From 18c0eba5cac589731404d074c42a4386f7e49fdf Mon Sep 17 00:00:00 2001 From: Jonathan Hodges <johodges@vt.edu> Date: Thu, 13 Apr 2023 15:08:46 -0400 Subject: [PATCH 01/31] Add WRITE_STL functionality for OBST. --- Manuals/FDS_User_Guide/FDS_User_Guide.tex | 21 ++-- Source/cons.f90 | 5 +- Source/dump.f90 | 124 +++++++++++++++++++++- Source/main.f90 | 5 + Source/prec.f90 | 3 + Source/read.f90 | 2 +- 6 files changed, 148 insertions(+), 12 deletions(-) diff --git a/Manuals/FDS_User_Guide/FDS_User_Guide.tex b/Manuals/FDS_User_Guide/FDS_User_Guide.tex index c7f1661fe29..bea8f6e70aa 100644 --- a/Manuals/FDS_User_Guide/FDS_User_Guide.tex +++ b/Manuals/FDS_User_Guide/FDS_User_Guide.tex @@ -5137,7 +5137,7 @@ \subsection{Catalysts} Some reactions require the presence of a specific molecule to stabilize the reaction rather than any species as in a third body reaction. An example is given below: \begin{equation}\label{eq:catalyst} - \mathrm{a \, X + b \, Y + \, Z \rightarrow X_aY_b + Z } + \mathrm{a \, X + b \, Y + \, Z \rightarrow X_aY_b + Z } \end{equation} A catalyst can be specified by listing the catalyst species twice in {\ct SPEC\_ID\_NU} and giving the {\ct NU} values for each side of the equation. The reaction will move forward in FDS using the net {\ct NU} and the default value for {\ct NU\_S} will be the left-hand side stoichiometric coefficient. For a reverse reaction, the value or {\ct NU\_S} for the catalyst will be the right-hand side stoichiometric coefficient. @@ -9291,6 +9291,10 @@ \section{Plot3D Static Data Dumps} Past versions of FDS (1-5) output Plot3D files by default. Now, you must specify the time interval between dumps using {\ct DT\_PL3D} on the {\ct DUMP} line. +\section{Stereolithography (STL) Geometry Dump} +\label{info:stl} + +Stereolithography (STL) is a commonly used file format in computer-aided design (CAD) programs. STL files represent the surface geometry of objects using a set of triangles. FDS will generate an STL representation of input obstructions for visualization in other software packages if {\ct WRITE\_STL=T} is included on the {\ct DUMP} line. \section{SMOKE3D: Realistic Smoke and Fire} \label{info:SMOKE3D} @@ -11250,6 +11254,7 @@ \section{\texorpdfstring{{\tt DUMP}}{DUMP} (Output Parameters)} {\ct STATUS\_FILES} & Logical & Section~\ref{info:DUMP} & & {\ct F} \\ \hline {\ct SUPPRESS\_DIAGNOSTICS} & Logical & Section~\ref{info:monitoring_progress} & & {\ct F} \\ \hline {\ct VELOCITY\_ERROR\_FILE} & Logical & Section~\ref{info:TIMING} & & {\ct F} \\ \hline +{\ct WRITE\_STL} & Logical & Section~\ref{info:Paraview} & & {\ct F} \\ \hline {\ct WRITE\_XYZ} & Logical & Section~\ref{info:PL3D} & & {\ct F} \\ \hline \end{longtable} @@ -13387,16 +13392,16 @@ \section{FDS HVAC I/O binary format} \label{inout:binhvac} The HVAC outputs under the namelist group {\ct HVAC} are written out unformatted to the file {\ct CHID.hvac}. These files are written out from {\ct dump.f90} with the following lines: \begin{lstlisting} - WRITE(LU_HVAC) N_NODE_OUT, N_NODE_QUANTITY, N_DUCT_OUT, N_DUCT_QUANTITY - WRITE(LU_HVAC) DUCT_CELL(1:N_DUCT_OUT) + WRITE(LU_HVAC) N_NODE_OUT, N_NODE_QUANTITY, N_DUCT_OUT, N_DUCT_QUANTITY + WRITE(LU_HVAC) DUCT_CELL(1:N_DUCT_OUT) - WRITE(LU_HVAC) TIME + WRITE(LU_HVAC) TIME DO N=1,N_NODE_OUT WRITE(LU_HVAC) OUTVAL_N(1:N_NODE_QUANTITY) ENDDO - DO N=1,N_DUCT_OUT - IF (DUCT(N)%N_CELLS > 0) THEN - DO N=1,DUCT(N)%N_CELLS + DO N=1,N_DUCT_OUT + IF (DUCT(N)%N_CELLS > 0) THEN + DO N=1,DUCT(N)%N_CELLS WRITE(LU_HVAC) OUTVAL_D(1:N_DUCT_QUANTITY) ENDDO ELSE @@ -13421,7 +13426,7 @@ \chapter{Predefined Species} This appendix lists all predefined species in FDS. If a species name ends in 'p' or 'm', this indicates the positive or negative charge state of that species. If a species ends in 's', this indicates the excited state of that species. This is typically written with a '*' as in CH$^*$. A 'Y in the Liquid column indicates that liquid properties are predefined, and a 'Y' in the Gibbs column indicates that Gibbs energy data is predefined. \begin{landscape} - \IfFileExists{spec_table.tex}{\input{spec_table.tex}}{\typeout{Error: Missing file spec\_table.tex}} + \IfFileExists{spec_table.tex}{\input{spec_table.tex}}{\typeout{Error: Missing file spec\_table.tex}} \end{landscape} diff --git a/Source/cons.f90 b/Source/cons.f90 index f0010cc0b73..18ee3aca03e 100644 --- a/Source/cons.f90 +++ b/Source/cons.f90 @@ -177,6 +177,7 @@ MODULE GLOBAL_CONSTANTS LOGICAL :: SUPPRESSION=.TRUE. !< Indicates if gas-phase combustion extinction is modeled LOGICAL :: ACCUMULATE_WATER=.FALSE. !< Indicates that integrated liquid outputs are specified LOGICAL :: WRITE_XYZ=.FALSE. !< Indicates that a Plot3D geometry file is specified by user +LOGICAL :: WRITE_STL=.FALSE. !< Indicates that a STL geometry file is specified by user LOGICAL :: CHECK_POISSON=.FALSE. !< Check the accuracy of the Poisson solver LOGICAL :: TWO_D=.FALSE. !< Perform a 2-D simulation LOGICAL :: SETUP_ONLY=.FALSE. !< Indicates that the calculation should be stopped before time-stepping @@ -523,7 +524,7 @@ MODULE GLOBAL_CONSTANTS LU_CATF=9 INTEGER :: LU_MASS,LU_HRR,LU_STEPS,LU_NOTREADY,LU_VELOCITY_ERROR,LU_CFL,LU_LINE=-1,LU_CUTCELL INTEGER :: LU_HISTOGRAM,LU_HVAC -INTEGER :: LU_GEOC=-1,LU_TGA,LU_INFO,LU_DEVC_CTRL=-1 +INTEGER :: LU_GEOC=-1,LU_TGA,LU_INFO,LU_DEVC_CTRL=-1,LU_STL INTEGER, ALLOCATABLE, DIMENSION(:) :: LU_PART,LU_PROF,LU_XYZ,LU_TERRAIN,LU_PL3D,LU_DEVC,LU_STATE,LU_CTRL,LU_CORE,LU_RESTART INTEGER, ALLOCATABLE, DIMENSION(:) :: LU_VEG_OUT,LU_GEOM,LU_CFACE_GEOM INTEGER :: LU_GEOM_TRAN @@ -534,7 +535,7 @@ MODULE GLOBAL_CONSTANTS CHARACTER(250) :: FN_INPUT='null' CHARACTER(80) :: FN_STOP='null',FN_CPU,FN_CFL,FN_OUTPUT='null' CHARACTER(80) :: FN_MASS,FN_HRR,FN_STEPS,FN_SMV,FN_END,FN_ERR,FN_NOTREADY,FN_VELOCITY_ERROR,FN_GIT -CHARACTER(80) :: FN_LINE,FN_HISTOGRAM,FN_CUTCELL,FN_TGA,FN_DEVC_CTRL,FN_HVAC +CHARACTER(80) :: FN_LINE,FN_HISTOGRAM,FN_CUTCELL,FN_TGA,FN_DEVC_CTRL,FN_HVAC,FN_STL CHARACTER(80), ALLOCATABLE, DIMENSION(:) :: FN_PART,FN_PROF,FN_XYZ,FN_TERRAIN,FN_PL3D,FN_DEVC,FN_STATE,FN_CTRL,FN_CORE,FN_RESTART CHARACTER(80), ALLOCATABLE, DIMENSION(:) :: FN_VEG_OUT,FN_GEOM, FN_CFACE_GEOM CHARACTER(80), ALLOCATABLE, DIMENSION(:,:) :: FN_SLCF,FN_SLCF_GEOM,FN_BNDF,FN_BNDF_GEOM,FN_BNDG, & diff --git a/Source/dump.f90 b/Source/dump.f90 index 938ff9885d3..3382e46364f 100644 --- a/Source/dump.f90 +++ b/Source/dump.f90 @@ -51,7 +51,7 @@ MODULE DUMP TIMINGS,FLUSH_GLOBAL_BUFFERS,FLUSH_LOCAL_BUFFERS,READ_RESTART,WRITE_DIAGNOSTICS, & WRITE_SMOKEVIEW_FILE,DUMP_MESH_OUTPUTS,UPDATE_GLOBAL_OUTPUTS,DUMP_DEVICES,DUMP_HRR,DUMP_MASS,DUMP_CONTROLS,& INITIALIZE_DIAGNOSTIC_FILE,DUMP_RESTART,DUMP_HVAC,& - DUMP_UVW,DUMP_GEOM,UPDATE_DEVICES_2,WRITE_DEVC_CTRL_LOG + DUMP_UVW,DUMP_GEOM,UPDATE_DEVICES_2,WRITE_DEVC_CTRL_LOG,WRITE_STL_FILE CONTAINS @@ -509,6 +509,11 @@ SUBROUTINE ASSIGN_FILE_NAMES FN_DEVC_CTRL = TRIM(CHID)//'_devc_ctrl_log.csv' ENDIF +IF (WRITE_STL) THEN + LU_STL = GET_FILE_NUMBER() + FN_STL = TRIM(CHID)//'.stl' +ENDIF + END SUBROUTINE ASSIGN_FILE_NAMES @@ -1403,6 +1408,123 @@ SUBROUTINE INITIALIZE_MESH_DUMPS(NM) T_USED(7) = T_USED(7) + CURRENT_TIME() - TNOW END SUBROUTINE INITIALIZE_MESH_DUMPS +SUBROUTINE WRITE_STL_FILE + ! Parts of this subroutine use conent from stack overflow + ! Original question: https://stackoverflow.com/questions/34144786 + ! User whos answer is integrated: https://stackoverflow.com/users/4621823/chw21 + !character(len=*), parameter :: fname = 'fds.stl' + INTEGER :: I,IOS,N,FACES(12, 3) + CHARACTER(LEN=80) :: title + REAL(FB) :: VERTICES(8,3), XB(6) + INTEGER(IB4) :: color(3), one + INTEGER(IB32) :: NUM_FACETS + + title = FN_STL + + FACES(1,:) = (/1,4,2/) + FACES(2,:) = (/2,4,3/) + FACES(3,:) = (/1,5,8/) + FACES(4,:) = (/1,8,4/) + FACES(5,:) = (/5,6,7/) + FACES(6,:) = (/5,7,8/) + FACES(7,:) = (/6,2,3/) + FACES(8,:) = (/6,3,7/) + FACES(9,:) = (/3,4,7/) + FACES(10,:) = (/4,8,7/) + FACES(11,:) = (/1,2,6/) + FACES(12,:) = (/1,6,5/) + + OPEN(UNIT=LU_STL, FILE=title, ACCESS='stream', STATUS='replace', & + ACTION='write', IOSTAT=IOS) + CALL check(IOS, 'open') + WRITE(LU_STL, IOStat=IOS) title + CALL check(IOS, 'write title') + NUM_FACETS = M%N_OBST*12 + WRITE(LU_STL, IOStat=IOS) NUM_FACETS + CALL check(IOS, 'write number of facets') + + DO N=1,M%N_OBST + OB=>M%OBSTRUCTION(N) + XB(:) = (/OB%X1,OB%X2,OB%Y1,OB%Y2,OB%Z1,OB%Z2/) + !color(:) = OB%SURF_INDEX(-1),OB%SURF_INDEX(1),OB%SURF_INDEX(-2),& + !OB%SURF_INDEX(2),OB%SURF_INDEX(-3),OB%SURF_INDEX(3) + VERTICES = get_vertices(XB) + + DO I=1,12 + !CALL write_facet_c(u, & + ! VERTICES(FACES(i,1),:), VERTICES(FACES(i,2),:), VERTICES(FACES(i,3),:), color) + CALL write_facet(LU_STL, & + VERTICES(FACES(I,1),:), VERTICES(FACES(I,2),:), VERTICES(FACES(I,3),:)) + END DO + + ENDDO + CLOSE(LU_STL, IOSTAT=IOS) + CALL check(IOS, 'close') +CONTAINS + + FUNCTION get_vertices(XB) + REAL(FB), INTENT(IN) :: XB(6) + REAL(FB) :: get_vertices(8,3) + get_vertices(1,:) = (/XB(1),XB(3),XB(5)/) + get_vertices(2,:) = (/XB(2),XB(3),XB(5)/) + get_vertices(3,:) = (/XB(2),XB(4),XB(5)/) + get_vertices(4,:) = (/XB(1),XB(4),XB(5)/) + get_vertices(5,:) = (/XB(1),XB(3),XB(6)/) + get_vertices(6,:) = (/XB(2),XB(3),XB(6)/) + get_vertices(7,:) = (/XB(2),XB(4),XB(6)/) + get_vertices(8,:) = (/XB(1),XB(4),XB(6)/) + END FUNCTION get_vertices + + SUBROUTINE check(IOS, operation) + IMPLICIT NONE + INTEGER, INTENT(IN) :: IOS + CHARACTER(LEN=*), INTENT(IN) :: operation + IF (IOS == 0) RETURN + WRITE(*, '(A, I0, 2A)') "Encountered error ", IOS, " while performing ", operation + STOP 1 + END SUBROUTINE check + + SUBROUTINE write_facet(u, vertex1, vertex2, vertex3) + IMPLICIT NONE + INTEGER, INTENT(IN) :: u + REAL(FB), DIMENSION(3), INTENT(IN) :: vertex1, vertex2, vertex3 + REAL(FB), DIMENSION(3) :: normal + INTEGER(IB16), PARAMETER :: zero = 0 + + normal = calc_normal(vertex1, vertex2, vertex3) + WRITE(u, IOSTAT=IOS) normal + CALL check(IOS, 'write normal') + WRITE(u, IOSTAT=IOS) vertex1 + CALL check(IOS, 'write vertex') + WRITE(u, IOSTAT=IOS) vertex2 + CALL check(IOS, 'write vertex') + WRITE(u, IOSTAT=IOS) vertex3 + CALL check(IOS, 'write vertex') + WRITE(u, IOSTAT=IOS) zero + CALL check(IOS, 'write zero') + END SUBROUTINE write_facet + + FUNCTION calc_normal(vec1, vec2, vec3) + IMPLICIT NONE + REAL(FB), DIMENSION(3), INTENT(IN) :: vec1, vec2, vec3 + REAL(FB), DIMENSION(3) :: calc_normal + REAL(FB), DIMENSION(3) :: d1, d2 + d1 = vec2 - vec1 + d2 = vec3 - vec1 + calc_normal(1) = d1(2) * d2(3) - d1(3) * d2(2) + calc_normal(2) = d1(3) * d2(1) - d1(1) * d2(3) + calc_normal(3) = d1(1) * d2(2) - d1(2) * d2(1) + calc_normal = calc_normal / norm(calc_normal) + END FUNCTION calc_normal + + FUNCTION norm(vec) + IMPLICIT NONE + REAL(FB), DIMENSION(3), INTENT(IN) :: vec + REAL(FB) :: norm + norm = sqrt(vec(1)**2 + vec(2)**2 + vec(3)**2) + END FUNCTION norm + +END SUBROUTINE WRITE_STL_FILE !> \brief Write information into the Smokeview (.smv) file diff --git a/Source/main.f90 b/Source/main.f90 index 986e410227c..9304bfbd819 100644 --- a/Source/main.f90 +++ b/Source/main.f90 @@ -146,6 +146,11 @@ PROGRAM FDS IF (SHARED_FILE_SYSTEM) CALL MPI_BARRIER(MPI_COMM_WORLD, IERR) ENDDO +! Write STL file if required +IF (WRITE_STL) THEN + CALL WRITE_STL_FILE +ENDIF + ! Shut down the run if it is only for checking the set up IF (SETUP_ONLY .AND. .NOT.CHECK_MESH_ALIGNMENT) STOP_STATUS = SETUP_ONLY_STOP diff --git a/Source/prec.f90 b/Source/prec.f90 index ec20e2bf335..8749a160df0 100644 --- a/Source/prec.f90 +++ b/Source/prec.f90 @@ -6,6 +6,9 @@ MODULE PRECISION_PARAMETERS INTEGER, PARAMETER :: FB = SELECTED_REAL_KIND(6) !< Precision of "Four Byte" reals INTEGER, PARAMETER :: EB = SELECTED_REAL_KIND(12) !< Precision of "Eight Byte" reals +INTEGER, PARAMETER :: IB4 = SELECTED_INT_KIND(1) !< Precision of "One Byte" ints +INTEGER, PARAMETER :: IB16 = SELECTED_INT_KIND(3) !< Precision of "Two Byte" ints +INTEGER, PARAMETER :: IB32 = SELECTED_INT_KIND(6) !< Precision of "Four Byte" ints INTEGER, PARAMETER :: MAX_LPC=20 !< Maximum number of declared particle classes INTEGER, PARAMETER :: MAX_SPECIES=20 !< Maximum number of declared species INTEGER, PARAMETER :: MAX_LAYERS=20 !< Maximum number of solid material layers diff --git a/Source/read.f90 b/Source/read.f90 index 83f4efe2e90..37cec60cee6 100644 --- a/Source/read.f90 +++ b/Source/read.f90 @@ -2188,7 +2188,7 @@ SUBROUTINE READ_DUMP RAMP_BNDF,RAMP_CPU,RAMP_CTRL,RAMP_DEVC,RAMP_FLUSH,RAMP_GEOM,RAMP_HRR,RAMP_HVAC,RAMP_ISOF,RAMP_MASS,& RAMP_PART,RAMP_PL3D,RAMP_PROF,RAMP_RADF,RAMP_RESTART,RAMP_SLCF,RAMP_SL3D,RAMP_SMOKE3D,RAMP_UVW,& RENDER_FILE,SIG_FIGS,SIG_FIGS_EXP,SMOKE3D,STATUS_FILES,SUPPRESS_DIAGNOSTICS,& - TURB_INIT_CLOCK,VELOCITY_ERROR_FILE,WRITE_XYZ + TURB_INIT_CLOCK,VELOCITY_ERROR_FILE,WRITE_XYZ,WRITE_STL ! Set defaults From c8f32655f955a727243d05c4a680f0dea9fb7e93 Mon Sep 17 00:00:00 2001 From: Jonathan Hodges <johodges@vt.edu> Date: Thu, 13 Apr 2023 15:54:04 -0400 Subject: [PATCH 02/31] Fix WRITE_STL for multiple meshes. --- Source/dump.f90 | 38 ++++++++++++++++++++++---------------- 1 file changed, 22 insertions(+), 16 deletions(-) diff --git a/Source/dump.f90 b/Source/dump.f90 index 3382e46364f..0a8685fb1d2 100644 --- a/Source/dump.f90 +++ b/Source/dump.f90 @@ -1413,7 +1413,7 @@ SUBROUTINE WRITE_STL_FILE ! Original question: https://stackoverflow.com/questions/34144786 ! User whos answer is integrated: https://stackoverflow.com/users/4621823/chw21 !character(len=*), parameter :: fname = 'fds.stl' - INTEGER :: I,IOS,N,FACES(12, 3) + INTEGER :: I,IOS,N,NM,FACES(12, 3) CHARACTER(LEN=80) :: title REAL(FB) :: VERTICES(8,3), XB(6) INTEGER(IB4) :: color(3), one @@ -1439,24 +1439,30 @@ SUBROUTINE WRITE_STL_FILE CALL check(IOS, 'open') WRITE(LU_STL, IOStat=IOS) title CALL check(IOS, 'write title') - NUM_FACETS = M%N_OBST*12 + + NUM_FACETS = 0 + DO NM=1,NMESHES + M => MESHES(NM) + NUM_FACETS = NUM_FACETS + M%N_OBST*12 + END DO WRITE(LU_STL, IOStat=IOS) NUM_FACETS CALL check(IOS, 'write number of facets') - - DO N=1,M%N_OBST - OB=>M%OBSTRUCTION(N) - XB(:) = (/OB%X1,OB%X2,OB%Y1,OB%Y2,OB%Z1,OB%Z2/) - !color(:) = OB%SURF_INDEX(-1),OB%SURF_INDEX(1),OB%SURF_INDEX(-2),& - !OB%SURF_INDEX(2),OB%SURF_INDEX(-3),OB%SURF_INDEX(3) - VERTICES = get_vertices(XB) - - DO I=1,12 - !CALL write_facet_c(u, & - ! VERTICES(FACES(i,1),:), VERTICES(FACES(i,2),:), VERTICES(FACES(i,3),:), color) - CALL write_facet(LU_STL, & - VERTICES(FACES(I,1),:), VERTICES(FACES(I,2),:), VERTICES(FACES(I,3),:)) + DO NM=1,NMESHES + M => MESHES(NM) + DO N=1,M%N_OBST + OB=>M%OBSTRUCTION(N) + XB(:) = (/OB%X1,OB%X2,OB%Y1,OB%Y2,OB%Z1,OB%Z2/) + !color(:) = OB%SURF_INDEX(-1),OB%SURF_INDEX(1),OB%SURF_INDEX(-2),& + !OB%SURF_INDEX(2),OB%SURF_INDEX(-3),OB%SURF_INDEX(3) + VERTICES = get_vertices(XB) + + DO I=1,12 + !CALL write_facet_c(u, & + ! VERTICES(FACES(i,1),:), VERTICES(FACES(i,2),:), VERTICES(FACES(i,3),:), color) + CALL write_facet(LU_STL, & + VERTICES(FACES(I,1),:), VERTICES(FACES(I,2),:), VERTICES(FACES(I,3),:)) + END DO END DO - ENDDO CLOSE(LU_STL, IOSTAT=IOS) CALL check(IOS, 'close') From d99d6f8c3d6f9375eed8085cbd05593ee24d4a30 Mon Sep 17 00:00:00 2001 From: Jonathan Hodges <johodges@vt.edu> Date: Thu, 13 Apr 2023 16:07:57 -0400 Subject: [PATCH 03/31] Fix section reference for WRITE_STL. --- Manuals/FDS_User_Guide/FDS_User_Guide.tex | 2 +- Source/dump.f90 | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/Manuals/FDS_User_Guide/FDS_User_Guide.tex b/Manuals/FDS_User_Guide/FDS_User_Guide.tex index 431517db622..c7fe46672cb 100644 --- a/Manuals/FDS_User_Guide/FDS_User_Guide.tex +++ b/Manuals/FDS_User_Guide/FDS_User_Guide.tex @@ -11263,7 +11263,7 @@ \section{\texorpdfstring{{\tt DUMP}}{DUMP} (Output Parameters)} {\ct STATUS\_FILES} & Logical & Section~\ref{info:DUMP} & & {\ct F} \\ \hline {\ct SUPPRESS\_DIAGNOSTICS} & Logical & Section~\ref{info:monitoring_progress} & & {\ct F} \\ \hline {\ct VELOCITY\_ERROR\_FILE} & Logical & Section~\ref{info:TIMING} & & {\ct F} \\ \hline -{\ct WRITE\_STL} & Logical & Section~\ref{info:Paraview} & & {\ct F} \\ \hline +{\ct WRITE\_STL} & Logical & Section~\ref{info:stl} & & {\ct F} \\ \hline {\ct WRITE\_XYZ} & Logical & Section~\ref{info:PL3D} & & {\ct F} \\ \hline \end{longtable} diff --git a/Source/dump.f90 b/Source/dump.f90 index 0a8685fb1d2..3524011fc5b 100644 --- a/Source/dump.f90 +++ b/Source/dump.f90 @@ -1409,7 +1409,7 @@ SUBROUTINE INITIALIZE_MESH_DUMPS(NM) END SUBROUTINE INITIALIZE_MESH_DUMPS SUBROUTINE WRITE_STL_FILE - ! Parts of this subroutine use conent from stack overflow + ! Parts of this subroutine use content from stack overflow ! Original question: https://stackoverflow.com/questions/34144786 ! User whos answer is integrated: https://stackoverflow.com/users/4621823/chw21 !character(len=*), parameter :: fname = 'fds.stl' From 618493acc1af999cd9eb2cd941bfe8e0aa16872b Mon Sep 17 00:00:00 2001 From: Jonathan Hodges <johodges@vt.edu> Date: Wed, 3 May 2023 18:35:39 -0400 Subject: [PATCH 04/31] Add geoms to WRITE_STL in dump. --- Source/dump.f90 | 22 +++++++++++++++++++++- 1 file changed, 21 insertions(+), 1 deletion(-) diff --git a/Source/dump.f90 b/Source/dump.f90 index 4727fa456d9..18de551d33b 100644 --- a/Source/dump.f90 +++ b/Source/dump.f90 @@ -27,6 +27,7 @@ MODULE DUMP CHARACTER(80) :: TCFORM LOGICAL :: EX,DRY,OPN,FROM_BNDF=.FALSE. +TYPE (GEOMETRY_TYPE), POINTER :: G=>NULL() TYPE (MESH_TYPE), POINTER :: M=>NULL() TYPE (LAGRANGIAN_PARTICLE_TYPE), POINTER :: LP=>NULL() TYPE (OBSTRUCTION_TYPE), POINTER :: OB=>NULL() @@ -1413,9 +1414,10 @@ SUBROUTINE WRITE_STL_FILE ! Original question: https://stackoverflow.com/questions/34144786 ! User whos answer is integrated: https://stackoverflow.com/users/4621823/chw21 !character(len=*), parameter :: fname = 'fds.stl' - INTEGER :: I,IOS,N,NM,FACES(12, 3) + INTEGER :: I,IOS,N,NM,FACES(12, 3),GEOM_VERTICES_IDS(1,3) CHARACTER(LEN=80) :: title REAL(FB) :: VERTICES(8,3), XB(6) + REAL(FB) :: GEOM_VERTICES(3,3) INTEGER(IB4) :: color(3), one INTEGER(IB32) :: NUM_FACETS @@ -1445,6 +1447,12 @@ SUBROUTINE WRITE_STL_FILE M => MESHES(NM) NUM_FACETS = NUM_FACETS + M%N_OBST*12 END DO + + DO I= 1,N_GEOMETRY + G=>GEOMETRY(I) + NUM_FACETS = NUM_FACETS + G%N_FACES + END DO + WRITE(LU_STL, IOStat=IOS) NUM_FACETS CALL check(IOS, 'write number of facets') DO NM=1,NMESHES @@ -1464,6 +1472,18 @@ SUBROUTINE WRITE_STL_FILE END DO END DO ENDDO + + DO I= 1,N_GEOMETRY + G=>GEOMETRY(I) + DO N=1,G%N_FACES + GEOM_VERTICES_IDS(1,:) = G%FACES((N-1)*3+1:(N-1)*3 + 3) + GEOM_VERTICES(1,:) = G%VERTS((GEOM_VERTICES_IDS(1,1)-1)*3+1:(GEOM_VERTICES_IDS(1,1)-1)*3+3) + GEOM_VERTICES(2,:) = G%VERTS((GEOM_VERTICES_IDS(1,2)-1)*3+1:(GEOM_VERTICES_IDS(1,2)-1)*3+3) + GEOM_VERTICES(3,:) = G%VERTS((GEOM_VERTICES_IDS(1,3)-1)*3+1:(GEOM_VERTICES_IDS(1,3)-1)*3+3) + CALL write_facet(LU_STL, GEOM_VERTICES(1,:), GEOM_VERTICES(2,:), GEOM_VERTICES(3,:)) + ENDDO + ENDDO + CLOSE(LU_STL, IOSTAT=IOS) CALL check(IOS, 'close') CONTAINS From e1e7551f5ea7178b47f01b35abb054bbfb3adcaf Mon Sep 17 00:00:00 2001 From: rmcdermo <randy.mcdermott@gmail.com> Date: Mon, 8 May 2023 16:59:29 -0400 Subject: [PATCH 05/31] FDS Source: fix formatting and unused warning --- Source/dump.f90 | 133 +++++++++++++++++++++++++----------------------- 1 file changed, 69 insertions(+), 64 deletions(-) diff --git a/Source/dump.f90 b/Source/dump.f90 index 9155b7f8c77..601d3f4d630 100644 --- a/Source/dump.f90 +++ b/Source/dump.f90 @@ -1409,19 +1409,23 @@ SUBROUTINE INITIALIZE_MESH_DUMPS(NM) T_USED(7) = T_USED(7) + CURRENT_TIME() - TNOW END SUBROUTINE INITIALIZE_MESH_DUMPS + SUBROUTINE WRITE_STL_FILE ! Parts of this subroutine use content from stack overflow ! Original question: https://stackoverflow.com/questions/34144786 ! User whos answer is integrated: https://stackoverflow.com/users/4621823/chw21 !character(len=*), parameter :: fname = 'fds.stl' INTEGER :: I,IOS,N,NM,FACES(12, 3),GEOM_VERTICES_IDS(1,3) - CHARACTER(LEN=80) :: title + CHARACTER(LEN=80) :: TITLE REAL(FB) :: VERTICES(8,3), XB(6) REAL(FB) :: GEOM_VERTICES(3,3) - INTEGER(IB4) :: color(3), one + INTEGER(IB4) :: COLOR(3), ONE INTEGER(IB32) :: NUM_FACETS + + COLOR = (/0,0,0/) + ONE = 1 - title = FN_STL + TITLE = FN_STL FACES(1,:) = (/1,4,2/) FACES(2,:) = (/2,4,3/) @@ -1436,11 +1440,11 @@ SUBROUTINE WRITE_STL_FILE FACES(11,:) = (/1,2,6/) FACES(12,:) = (/1,6,5/) - OPEN(UNIT=LU_STL, FILE=title, ACCESS='stream', STATUS='replace', & + OPEN(UNIT=LU_STL, FILE=TITLE, ACCESS='stream', STATUS='replace', & ACTION='write', IOSTAT=IOS) - CALL check(IOS, 'open') - WRITE(LU_STL, IOStat=IOS) title - CALL check(IOS, 'write title') + CALL CHECK(IOS, 'open') + WRITE(LU_STL, IOStat=IOS) TITLE + CALL CHECK(IOS, 'write title') NUM_FACETS = 0 DO NM=1,NMESHES @@ -1454,20 +1458,20 @@ SUBROUTINE WRITE_STL_FILE END DO WRITE(LU_STL, IOStat=IOS) NUM_FACETS - CALL check(IOS, 'write number of facets') + CALL CHECK(IOS, 'write number of facets') DO NM=1,NMESHES M => MESHES(NM) DO N=1,M%N_OBST OB=>M%OBSTRUCTION(N) XB(:) = (/OB%X1,OB%X2,OB%Y1,OB%Y2,OB%Z1,OB%Z2/) - !color(:) = OB%SURF_INDEX(-1),OB%SURF_INDEX(1),OB%SURF_INDEX(-2),& + !COLOR(:) = OB%SURF_INDEX(-1),OB%SURF_INDEX(1),OB%SURF_INDEX(-2),& !OB%SURF_INDEX(2),OB%SURF_INDEX(-3),OB%SURF_INDEX(3) VERTICES = get_vertices(XB) DO I=1,12 - !CALL write_facet_c(u, & + !CALL write_facet_c(U, & ! VERTICES(FACES(i,1),:), VERTICES(FACES(i,2),:), VERTICES(FACES(i,3),:), color) - CALL write_facet(LU_STL, & + CALL WRITE_FACET(LU_STL, & VERTICES(FACES(I,1),:), VERTICES(FACES(I,2),:), VERTICES(FACES(I,3),:)) END DO END DO @@ -1480,75 +1484,76 @@ SUBROUTINE WRITE_STL_FILE GEOM_VERTICES(1,:) = G%VERTS((GEOM_VERTICES_IDS(1,1)-1)*3+1:(GEOM_VERTICES_IDS(1,1)-1)*3+3) GEOM_VERTICES(2,:) = G%VERTS((GEOM_VERTICES_IDS(1,2)-1)*3+1:(GEOM_VERTICES_IDS(1,2)-1)*3+3) GEOM_VERTICES(3,:) = G%VERTS((GEOM_VERTICES_IDS(1,3)-1)*3+1:(GEOM_VERTICES_IDS(1,3)-1)*3+3) - CALL write_facet(LU_STL, GEOM_VERTICES(1,:), GEOM_VERTICES(2,:), GEOM_VERTICES(3,:)) + CALL WRITE_FACET(LU_STL, GEOM_VERTICES(1,:), GEOM_VERTICES(2,:), GEOM_VERTICES(3,:)) ENDDO ENDDO CLOSE(LU_STL, IOSTAT=IOS) - CALL check(IOS, 'close') + CALL CHECK(IOS, 'close') + CONTAINS - FUNCTION get_vertices(XB) + FUNCTION GET_VERTICES(XB) REAL(FB), INTENT(IN) :: XB(6) - REAL(FB) :: get_vertices(8,3) - get_vertices(1,:) = (/XB(1),XB(3),XB(5)/) - get_vertices(2,:) = (/XB(2),XB(3),XB(5)/) - get_vertices(3,:) = (/XB(2),XB(4),XB(5)/) - get_vertices(4,:) = (/XB(1),XB(4),XB(5)/) - get_vertices(5,:) = (/XB(1),XB(3),XB(6)/) - get_vertices(6,:) = (/XB(2),XB(3),XB(6)/) - get_vertices(7,:) = (/XB(2),XB(4),XB(6)/) - get_vertices(8,:) = (/XB(1),XB(4),XB(6)/) - END FUNCTION get_vertices + REAL(FB) :: GET_VERTICES(8,3) + GET_VERTICES(1,:) = (/XB(1),XB(3),XB(5)/) + GET_VERTICES(2,:) = (/XB(2),XB(3),XB(5)/) + GET_VERTICES(3,:) = (/XB(2),XB(4),XB(5)/) + GET_VERTICES(4,:) = (/XB(1),XB(4),XB(5)/) + GET_VERTICES(5,:) = (/XB(1),XB(3),XB(6)/) + GET_VERTICES(6,:) = (/XB(2),XB(3),XB(6)/) + GET_VERTICES(7,:) = (/XB(2),XB(4),XB(6)/) + GET_VERTICES(8,:) = (/XB(1),XB(4),XB(6)/) + END FUNCTION GET_VERTICES - SUBROUTINE check(IOS, operation) + SUBROUTINE CHECK(IOS, OPERATION) IMPLICIT NONE INTEGER, INTENT(IN) :: IOS - CHARACTER(LEN=*), INTENT(IN) :: operation + CHARACTER(LEN=*), INTENT(IN) :: OPERATION IF (IOS == 0) RETURN - WRITE(*, '(A, I0, 2A)') "Encountered error ", IOS, " while performing ", operation + WRITE(LU_ERR, '(A, I0, 2A)') "Encountered error ", IOS, " while performing ", OPERATION STOP 1 - END SUBROUTINE check + END SUBROUTINE CHECK - SUBROUTINE write_facet(u, vertex1, vertex2, vertex3) + SUBROUTINE WRITE_FACET(U, VERTEX1, VERTEX2, VERTEX3) IMPLICIT NONE - INTEGER, INTENT(IN) :: u - REAL(FB), DIMENSION(3), INTENT(IN) :: vertex1, vertex2, vertex3 - REAL(FB), DIMENSION(3) :: normal - INTEGER(IB16), PARAMETER :: zero = 0 - - normal = calc_normal(vertex1, vertex2, vertex3) - WRITE(u, IOSTAT=IOS) normal - CALL check(IOS, 'write normal') - WRITE(u, IOSTAT=IOS) vertex1 - CALL check(IOS, 'write vertex') - WRITE(u, IOSTAT=IOS) vertex2 - CALL check(IOS, 'write vertex') - WRITE(u, IOSTAT=IOS) vertex3 - CALL check(IOS, 'write vertex') - WRITE(u, IOSTAT=IOS) zero - CALL check(IOS, 'write zero') - END SUBROUTINE write_facet - - FUNCTION calc_normal(vec1, vec2, vec3) + INTEGER, INTENT(IN) :: U + REAL(FB), DIMENSION(3), INTENT(IN) :: VERTEX1, VERTEX2, VERTEX3 + REAL(FB), DIMENSION(3) :: NORMAL + INTEGER(IB16), PARAMETER :: ZERO = 0 + + NORMAL = CALC_NORMAL(VERTEX1, VERTEX2, VERTEX3) + WRITE(U, IOSTAT=IOS) NORMAL + CALL CHECK(IOS, 'WRITE NORMAL') + WRITE(U, IOSTAT=IOS) VERTEX1 + CALL CHECK(IOS, 'WRITE VERTEX') + WRITE(U, IOSTAT=IOS) VERTEX2 + CALL CHECK(IOS, 'WRITE VERTEX') + WRITE(U, IOSTAT=IOS) VERTEX3 + CALL CHECK(IOS, 'WRITE VERTEX') + WRITE(U, IOSTAT=IOS) ZERO + CALL CHECK(IOS, 'WRITE ZERO') + END SUBROUTINE WRITE_FACET + + FUNCTION CALC_NORMAL(VEC1, VEC2, VEC3) IMPLICIT NONE - REAL(FB), DIMENSION(3), INTENT(IN) :: vec1, vec2, vec3 - REAL(FB), DIMENSION(3) :: calc_normal - REAL(FB), DIMENSION(3) :: d1, d2 - d1 = vec2 - vec1 - d2 = vec3 - vec1 - calc_normal(1) = d1(2) * d2(3) - d1(3) * d2(2) - calc_normal(2) = d1(3) * d2(1) - d1(1) * d2(3) - calc_normal(3) = d1(1) * d2(2) - d1(2) * d2(1) - calc_normal = calc_normal / norm(calc_normal) - END FUNCTION calc_normal - - FUNCTION norm(vec) + REAL(FB), DIMENSION(3), INTENT(IN) :: VEC1, VEC2, VEC3 + REAL(FB), DIMENSION(3) :: CALC_NORMAL + REAL(FB), DIMENSION(3) :: D1, D2 + D1 = VEC2 - VEC1 + D2 = VEC3 - VEC1 + CALC_NORMAL(1) = D1(2) * D2(3) - D1(3) * D2(2) + CALC_NORMAL(2) = D1(3) * D2(1) - D1(1) * D2(3) + CALC_NORMAL(3) = D1(1) * D2(2) - D1(2) * D2(1) + CALC_NORMAL = CALC_NORMAL / NORM(CALC_NORMAL) + END FUNCTION CALC_NORMAL + + FUNCTION NORM(VEC) IMPLICIT NONE - REAL(FB), DIMENSION(3), INTENT(IN) :: vec - REAL(FB) :: norm - norm = sqrt(vec(1)**2 + vec(2)**2 + vec(3)**2) - END FUNCTION norm + REAL(FB), DIMENSION(3), INTENT(IN) :: VEC + REAL(FB) :: NORM + NORM = SQRT(VEC(1)**2 + VEC(2)**2 + VEC(3)**2) + END FUNCTION NORM END SUBROUTINE WRITE_STL_FILE From 19f13b804313c8fb9c12409437c3874768a0db6c Mon Sep 17 00:00:00 2001 From: johodges <johodges@vt.edu> Date: Wed, 20 Dec 2023 16:45:08 -0500 Subject: [PATCH 06/31] add export_to_vtk.py to utilities --- Utilities/Python/scripts/export_to_vtk.py | 134 ++++++++++++++++++++++ 1 file changed, 134 insertions(+) create mode 100644 Utilities/Python/scripts/export_to_vtk.py diff --git a/Utilities/Python/scripts/export_to_vtk.py b/Utilities/Python/scripts/export_to_vtk.py new file mode 100644 index 00000000000..4091097a093 --- /dev/null +++ b/Utilities/Python/scripts/export_to_vtk.py @@ -0,0 +1,134 @@ +import pyfdstools as fds +import os, glob, sys, argparse +import numpy as np + +if __name__ == '__main__': + + args = sys.argv + systemPath = os.path.dirname(os.path.abspath(__file__)) + + filename = 'export_to_vtk.py' + + availableArguments = "--help\n" + availableArguments = availableArguments + "--all Outputs all FDS outputs to VTK\n" + availableArguments = availableArguments + "--binary Selects whether VTK files are ASCIi or Binary\n" + availableArguments = availableArguments + "--bnde Exports BNDE files to VTK, default False\n" + availableArguments = availableArguments + "--bndf Exports BNDF files to VTK, default False\n" + availableArguments = availableArguments + "--chid CHID of the FDS case, defaults to basename of the first .fds file in dir\n" + availableArguments = availableArguments + "--clean Deletes VTK and related files from dir prior to run\n" + availableArguments = availableArguments + "--indir Directory of the FDS output files, defaults to current working directory\n" + availableArguments = availableArguments + "--outdir Directory of the VTK files, defaults to current working directory\n" + availableArguments = availableArguments + '--times Establishes the time interval to export data [start time, end time, NFRAMES]\n' + availableArguments = availableArguments + "--prt5 Exports PRT5 files to VTK, default False\n" + availableArguments = availableArguments + "--sl2d Exports SL2D files to VTK, default False\n" + availableArguments = availableArguments + "--sl3d Exports SL3D files to VTK, default False\n" + availableArguments = availableArguments + "--s3d Exports S3D files to VTK, default False\n" + availableArguments = availableArguments + "--stl Generates STL file based on geometry, default True" + + parser = argparse.ArgumentParser() + parser.add_argument('call') + parser.add_argument('--all', action='store_true', default=False, help='Outputs all FDS outputs to VTK, default False') + parser.add_argument('--binary', action='store_true', default=False, help='Selects whether VTK files are ASCII or Binary, default ASCII') + parser.add_argument('--bnde', action='store_true', default=False, help='Exports BNDE files to VTK, default False') + parser.add_argument('--bndf', action='store_true', default=False, help='Exports BNDF files to VTK, default False') + parser.add_argument('--chid', nargs=1, default=[], help='CHID of the FDS case, defaults to basename of the first .fds file in dir') + parser.add_argument('--clean', action='store_true', help='Deletes VTK and related files from dir prior to run') + parser.add_argument('--indir', nargs=1, default=[], help='Directory of the FDS output files, defaults to current working directory') + parser.add_argument('--outdir', nargs=1, default=[], help='Directory of the VTK output files, defaults to current working directory') + parser.add_argument('--prt5', action='store_true', default=False, help='Exports PRT5 files to VTK, default False') + parser.add_argument('--sl2d', action='store_true', default=False, help='Exports SL2D files to VTK, default False') + parser.add_argument('--sl3d', action='store_true', default=False, help='Exports SL3D files to VTK, default False') + parser.add_argument('--s3d', action='store_true', default=False, help='Exports S3D files to VTK, default False') + parser.add_argument('--stl', action='store_true', default=False, help='Disables export of STL file, default True') + parser.add_argument('--times', nargs=3, default=[], help='Establishes the time interval to export data [start time, end time, NFRAMES]') + #parser.add_argument('--help', action='store_true', default=False) + + if len(args) == 1: + sys.exit("Available arguments\n%s"%(availableArguments)) + + cmdargs = parser.parse_args(args) + + if len(cmdargs.indir) == 0: + print("Warning, no input directory was provided, assuming the script directory.") + rdir = os.getcwd() + os.sep + else: + if os.path.isabs(cmdargs.indir[0]): + rdir = cmdargs.indir[0] + os.sep + else: + rdir = os.path.abspath(cmdargs.indir[0]) + os.sep + if len(cmdargs.outdir) == 0: + print("Warning, no input directory was provided, assuming the script directory.") + odir = os.getcwd() + os.sep + else: + if os.spath.isabs(cmdargs.outdir[0]): + odir = cmdargs.outdir[0] + os.sep + else: + odir = os.path.abspath(cmd.args.outdir[0]) + os.sep + + if len(cmdargs.chid) == 0: + print("Warning, no chid was provided, assuming the namespace of the fds file.") + fdsFiles = fds.getFileList(rdir, '', 'fds') + if len(fdsFiles) == 0: + sys.exit('No fds files found in %s.'%(rdir)) + if len(fdsFiles) > 1: + print("Warning, multiple fds files found, assuming %s is correct."%(fdsFiles[0])) + chid = os.path.basename(fdsFiles[0]).replace('.fds','') + print('CHID = %s'%(chid)) + else: + chid = cmdargs.chid[0] + + if cmdargs.clean: + for f in glob.glob(odir + '*.vtr'): + os.remove(f) + for f in glob.glob(odir + '*.pvtr'): + os.remove(f) + for f in glob.glob(odir + '*.vti'): + os.remove(f) + for f in glob.glob(odir + '*.pvti'): + os.remove(f) + for f in glob.glob(odir + '*.vtp'): + os.remove(f) + for f in glob.glob(odir + '*.pvtp'): + os.remove(f) + + if cmdargs.all: + cmdargs.sl2d = True + cmdargs.sl3d = True + cmdargs.s3d = True + cmdargs.bndf = True + cmdargs.bnde = True + cmdargs.prt5 = True + + if len(cmdargs.times) == 0: + outTimes = None + else: + outTimes = np.linspace(float(cmdargs.times[0]), float(cmdargs.times[1]), int(cmdargs.times[2])) + + if not cmdargs.stl: + fds.obstToStl(rdir, chid) + + if cmdargs.sl2d: + print("Converting SL2D to VTK...") + fds.exportSl2dDataToVtk(chid, rdir, outtimes=outTimes, binary=cmdargs.binary) + + if cmdargs.sl3d: + print("Converting SL3D to VTK...") + fds.exportSl3dDataToVtk(chid, rdir, outtimes=outTimes, binary=cmdargs.binary) + + if cmdargs.s3d: + print("Converting S3D to VTK...") + fds.exportS3dDataToVtk(chid, rdir, outtimes=outTimes, binary=cmdargs.binary) + + if cmdargs.bndf: + print("Converting BNDF to VTK...") + fds.exportBndfDataToVtk(chid, rdir, outtimes=outTimes, binary=cmdargs.binary) + + if cmdargs.bnde: + print("Converting BNDE to VTK...") + fds.exportBndeDataToVtk(chid, rdir, outtimes=outTimes, binary=cmdargs.binary) + + if cmdargs.prt5: + print("Converting PRT5 to VTK...") + fds.exportPrt5DataToVtk(chid, rdir, outtimes=outTimes, binary=cmdargs.binary) + + From d3ae14b1a3eaa94cdeb59f978c32570241750169 Mon Sep 17 00:00:00 2001 From: johodges <johodges@vt.edu> Date: Fri, 22 Dec 2023 16:49:34 -0500 Subject: [PATCH 07/31] small fix in cmdargs --- Utilities/Python/scripts/export_to_vtk.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Utilities/Python/scripts/export_to_vtk.py b/Utilities/Python/scripts/export_to_vtk.py index 4091097a093..dbe519532af 100644 --- a/Utilities/Python/scripts/export_to_vtk.py +++ b/Utilities/Python/scripts/export_to_vtk.py @@ -63,7 +63,7 @@ if os.spath.isabs(cmdargs.outdir[0]): odir = cmdargs.outdir[0] + os.sep else: - odir = os.path.abspath(cmd.args.outdir[0]) + os.sep + odir = os.path.abspath(cmdargs.outdir[0]) + os.sep if len(cmdargs.chid) == 0: print("Warning, no chid was provided, assuming the namespace of the fds file.") From 5f3b2f8f4133096118a311c3695eb248ec27d4b9 Mon Sep 17 00:00:00 2001 From: Jonathan Hodges <johodges@vt.edu> Date: Sat, 23 Dec 2023 18:53:38 -0500 Subject: [PATCH 08/31] add vtk write for 3d slice --- Source/cons.f90 | 7 ++-- Source/dump.f90 | 87 ++++++++++++++++++++++++++++++++++++++++++++----- Source/read.f90 | 8 +++-- 3 files changed, 88 insertions(+), 14 deletions(-) diff --git a/Source/cons.f90 b/Source/cons.f90 index 811c1e573c1..92eccb74528 100644 --- a/Source/cons.f90 +++ b/Source/cons.f90 @@ -760,10 +760,11 @@ MODULE OUTPUT_CLOCKS INTEGER :: RAMP_SPEC_INDEX=0 !< Ramp index for species file time series REAL(EB), ALLOCATABLE, DIMENSION(:) :: BNDF_CLOCK, CPU_CLOCK,CTRL_CLOCK,DEVC_CLOCK,FLSH_CLOCK,GEOM_CLOCK, HRR_CLOCK,HVAC_CLOCK,& ISOF_CLOCK,MASS_CLOCK,PART_CLOCK,PL3D_CLOCK,PROF_CLOCK,RADF_CLOCK,RSRT_CLOCK,& - SLCF_CLOCK,SL3D_CLOCK,SM3D_CLOCK,UVW_CLOCK ,TMP_CLOCK ,SPEC_CLOCK + SLCF_CLOCK,SL3D_CLOCK,SM3D_CLOCK,UVW_CLOCK ,TMP_CLOCK ,SPEC_CLOCK,VTK_CLOCK INTEGER, ALLOCATABLE, DIMENSION(:) :: BNDF_COUNTER, CPU_COUNTER,CTRL_COUNTER,DEVC_COUNTER,FLSH_COUNTER,GEOM_COUNTER, HRR_COUNTER,& HVAC_COUNTER,ISOF_COUNTER,MASS_COUNTER,PART_COUNTER,PL3D_COUNTER,PROF_COUNTER,RADF_COUNTER,& - RSRT_COUNTER,SLCF_COUNTER,SL3D_COUNTER,SM3D_COUNTER,UVW_COUNTER ,TMP_COUNTER ,SPEC_COUNTER + RSRT_COUNTER,SLCF_COUNTER,SL3D_COUNTER,SM3D_COUNTER,UVW_COUNTER ,TMP_COUNTER ,SPEC_COUNTER,& + VTK_COUNTER REAL(EB) :: TURB_INIT_CLOCK=-1.E10_EB REAL(EB) :: MMS_TIMER=1.E10_EB REAL(EB) :: DT_SLCF,DT_BNDF,DT_DEVC,DT_PL3D,DT_PART,DT_RESTART,DT_ISOF,DT_HRR,DT_HVAC,DT_MASS,DT_PROF,DT_CTRL,& @@ -773,7 +774,7 @@ MODULE OUTPUT_CLOCKS DT_HVAC_SPECIFIED =-1._EB,DT_MASS_SPECIFIED =-1._EB,DT_PROF_SPECIFIED=-1._EB,DT_CTRL_SPECIFIED=-1._EB,& DT_FLUSH_SPECIFIED=-1._EB,DT_SL3D_SPECIFIED =-1._EB,DT_GEOM_SPECIFIED=-1._EB,DT_CPU_SPECIFIED =-1._EB,& DT_RADF_SPECIFIED =-1._EB,DT_SMOKE3D_SPECIFIED=-1._EB,DT_UVW_SPECIFIED =-1._EB,DT_TMP_SPECIFIED =-1._EB,& - DT_SPEC_SPECIFIED =-1._EB + DT_SPEC_SPECIFIED =-1._EB,DT_VTK_SPECIFIED =-1._EB END MODULE OUTPUT_CLOCKS diff --git a/Source/dump.f90 b/Source/dump.f90 index 75529be1ef2..3ec74367235 100644 --- a/Source/dump.f90 +++ b/Source/dump.f90 @@ -19,6 +19,8 @@ MODULE DUMP CC_VGSC,CC_GASPHASE,MAKE_UNIQUE_VERT_ARRAY,AVERAGE_FACE_VALUES USE CC_SCALARS, ONLY : ADD_Q_DOT_CUTCELLS,GET_PRES_CFACE,GET_PRES_CFACE_TEST,GET_UVWGAS_CFACE,GET_MUDNS_CFACE +USE PENF +USE VTK_FORTRAN, ONLY : VTK_FILE IMPLICIT NONE (TYPE,EXTERNAL) PRIVATE @@ -129,6 +131,14 @@ SUBROUTINE DUMP_MESH_OUTPUTS(T,DT,NM) ENDDO ENDIF +IF (T>=VTK_CLOCK(VTK_COUNTER(NM)) .OR. STOP_STATUS==INSTABILITY_STOP) THEN + CALL DUMP_SLCF(T,DT,NM,3) + DO WHILE(VTK_COUNTER(NM)<SIZE(VTK_CLOCK)-1) + VTK_COUNTER(NM) = VTK_COUNTER(NM) + 1 + IF (VTK_CLOCK(VTK_COUNTER(NM))>=T) EXIT + ENDDO +ENDIF + IF (T>=BNDF_CLOCK(BNDF_COUNTER(NM))) THEN CALL DUMP_BNDF(T,DT,NM) DO WHILE(BNDF_COUNTER(NM)<SIZE(BNDF_CLOCK)-1) @@ -5762,7 +5772,7 @@ END SUBROUTINE GET_GASCUTFACE_SCALAR_SLICE !> \param T Current simulation time (s) !> \param DT Current time step size (s) !> \param NM Mesh number -!> \param IFRMT Slice (IFRMT=0) or Plot3D (IFRMT=1) or 3D slice (IFRMT=2) +!> \param IFRMT Slice (IFRMT=0) or Plot3D (IFRMT=1) or 3D slice (IFRMT=2) or VTK slice (IFRMT=3) SUBROUTINE DUMP_SLCF(T,DT,NM,IFRMT) @@ -5780,7 +5790,7 @@ SUBROUTINE DUMP_SLCF(T,DT,NM,IFRMT) INTEGER :: KTS,NTSL REAL(EB), POINTER, DIMENSION(:,:,:) :: B,S,QUANTITY REAL(FB) :: ZERO,STIME -LOGICAL :: PLOT3D,SLCF3D +LOGICAL :: PLOT3D,SLCF3D,VTK3D LOGICAL :: AGL_TERRAIN_SLICE,CC_CELL_CENTERED,CC_INTERP2FACES REAL(FB) :: SLICE_MIN, SLICE_MAX, DSLICE INTEGER :: NX, NY, NZ @@ -5788,15 +5798,19 @@ SUBROUTINE DUMP_SLCF(T,DT,NM,IFRMT) REAL(FB), ALLOCATABLE, DIMENSION(:) :: QQ_PACK REAL(FB) :: UVEL, VVEL, WVEL, VEL, PLOT3D_MIN, PLOT3D_MAX INTEGER :: IERROR +TYPE(VTK_FILE) :: A_VTK_FILE ! A VTK file. +CHARACTER(80) :: VTK_FILE_NAME +INTEGER(IB4) :: VTK_ERROR=0_IB4 !< IO Error status. ! Return if there are no slices to process and this is not a Plot3D dump DRY=.FALSE. SELECT CASE(IFRMT) - CASE(0) ; PLOT3D=.FALSE. ; SLCF3D=.FALSE. - CASE(1) ; PLOT3D=.TRUE. ; SLCF3D=.FALSE. - CASE(2) ; PLOT3D=.FALSE. ; SLCF3D=.TRUE. + CASE(0) ; PLOT3D=.FALSE. ; SLCF3D=.FALSE. ; VTK3D=.FALSE. + CASE(1) ; PLOT3D=.TRUE. ; SLCF3D=.FALSE. ; VTK3D=.FALSE. + CASE(2) ; PLOT3D=.FALSE. ; SLCF3D=.TRUE. ; VTK3D=.FALSE. + CASE(3) ; PLOT3D=.FALSE. ; SLCF3D=.FALSE. ; VTK3D=.TRUE. END SELECT IF (MESHES(NM)%N_SLCF==0 .AND. .NOT.PLOT3D) RETURN @@ -5836,10 +5850,12 @@ SUBROUTINE DUMP_SLCF(T,DT,NM,IFRMT) ! If sprinkler diagnostic on, pre-compute various PARTICLE flux output -IF (.NOT.PLOT3D) THEN +IF (.NOT.PLOT3D .AND. .NOT.VTK3D) THEN IF (SLCF_PARTICLE_FLUX) CALL COMPUTE_PARTICLE_FLUXES(NM) -ELSE +ELSEIF (.NOT.VTK3D) THEN IF (PL3D_PARTICLE_FLUX) CALL COMPUTE_PARTICLE_FLUXES(NM) +ELSE + IF (SLCF_PARTICLE_FLUX) CALL COMPUTE_PARTICLE_FLUXES(NM) ! TODO Not sure what we need for VTK here ENDIF ! Determine slice or Plot3D indicies @@ -5886,6 +5902,25 @@ SUBROUTINE DUMP_SLCF(T,DT,NM,IFRMT) NTSL = 0 +IF (VTK3D) THEN + SL => SLICE(IQ) + STIME = REAL(T_BEGIN + (T-T_BEGIN)*TIME_SHRINK_FACTOR,FB) + WRITE(VTK_FILE_NAME, '(A,A,I0,A,I0,A)') TRIM(CHID),'_',NM,'_',STIME,'.vtr' + IF (SL%SLICETYPE=='STRUCTURED') THEN ! write out slice file using original slice file format + WRITE(*,*) "HELLO WORLD" + VTK_ERROR = A_VTK_FILE%initialize(format='ascii', filename=VTK_FILE_NAME, & + mesh_topology='RectilinearGrid', & + nx1=I1, nx2=I2, ny1=J1, ny2=J2, nz1=K1, nz2=K2) + VTK_ERROR = A_VTK_FILE%XML_WRITER%write_fielddata(action='open') + VTK_ERROR = A_VTK_FILE%XML_WRITER%write_fielddata(x=0._FB, data_name='TIME') + VTK_ERROR = A_VTK_FILE%XML_WRITER%write_fielddata(x=1_IB16, data_name='CYCLE') + VTK_ERROR = A_VTK_FILE%XML_WRITER%write_fielddata(action='close') + ! write one piece + VTK_ERROR = A_VTK_FILE%XML_WRITER%write_piece(nx1=I1, nx2=I2, ny1=J1, ny2=J2, nz1=K1, nz2=K2) ! Piece Extent + VTK_ERROR = A_VTK_FILE%XML_WRITER%write_geo(x=x, y=y, z=z) ! Piece coordinates + ENDIF +ENDIF + QUANTITY_LOOP: DO IQ=1,NQT IF (PLOT3D) THEN @@ -6035,7 +6070,7 @@ SUBROUTINE DUMP_SLCF(T,DT,NM,IFRMT) ! Dump out the slice file to a .sf file - IF (.NOT.PLOT3D) THEN + IF (.NOT.PLOT3D .and. .NOT.VTK3D) THEN SL => SLICE(IQ) IF (SL%SLICETYPE=='STRUCTURED') THEN ! write out slice file using original slice file format STIME = REAL(T_BEGIN + (T-T_BEGIN)*TIME_SHRINK_FACTOR,FB) @@ -6189,6 +6224,42 @@ SUBROUTINE DUMP_SLCF(T,DT,NM,IFRMT) ENDIF ENDIF + + + ! Dump out the slice file to a .vtk file + + IF (VTK3D) THEN + SL => SLICE(IQ) + IF (SL%SLICETYPE=='STRUCTURED') THEN ! write out slice file using original slice file format + IF (NX*NY*NZ>0) THEN + ALLOCATE(QQ_PACK(NX*NY*NZ)) + + DO K = K1, K2 + KFACT = (K-K1) + DO J = J1, J2 + JFACT = (J-J1)*NZ + DO I = I1, I2 + IFACT = (I - I1)*NY*NZ + QQ_PACK(1+IFACT+JFACT+KFACT) = QQ(I,J,K,1) + ENDDO + ENDDO + ENDDO + ! write one quantity + VTK_ERROR = A_VTK_FILE%XML_WRITER%WRITE_DATAARRAY(LOCATION='cell', ACTION='open') + VTK_ERROR = A_VTK_FILE%XML_WRITER%WRITE_DATAARRAY(DATA_NAME='cell_value', X=QQ_PACK) + VTK_ERROR = A_VTK_FILE%XML_WRITER%WRITE_DATAARRAY(LOCATION='cell', ACTION='close') + VTK_ERROR = A_VTK_FILE%XML_WRITER%WRITE_PIECE() + DEALLOCATE(QQ_PACK) + ENDIF + ENDIF + ENDIF + +IF (VTK3D) THEN + ! finish after writing all pieces + WRITE(*,*) "HELLO WORLD 2" + VTK_ERROR = A_VTK_FILE%FINALIZE() +ENDIF + ENDDO QUANTITY_LOOP ! Write out the PLOT3D ``q'' file diff --git a/Source/read.f90 b/Source/read.f90 index d7e3b13d103..211a8b8c44e 100644 --- a/Source/read.f90 +++ b/Source/read.f90 @@ -2252,13 +2252,13 @@ SUBROUTINE READ_DUMP NAMELIST /DUMP/ CFL_FILE,CLIP_RESTART_FILES,COLUMN_DUMP_LIMIT,CTRL_COLUMN_LIMIT,DEVC_COLUMN_LIMIT,& DIAGNOSTICS_INTERVAL,& DT_BNDF,DT_CPU,DT_CTRL,DT_DEVC,DT_FLUSH,DT_HRR,DT_HVAC,DT_ISOF,DT_MASS,DT_PART,DT_PL3D,DT_PROF,& - DT_RADF,DT_RESTART,DT_SL3D,DT_SLCF,DT_SMOKE3D,DT_UVW,DT_TMP,DT_SPEC,& + DT_RADF,DT_RESTART,DT_SL3D,DT_SLCF,DT_SMOKE3D,DT_UVW,DT_TMP,DT_SPEC,DT_VTK,& FLUSH_FILE_BUFFERS,GET_CUTCELLS_VERBOSE,HRR_GAS_ONLY,MASS_FILE,MAXIMUM_PARTICLES,MMS_TIMER,& NFRAMES,PLOT3D_PART_ID,PLOT3D_QUANTITY,PLOT3D_SPEC_ID,PLOT3D_VELO_INDEX,& RAMP_BNDF,RAMP_CPU,RAMP_CTRL,RAMP_DEVC,RAMP_FLUSH,RAMP_HRR,RAMP_HVAC,RAMP_ISOF,RAMP_MASS,& RAMP_PART,RAMP_PL3D,RAMP_PROF,RAMP_RADF,RAMP_RESTART,RAMP_SLCF,RAMP_SL3D,RAMP_SMOKE3D,& - RAMP_SPEC,RAMP_TMP,RAMP_UVW,RENDER_FILE,SIG_FIGS,SIG_FIGS_EXP,SMOKE3D,STATUS_FILES,SUPPRESS_DIAGNOSTICS,& - TURB_INIT_CLOCK,VELOCITY_ERROR_FILE,WRITE_XYZ,WRITE_STL + RAMP_SPEC,RAMP_TMP,RAMP_UVW,RAMP_VTK,RENDER_FILE,SIG_FIGS,SIG_FIGS_EXP,SMOKE3D,STATUS_FILES,& + SUPPRESS_DIAGNOSTICS,TURB_INIT_CLOCK,VELOCITY_ERROR_FILE,WRITE_XYZ,WRITE_STL ! Set defaults @@ -2302,6 +2302,7 @@ SUBROUTINE READ_DUMP DT_SL3D = (T_END-T_BEGIN)/5._EB ; RAMP_SL3D = 'null' ; DT_SL3D_SPECIFIED = DT_SL3D DT_SMOKE3D = -1._EB ; RAMP_SMOKE3D = 'null' ; DT_SMOKE3D_SPECIFIED = DT_SMOKE3D DT_UVW = HUGE(EB) ; RAMP_UVW = 'null' ; DT_UVW_SPECIFIED = DT_UVW +DT_VTK = HUGE(EB) ; RAMP_VTK = 'null' ; DT_VTK_SPECIFIED = DT_VTK DT_TMP = HUGE(EB) ; RAMP_TMP = 'null' ; DT_TMP_SPECIFIED = DT_TMP DT_SPEC = HUGE(EB) ; RAMP_SPEC = 'null' ; DT_SPEC_SPECIFIED = DT_SPEC DIAGNOSTICS_INTERVAL = 100 @@ -2340,6 +2341,7 @@ SUBROUTINE READ_DUMP IF (DT_UVW_SPECIFIED /= DT_UVW) THEN ; DT_UVW_SPECIFIED = DT_UVW ; ELSE ; DT_UVW_SPECIFIED = -1._EB ; ENDIF IF (DT_TMP_SPECIFIED /= DT_TMP) THEN ; DT_TMP_SPECIFIED = DT_TMP ; ELSE ; DT_TMP_SPECIFIED = -1._EB ; ENDIF IF (DT_SPEC_SPECIFIED /= DT_SPEC) THEN ; DT_SPEC_SPECIFIED = DT_SPEC ; ELSE ; DT_SPEC_SPECIFIED = -1._EB ; ENDIF +IF (DT_VTK_SPECIFIED /= DT_VTK) THEN ; DT_VTK_SPECIFIED = DT_PL3D ; ELSE ; DT_VTK_SPECIFIED = -1._EB ; ENDIF ! Timing RAMPs From 863d9000953163acf0cd742fe4b82c21da353bc2 Mon Sep 17 00:00:00 2001 From: Jonathan Hodges <johodges@vt.edu> Date: Sat, 23 Dec 2023 19:00:03 -0500 Subject: [PATCH 09/31] add parameters for VTK output --- Source/cons.f90 | 3 ++- Source/dump.f90 | 18 +++++++++--------- Source/read.f90 | 2 +- 3 files changed, 12 insertions(+), 11 deletions(-) diff --git a/Source/cons.f90 b/Source/cons.f90 index 92eccb74528..743ac80929c 100644 --- a/Source/cons.f90 +++ b/Source/cons.f90 @@ -758,6 +758,7 @@ MODULE OUTPUT_CLOCKS INTEGER :: RAMP_UVW_INDEX =0 !< Ramp index for velocity file time series INTEGER :: RAMP_TMP_INDEX =0 !< Ramp index for temperature file time series INTEGER :: RAMP_SPEC_INDEX=0 !< Ramp index for species file time series +INTEGER :: RAMP_VTK_INDEX=0 !< Ramp index for vtk file time series REAL(EB), ALLOCATABLE, DIMENSION(:) :: BNDF_CLOCK, CPU_CLOCK,CTRL_CLOCK,DEVC_CLOCK,FLSH_CLOCK,GEOM_CLOCK, HRR_CLOCK,HVAC_CLOCK,& ISOF_CLOCK,MASS_CLOCK,PART_CLOCK,PL3D_CLOCK,PROF_CLOCK,RADF_CLOCK,RSRT_CLOCK,& SLCF_CLOCK,SL3D_CLOCK,SM3D_CLOCK,UVW_CLOCK ,TMP_CLOCK ,SPEC_CLOCK,VTK_CLOCK @@ -768,7 +769,7 @@ MODULE OUTPUT_CLOCKS REAL(EB) :: TURB_INIT_CLOCK=-1.E10_EB REAL(EB) :: MMS_TIMER=1.E10_EB REAL(EB) :: DT_SLCF,DT_BNDF,DT_DEVC,DT_PL3D,DT_PART,DT_RESTART,DT_ISOF,DT_HRR,DT_HVAC,DT_MASS,DT_PROF,DT_CTRL,& - DT_FLUSH,DT_SL3D,DT_GEOM,DT_CPU,DT_RADF,DT_SMOKE3D,DT_UVW ,DT_TMP,DT_SPEC + DT_FLUSH,DT_SL3D,DT_GEOM,DT_CPU,DT_RADF,DT_SMOKE3D,DT_UVW ,DT_TMP,DT_SPEC,DT_VTK REAL(EB) :: DT_SLCF_SPECIFIED =-1._EB,DT_BNDF_SPECIFIED =-1._EB,DT_DEVC_SPECIFIED=-1._EB,DT_PL3D_SPECIFIED=-1._EB,& DT_PART_SPECIFIED =-1._EB,DT_RESTART_SPECIFIED=-1._EB,DT_ISOF_SPECIFIED=-1._EB,DT_HRR_SPECIFIED =-1._EB,& DT_HVAC_SPECIFIED =-1._EB,DT_MASS_SPECIFIED =-1._EB,DT_PROF_SPECIFIED=-1._EB,DT_CTRL_SPECIFIED=-1._EB,& diff --git a/Source/dump.f90 b/Source/dump.f90 index 3ec74367235..4418664199f 100644 --- a/Source/dump.f90 +++ b/Source/dump.f90 @@ -5908,16 +5908,16 @@ SUBROUTINE DUMP_SLCF(T,DT,NM,IFRMT) WRITE(VTK_FILE_NAME, '(A,A,I0,A,I0,A)') TRIM(CHID),'_',NM,'_',STIME,'.vtr' IF (SL%SLICETYPE=='STRUCTURED') THEN ! write out slice file using original slice file format WRITE(*,*) "HELLO WORLD" - VTK_ERROR = A_VTK_FILE%initialize(format='ascii', filename=VTK_FILE_NAME, & - mesh_topology='RectilinearGrid', & - nx1=I1, nx2=I2, ny1=J1, ny2=J2, nz1=K1, nz2=K2) - VTK_ERROR = A_VTK_FILE%XML_WRITER%write_fielddata(action='open') - VTK_ERROR = A_VTK_FILE%XML_WRITER%write_fielddata(x=0._FB, data_name='TIME') - VTK_ERROR = A_VTK_FILE%XML_WRITER%write_fielddata(x=1_IB16, data_name='CYCLE') - VTK_ERROR = A_VTK_FILE%XML_WRITER%write_fielddata(action='close') + VTK_ERROR = A_VTK_FILE%INITIALIZE(FORMAT='ascii', FILENAME=VTK_FILE_NAME, & + MESH_TOPOLOGY='RectilinearGrid', & + NX1=I1, NX2=I2, NY1=J1, NY2=J2, NZ1=K1, NZ2=K2) + VTK_ERROR = A_VTK_FILE%XML_WRITER%WRITE_FIELDDATA(ACTION='open') + VTK_ERROR = A_VTK_FILE%XML_WRITER%WRITE_FIELDDATA(X=0._FB, DATA_NAME='TIME') + VTK_ERROR = A_VTK_FILE%XML_WRITER%WRITE_FIELDDATA(X=1_IB16, DATA_NAME='CYCLE') + VTK_ERROR = A_VTK_FILE%XML_WRITER%WRITE_FIELDDATA(ACTION='close') ! write one piece - VTK_ERROR = A_VTK_FILE%XML_WRITER%write_piece(nx1=I1, nx2=I2, ny1=J1, ny2=J2, nz1=K1, nz2=K2) ! Piece Extent - VTK_ERROR = A_VTK_FILE%XML_WRITER%write_geo(x=x, y=y, z=z) ! Piece coordinates + VTK_ERROR = A_VTK_FILE%XML_WRITER%WRITE_PIECE(NX1=I1, NX2=I2, NY1=J1, NY2=J2, NZ1=K1, NZ2=K2) ! Piece Extent + VTK_ERROR = A_VTK_FILE%XML_WRITER%WRITE_GEO(X=X, Y=Y, Z=Z) ! Piece coordinates ENDIF ENDIF diff --git a/Source/read.f90 b/Source/read.f90 index 211a8b8c44e..82e24a77416 100644 --- a/Source/read.f90 +++ b/Source/read.f90 @@ -2248,7 +2248,7 @@ SUBROUTINE READ_DUMP INTEGER :: N,SIG_FIGS,SIG_FIGS_EXP CHARACTER(LABEL_LENGTH) :: RAMP_BNDF,RAMP_CPU,RAMP_CTRL,RAMP_DEVC,RAMP_FLUSH,RAMP_GEOM,RAMP_HRR,RAMP_HVAC,RAMP_ISOF,RAMP_MASS,& RAMP_PART,RAMP_PL3D,RAMP_PROF,RAMP_RADF,RAMP_RESTART,RAMP_SLCF,RAMP_SL3D,RAMP_SMOKE3D,RAMP_UVW,& - RAMP_TMP,RAMP_SPEC + RAMP_TMP,RAMP_SPEC,RAMP_VTK NAMELIST /DUMP/ CFL_FILE,CLIP_RESTART_FILES,COLUMN_DUMP_LIMIT,CTRL_COLUMN_LIMIT,DEVC_COLUMN_LIMIT,& DIAGNOSTICS_INTERVAL,& DT_BNDF,DT_CPU,DT_CTRL,DT_DEVC,DT_FLUSH,DT_HRR,DT_HVAC,DT_ISOF,DT_MASS,DT_PART,DT_PL3D,DT_PROF,& From 9956c1c62d429f1a2ab88deb544a6d420ce1e486 Mon Sep 17 00:00:00 2001 From: Jonathan Hodges <johodges@vt.edu> Date: Tue, 26 Dec 2023 10:01:23 -0500 Subject: [PATCH 10/31] add initialization of VTK clocks --- Source/func.f90 | 1 + 1 file changed, 1 insertion(+) diff --git a/Source/func.f90 b/Source/func.f90 index 0df81bd4392..bd92f564667 100644 --- a/Source/func.f90 +++ b/Source/func.f90 @@ -481,6 +481,7 @@ SUBROUTINE INITIALIZE_OUTPUT_CLOCKS(T) CALL SET_OUTPUT_CLOCK(DT_UVW ,RAMP_UVW_INDEX , UVW_CLOCK, UVW_COUNTER,.TRUE. ,.TRUE. ) CALL SET_OUTPUT_CLOCK(DT_TMP ,RAMP_TMP_INDEX , TMP_CLOCK, TMP_COUNTER,.TRUE. ,.TRUE. ) CALL SET_OUTPUT_CLOCK(DT_SPEC ,RAMP_SPEC_INDEX,SPEC_CLOCK,SPEC_COUNTER,.TRUE. ,.TRUE. ) +CALL SET_OUTPUT_CLOCK(DT_VTK ,RAMP_VTK_INDEX, VTK_CLOCK, VTK_COUNTER,.TRUE. ,.TRUE. ) ! Special cases From c0b3fde9da58d3ca6ba99cb035730cdc8661248b Mon Sep 17 00:00:00 2001 From: Jonathan Hodges <johodges@vt.edu> Date: Tue, 26 Dec 2023 16:11:42 -0500 Subject: [PATCH 11/31] fix for VTK with 3-d slices in multiple meshes --- Source/cons.f90 | 3 +- Source/dump.f90 | 77 ++++++++++++++++++++++++++++--------------------- 2 files changed, 46 insertions(+), 34 deletions(-) diff --git a/Source/cons.f90 b/Source/cons.f90 index 743ac80929c..93909e7a7f6 100644 --- a/Source/cons.f90 +++ b/Source/cons.f90 @@ -545,10 +545,11 @@ MODULE GLOBAL_CONSTANTS CHARACTER(80) :: FN_MASS,FN_HRR,FN_STEPS,FN_SMV,FN_END,FN_ERR,FN_NOTREADY,FN_VELOCITY_ERROR,FN_GIT CHARACTER(80) :: FN_LINE,FN_HISTOGRAM,FN_CUTCELL,FN_TGA,FN_DEVC_CTRL,FN_HVAC,FN_STL CHARACTER(80), ALLOCATABLE, DIMENSION(:) :: FN_PART,FN_PROF,FN_XYZ,FN_TERRAIN,FN_PL3D,FN_DEVC,FN_STATE,FN_CTRL,FN_CORE,FN_RESTART -CHARACTER(80), ALLOCATABLE, DIMENSION(:) :: FN_VEG_OUT,FN_GEOM, FN_CFACE_GEOM +CHARACTER(80), ALLOCATABLE, DIMENSION(:) :: FN_VEG_OUT,FN_GEOM, FN_CFACE_GEOM, FN_VTK CHARACTER(80), ALLOCATABLE, DIMENSION(:,:) :: FN_SLCF,FN_SLCF_GEOM,FN_BNDF,FN_BNDG, & FN_ISOF,FN_ISOF2,FN_SMOKE3D,FN_RADF + CHARACTER(9) :: FMT_R LOGICAL :: OUT_FILE_OPENED=.FALSE. diff --git a/Source/dump.f90 b/Source/dump.f90 index 4418664199f..f36663b77a1 100644 --- a/Source/dump.f90 +++ b/Source/dump.f90 @@ -336,6 +336,7 @@ SUBROUTINE ASSIGN_FILE_NAMES ALLOCATE(LU_XYZ(NMESHES)) ALLOCATE(FN_PL3D(2*NMESHES)) ALLOCATE(LU_PL3D(2*NMESHES)) +ALLOCATE(FN_VTK(NMESHES)) ALLOCATE(FN_ISOF(N_ISOF,NMESHES)) ALLOCATE(LU_ISOF(N_ISOF,NMESHES)) @@ -5799,8 +5800,8 @@ SUBROUTINE DUMP_SLCF(T,DT,NM,IFRMT) REAL(FB) :: UVEL, VVEL, WVEL, VEL, PLOT3D_MIN, PLOT3D_MAX INTEGER :: IERROR TYPE(VTK_FILE) :: A_VTK_FILE ! A VTK file. -CHARACTER(80) :: VTK_FILE_NAME INTEGER(IB4) :: VTK_ERROR=0_IB4 !< IO Error status. +LOGICAL :: VTK_INITIALIZED ! Return if there are no slices to process and this is not a Plot3D dump @@ -5810,7 +5811,7 @@ SUBROUTINE DUMP_SLCF(T,DT,NM,IFRMT) CASE(0) ; PLOT3D=.FALSE. ; SLCF3D=.FALSE. ; VTK3D=.FALSE. CASE(1) ; PLOT3D=.TRUE. ; SLCF3D=.FALSE. ; VTK3D=.FALSE. CASE(2) ; PLOT3D=.FALSE. ; SLCF3D=.TRUE. ; VTK3D=.FALSE. - CASE(3) ; PLOT3D=.FALSE. ; SLCF3D=.FALSE. ; VTK3D=.TRUE. + CASE(3) ; PLOT3D=.FALSE. ; SLCF3D=.TRUE. ; VTK3D=.TRUE. END SELECT IF (MESHES(NM)%N_SLCF==0 .AND. .NOT.PLOT3D) RETURN @@ -5901,25 +5902,7 @@ SUBROUTINE DUMP_SLCF(T,DT,NM,IFRMT) ENDIF NTSL = 0 - -IF (VTK3D) THEN - SL => SLICE(IQ) - STIME = REAL(T_BEGIN + (T-T_BEGIN)*TIME_SHRINK_FACTOR,FB) - WRITE(VTK_FILE_NAME, '(A,A,I0,A,I0,A)') TRIM(CHID),'_',NM,'_',STIME,'.vtr' - IF (SL%SLICETYPE=='STRUCTURED') THEN ! write out slice file using original slice file format - WRITE(*,*) "HELLO WORLD" - VTK_ERROR = A_VTK_FILE%INITIALIZE(FORMAT='ascii', FILENAME=VTK_FILE_NAME, & - MESH_TOPOLOGY='RectilinearGrid', & - NX1=I1, NX2=I2, NY1=J1, NY2=J2, NZ1=K1, NZ2=K2) - VTK_ERROR = A_VTK_FILE%XML_WRITER%WRITE_FIELDDATA(ACTION='open') - VTK_ERROR = A_VTK_FILE%XML_WRITER%WRITE_FIELDDATA(X=0._FB, DATA_NAME='TIME') - VTK_ERROR = A_VTK_FILE%XML_WRITER%WRITE_FIELDDATA(X=1_IB16, DATA_NAME='CYCLE') - VTK_ERROR = A_VTK_FILE%XML_WRITER%WRITE_FIELDDATA(ACTION='close') - ! write one piece - VTK_ERROR = A_VTK_FILE%XML_WRITER%WRITE_PIECE(NX1=I1, NX2=I2, NY1=J1, NY2=J2, NZ1=K1, NZ2=K2) ! Piece Extent - VTK_ERROR = A_VTK_FILE%XML_WRITER%WRITE_GEO(X=X, Y=Y, Z=Z) ! Piece coordinates - ENDIF -ENDIF +VTK_INITIALIZED=.FALSE. QUANTITY_LOOP: DO IQ=1,NQT @@ -5964,6 +5947,28 @@ SUBROUTINE DUMP_SLCF(T,DT,NM,IFRMT) IF ((I2-I1==0 .OR. J2-J1==0 .OR. K2-K1==0) .AND. SLCF3D) CYCLE QUANTITY_LOOP ENDIF + IF (VTK3D .AND. .NOT.VTK_INITIALIZED) THEN + SL => SLICE(IQ) + STIME = REAL(T_BEGIN + (T-T_BEGIN)*TIME_SHRINK_FACTOR,FB) + TT = T_BEGIN + (T-T_BEGIN)*TIME_SHRINK_FACTOR + ITM = INT(TT) + ITM1 = NINT(ABS(TT-ITM)*100) + IF (ITM1==100) THEN + ITM = ITM+1 + ITM1 = 0 + ENDIF + IF (SL%SLICETYPE=='STRUCTURED') THEN ! write out slice file using original slice file format + VTK_ERROR = A_VTK_FILE%INITIALIZE(FORMAT='ascii', FILENAME=FN_VTK(NM), & + MESH_TOPOLOGY='RectilinearGrid', is_volatile=.FALSE., & + NX1=I1, NX2=I2, NY1=J1, NY2=J2, NZ1=K1, NZ2=K2) + ! write one piece + VTK_ERROR = A_VTK_FILE%XML_WRITER%WRITE_PIECE(NX1=I1, NX2=I2, NY1=J1, NY2=J2, NZ1=K1, NZ2=K2) ! Piece Extent + VTK_ERROR = A_VTK_FILE%XML_WRITER%WRITE_GEO(X=MESHES(NM)%XPLT, Y=MESHES(NM)%YPLT, Z=MESHES(NM)%ZPLT) ! Piece coordinates + VTK_ERROR = A_VTK_FILE%XML_WRITER%WRITE_DATAARRAY(LOCATION='NODE', ACTION='open') + ENDIF + VTK_INITIALIZED=.TRUE. + ENDIF + ! Determine what cells need to be evaluated to form cell-corner averages II1 = I1 @@ -6230,25 +6235,30 @@ SUBROUTINE DUMP_SLCF(T,DT,NM,IFRMT) IF (VTK3D) THEN SL => SLICE(IQ) + I1=SL%I1 + I2=SL%I2 + J1=SL%J1 + J2=SL%J2 + K1=SL%K1 + K2=SL%K2 + NX = I2 + 1 - I1 + NY = J2 + 1 - J1 + NZ = K2 + 1 - K1 + WRITE(*,*) "STARTING TO PACK", SL%SLICETYPE, NX, NY, NZ, I1, I2, J1, J2, K1, K2 IF (SL%SLICETYPE=='STRUCTURED') THEN ! write out slice file using original slice file format IF (NX*NY*NZ>0) THEN ALLOCATE(QQ_PACK(NX*NY*NZ)) - - DO K = K1, K2 - KFACT = (K-K1) + DO I = I1, I2 + IFACT = (I-I1) DO J = J1, J2 - JFACT = (J-J1)*NZ - DO I = I1, I2 - IFACT = (I - I1)*NY*NZ + JFACT = (J-J1)*NX + DO K = K1, K2 + KFACT = (K - K1)*NY*NX QQ_PACK(1+IFACT+JFACT+KFACT) = QQ(I,J,K,1) ENDDO ENDDO ENDDO - ! write one quantity - VTK_ERROR = A_VTK_FILE%XML_WRITER%WRITE_DATAARRAY(LOCATION='cell', ACTION='open') - VTK_ERROR = A_VTK_FILE%XML_WRITER%WRITE_DATAARRAY(DATA_NAME='cell_value', X=QQ_PACK) - VTK_ERROR = A_VTK_FILE%XML_WRITER%WRITE_DATAARRAY(LOCATION='cell', ACTION='close') - VTK_ERROR = A_VTK_FILE%XML_WRITER%WRITE_PIECE() + VTK_ERROR = A_VTK_FILE%XML_WRITER%WRITE_DATAARRAY(DATA_NAME=SL%SMOKEVIEW_LABEL(1:30), X=QQ_PACK) DEALLOCATE(QQ_PACK) ENDIF ENDIF @@ -6256,7 +6266,8 @@ SUBROUTINE DUMP_SLCF(T,DT,NM,IFRMT) IF (VTK3D) THEN ! finish after writing all pieces - WRITE(*,*) "HELLO WORLD 2" + VTK_ERROR = A_VTK_FILE%XML_WRITER%WRITE_DATAARRAY(LOCATION='NODE', ACTION='close') + VTK_ERROR = A_VTK_FILE%XML_WRITER%WRITE_PIECE() VTK_ERROR = A_VTK_FILE%FINALIZE() ENDIF From b0b4bdcd68cabba3f276b6d5c4a45273719c3e66 Mon Sep 17 00:00:00 2001 From: Jonathan Hodges <johodges@vt.edu> Date: Tue, 26 Dec 2023 16:19:51 -0500 Subject: [PATCH 12/31] clean-up debug writing lines --- Source/dump.f90 | 7 +++++-- 1 file changed, 5 insertions(+), 2 deletions(-) diff --git a/Source/dump.f90 b/Source/dump.f90 index f36663b77a1..0f719dbd308 100644 --- a/Source/dump.f90 +++ b/Source/dump.f90 @@ -5957,6 +5957,7 @@ SUBROUTINE DUMP_SLCF(T,DT,NM,IFRMT) ITM = ITM+1 ITM1 = 0 ENDIF + WRITE(FN_VTK(NM),'(A,A,I0,A,I8.8,I2.2,A)') TRIM(CHID),'_',NM,'_',ITM,ITM1,'.vtr' IF (SL%SLICETYPE=='STRUCTURED') THEN ! write out slice file using original slice file format VTK_ERROR = A_VTK_FILE%INITIALIZE(FORMAT='ascii', FILENAME=FN_VTK(NM), & MESH_TOPOLOGY='RectilinearGrid', is_volatile=.FALSE., & @@ -6244,10 +6245,10 @@ SUBROUTINE DUMP_SLCF(T,DT,NM,IFRMT) NX = I2 + 1 - I1 NY = J2 + 1 - J1 NZ = K2 + 1 - K1 - WRITE(*,*) "STARTING TO PACK", SL%SLICETYPE, NX, NY, NZ, I1, I2, J1, J2, K1, K2 IF (SL%SLICETYPE=='STRUCTURED') THEN ! write out slice file using original slice file format IF (NX*NY*NZ>0) THEN - ALLOCATE(QQ_PACK(NX*NY*NZ)) + ALLOCATE(QQ_PACK(NX*NY*NZ) + DO I = I1, I2 IFACT = (I-I1) DO J = J1, J2 @@ -6258,6 +6259,8 @@ SUBROUTINE DUMP_SLCF(T,DT,NM,IFRMT) ENDDO ENDDO ENDDO + + ! write one quantity VTK_ERROR = A_VTK_FILE%XML_WRITER%WRITE_DATAARRAY(DATA_NAME=SL%SMOKEVIEW_LABEL(1:30), X=QQ_PACK) DEALLOCATE(QQ_PACK) ENDIF From 300d38ce5059f41d14557a6fd513f7e0ecddab23 Mon Sep 17 00:00:00 2001 From: Jonathan Hodges <johodges@vt.edu> Date: Tue, 26 Dec 2023 16:21:04 -0500 Subject: [PATCH 13/31] fix missing parethensis --- Source/dump.f90 | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/Source/dump.f90 b/Source/dump.f90 index 0f719dbd308..959e94748cc 100644 --- a/Source/dump.f90 +++ b/Source/dump.f90 @@ -6247,8 +6247,7 @@ SUBROUTINE DUMP_SLCF(T,DT,NM,IFRMT) NZ = K2 + 1 - K1 IF (SL%SLICETYPE=='STRUCTURED') THEN ! write out slice file using original slice file format IF (NX*NY*NZ>0) THEN - ALLOCATE(QQ_PACK(NX*NY*NZ) - + ALLOCATE(QQ_PACK(NX*NY*NZ)) DO I = I1, I2 IFACT = (I-I1) DO J = J1, J2 From 7b7d1597f667ff18690db38978d789bfd40c0d72 Mon Sep 17 00:00:00 2001 From: Jonathan Hodges <johodges@vt.edu> Date: Thu, 28 Dec 2023 11:29:09 -0500 Subject: [PATCH 14/31] swap to vtu format for 3d slices --- Source/dump.f90 | 88 ++++++++++++++++++++++++++++++++++++++++++------- 1 file changed, 77 insertions(+), 11 deletions(-) diff --git a/Source/dump.f90 b/Source/dump.f90 index 959e94748cc..924b513c5a5 100644 --- a/Source/dump.f90 +++ b/Source/dump.f90 @@ -19,8 +19,10 @@ MODULE DUMP CC_VGSC,CC_GASPHASE,MAKE_UNIQUE_VERT_ARRAY,AVERAGE_FACE_VALUES USE CC_SCALARS, ONLY : ADD_Q_DOT_CUTCELLS,GET_PRES_CFACE,GET_PRES_CFACE_TEST,GET_UVWGAS_CFACE,GET_MUDNS_CFACE +#ifdef WITH_VTK USE PENF USE VTK_FORTRAN, ONLY : VTK_FILE +#endif /* WITH_VTK */ IMPLICIT NONE (TYPE,EXTERNAL) PRIVATE @@ -5794,9 +5796,11 @@ SUBROUTINE DUMP_SLCF(T,DT,NM,IFRMT) LOGICAL :: PLOT3D,SLCF3D,VTK3D LOGICAL :: AGL_TERRAIN_SLICE,CC_CELL_CENTERED,CC_INTERP2FACES REAL(FB) :: SLICE_MIN, SLICE_MAX, DSLICE -INTEGER :: NX, NY, NZ +INTEGER :: NX, NY, NZ, NC, NP INTEGER :: IFACT, JFACT, KFACT -REAL(FB), ALLOCATABLE, DIMENSION(:) :: QQ_PACK +REAL(FB), ALLOCATABLE, DIMENSION(:) :: QQ_PACK, X_PTS, Y_PTS, Z_PTS +INTEGER, ALLOCATABLE, DIMENSION(:) :: CONNECT, OFFSETS +INTEGER(IB4), ALLOCATABLE, DIMENSION(:) :: CELL_TYPE REAL(FB) :: UVEL, VVEL, WVEL, VEL, PLOT3D_MIN, PLOT3D_MAX INTEGER :: IERROR TYPE(VTK_FILE) :: A_VTK_FILE ! A VTK file. @@ -5957,15 +5961,77 @@ SUBROUTINE DUMP_SLCF(T,DT,NM,IFRMT) ITM = ITM+1 ITM1 = 0 ENDIF - WRITE(FN_VTK(NM),'(A,A,I0,A,I8.8,I2.2,A)') TRIM(CHID),'_',NM,'_',ITM,ITM1,'.vtr' + WRITE(FN_VTK(NM),'(A,A,I0,A,I8.8,I2.2,A)') TRIM(CHID),'_',NM,'_',ITM,ITM1,'.vtu' IF (SL%SLICETYPE=='STRUCTURED') THEN ! write out slice file using original slice file format - VTK_ERROR = A_VTK_FILE%INITIALIZE(FORMAT='ascii', FILENAME=FN_VTK(NM), & - MESH_TOPOLOGY='RectilinearGrid', is_volatile=.FALSE., & - NX1=I1, NX2=I2, NY1=J1, NY2=J2, NZ1=K1, NZ2=K2) - ! write one piece - VTK_ERROR = A_VTK_FILE%XML_WRITER%WRITE_PIECE(NX1=I1, NX2=I2, NY1=J1, NY2=J2, NZ1=K1, NZ2=K2) ! Piece Extent - VTK_ERROR = A_VTK_FILE%XML_WRITER%WRITE_GEO(X=MESHES(NM)%XPLT, Y=MESHES(NM)%YPLT, Z=MESHES(NM)%ZPLT) ! Piece coordinates - VTK_ERROR = A_VTK_FILE%XML_WRITER%WRITE_DATAARRAY(LOCATION='NODE', ACTION='open') + VTK_ERROR = A_VTK_FILE%INITIALIZE(FORMAT='BINARY', FILENAME=FN_VTK(NM), MESH_TOPOLOGY='UnstructuredGrid') ! do not change capitalization on mesh topology + + I1=SL%I1 + I2=SL%I2 + J1=SL%J1 + J2=SL%J2 + K1=SL%K1 + K2=SL%K2 + NX = I2 + 1 - I1 + NY = J2 + 1 - J1 + NZ = K2 + 1 - K1 + NP = NX*NY*NZ + NC = (NX-1)*(NY-1)*(NZ-1) + + ! Fill point data + ALLOCATE(X_PTS(NP)) + ALLOCATE(Y_PTS(NP)) + ALLOCATE(Z_PTS(NP)) + IFACT = 1 + DO K = 0, NZ-1 + DO J = 0, NY-1 + DO I = 0, NX-1 + X_PTS(IFACT)=MESHES(NM)%X(I) + Y_PTS(IFACT)=MESHES(NM)%Y(J) + Z_PTS(IFACT)=MESHES(NM)%Z(K) + IFACT = IFACT + 1 + ENDDO + ENDDO + ENDDO + + ! Fill cell data + ALLOCATE(CONNECT(NC*8)) + DO I = 1, NX-1 + IFACT = (I-1) + DO J = 1, NY-1 + JFACT = (J-1)*(NX-1) + DO K = 1, NZ-1 + KFACT = (K - 1)*(NY-1)*(NX-1) + CONNECT((IFACT+JFACT+KFACT)*8+1) = (K-1)*(NY*NX) + (J-1)*NX + I-1 + CONNECT((IFACT+JFACT+KFACT)*8+2) = (K-1)*(NY*NX) + (J-1)*NX + I + CONNECT((IFACT+JFACT+KFACT)*8+3) = (K-1)*(NY*NX) + (J)*NX + I-1 + CONNECT((IFACT+JFACT+KFACT)*8+4) = (K-1)*(NY*NX) + (J)*NX + I + CONNECT((IFACT+JFACT+KFACT)*8+5) = (K)*(NY*NX) + (J-1)*NX + I-1 + CONNECT((IFACT+JFACT+KFACT)*8+6) = (K)*(NY*NX) + (J-1)*NX + I + CONNECT((IFACT+JFACT+KFACT)*8+7) = (K)*(NY*NX) + (J)*NX + I-1 + CONNECT((IFACT+JFACT+KFACT)*8+8) = (K)*(NY*NX) + (J)*NX + I + ENDDO + ENDDO + ENDDO + + ALLOCATE(OFFSETS(NC)) + ALLOCATE(CELL_TYPE(NC)) + + DO I=1,NC + OFFSETS(I) = (I)*8_IB4 + CELL_TYPE(I) = 11_IB4 + ENDDO + + VTK_ERROR = A_VTK_FILE%XML_WRITER%WRITE_PIECE(NP=NP, NC=NC) + VTK_ERROR = A_VTK_FILE%XML_WRITER%WRITE_GEO(NP=NP, NC=NC, X=X_PTS, Y=Y_PTS, Z=Z_PTS) + VTK_ERROR = A_VTK_FILE%XML_WRITER%WRITE_CONNECTIVITY(NC=NC, CONNECTIVITY=CONNECT, OFFSET=OFFSETS, CELL_TYPE=CELL_TYPE) + VTK_ERROR = A_VTK_FILE%XML_WRITER%WRITE_DATAARRAY(LOCATION='NODE', ACTION='OPEN') + + DEALLOCATE(OFFSETS) + DEALLOCATE(CELL_TYPE) + DEALLOCATE(CONNECT) + DEALLOCATE(X_PTS) + DEALLOCATE(Y_PTS) + DEALLOCATE(Z_PTS) ENDIF VTK_INITIALIZED=.TRUE. ENDIF @@ -6268,7 +6334,7 @@ SUBROUTINE DUMP_SLCF(T,DT,NM,IFRMT) IF (VTK3D) THEN ! finish after writing all pieces - VTK_ERROR = A_VTK_FILE%XML_WRITER%WRITE_DATAARRAY(LOCATION='NODE', ACTION='close') + VTK_ERROR = A_VTK_FILE%XML_WRITER%WRITE_DATAARRAY(LOCATION='NODE', ACTION='CLOSE') VTK_ERROR = A_VTK_FILE%XML_WRITER%WRITE_PIECE() VTK_ERROR = A_VTK_FILE%FINALIZE() ENDIF From 2678b8bfff656527ec4d4a5e0e4d69654a889df4 Mon Sep 17 00:00:00 2001 From: Jonathan Hodges <johodges@vt.edu> Date: Thu, 28 Dec 2023 12:54:03 -0500 Subject: [PATCH 15/31] add VTK_BINARY logical flag to read --- Source/cons.f90 | 1 + Source/dump.f90 | 6 +++++- Source/read.f90 | 3 ++- 3 files changed, 8 insertions(+), 2 deletions(-) diff --git a/Source/cons.f90 b/Source/cons.f90 index 93909e7a7f6..f20ca5080aa 100644 --- a/Source/cons.f90 +++ b/Source/cons.f90 @@ -256,6 +256,7 @@ MODULE GLOBAL_CONSTANTS LOGICAL :: REACTING_THIN_OBSTRUCTIONS=.FALSE. !< Thin obstructions that off-gas are present LOGICAL :: SMOKE3D_16=.FALSE. !< Output 3D smoke values using 16 bit integers LOGICAL :: CHECK_BOUNDARY_ONE_D_ARRAYS=.FALSE. !< Flag that indicates that ONE_D array dimensions need to be checked +LOGICAL :: VTK_BINARY=.TRUE. !< Flag that indicates VTK outputs should be binary or ascii INTEGER, ALLOCATABLE, DIMENSION(:) :: CHANGE_TIME_STEP_INDEX !< Flag to indicate if a mesh needs to change time step INTEGER, ALLOCATABLE, DIMENSION(:) :: SETUP_PRESSURE_ZONES_INDEX !< Flag to indicate if a mesh needs to keep searching for ZONEs diff --git a/Source/dump.f90 b/Source/dump.f90 index 924b513c5a5..af7a5e15841 100644 --- a/Source/dump.f90 +++ b/Source/dump.f90 @@ -5963,7 +5963,11 @@ SUBROUTINE DUMP_SLCF(T,DT,NM,IFRMT) ENDIF WRITE(FN_VTK(NM),'(A,A,I0,A,I8.8,I2.2,A)') TRIM(CHID),'_',NM,'_',ITM,ITM1,'.vtu' IF (SL%SLICETYPE=='STRUCTURED') THEN ! write out slice file using original slice file format - VTK_ERROR = A_VTK_FILE%INITIALIZE(FORMAT='BINARY', FILENAME=FN_VTK(NM), MESH_TOPOLOGY='UnstructuredGrid') ! do not change capitalization on mesh topology + IF (VTK_BINARY) THEN + VTK_ERROR = A_VTK_FILE%INITIALIZE(FORMAT='BINARY', FILENAME=FN_VTK(NM), MESH_TOPOLOGY='UnstructuredGrid') + ELSE + VTK_ERROR = A_VTK_FILE%INITIALIZE(FORMAT='ASCII', FILENAME=FN_VTK(NM), MESH_TOPOLOGY='UnstructuredGrid') + ENDIF ! do not change capitalization on mesh topology I1=SL%I1 I2=SL%I2 diff --git a/Source/read.f90 b/Source/read.f90 index 82e24a77416..d9613e2350d 100644 --- a/Source/read.f90 +++ b/Source/read.f90 @@ -2258,7 +2258,7 @@ SUBROUTINE READ_DUMP RAMP_BNDF,RAMP_CPU,RAMP_CTRL,RAMP_DEVC,RAMP_FLUSH,RAMP_HRR,RAMP_HVAC,RAMP_ISOF,RAMP_MASS,& RAMP_PART,RAMP_PL3D,RAMP_PROF,RAMP_RADF,RAMP_RESTART,RAMP_SLCF,RAMP_SL3D,RAMP_SMOKE3D,& RAMP_SPEC,RAMP_TMP,RAMP_UVW,RAMP_VTK,RENDER_FILE,SIG_FIGS,SIG_FIGS_EXP,SMOKE3D,STATUS_FILES,& - SUPPRESS_DIAGNOSTICS,TURB_INIT_CLOCK,VELOCITY_ERROR_FILE,WRITE_XYZ,WRITE_STL + SUPPRESS_DIAGNOSTICS,TURB_INIT_CLOCK,VELOCITY_ERROR_FILE,VTK_BINARY,WRITE_XYZ,WRITE_STL ! Set defaults @@ -2277,6 +2277,7 @@ SUBROUTINE READ_DUMP RENDER_FILE = 'null' SIG_FIGS = 8 SIG_FIGS_EXP = 3 +VTK_BINARY = .TRUE. IF (NMESHES>32) THEN SUPPRESS_DIAGNOSTICS = .TRUE. ELSE From 30fbcd46b64a5a2bc2ad4358982aacd0c9cec03b Mon Sep 17 00:00:00 2001 From: Jonathan Hodges <johodges@vt.edu> Date: Thu, 28 Dec 2023 21:56:45 -0500 Subject: [PATCH 16/31] build with both VTK implementations --- Source/cons.f90 | 2 +- Source/dump.f90 | 30 +++++++- Source/vtk.f90 | 183 ++++++++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 212 insertions(+), 3 deletions(-) create mode 100644 Source/vtk.f90 diff --git a/Source/cons.f90 b/Source/cons.f90 index f20ca5080aa..6f61fa3c0bf 100644 --- a/Source/cons.f90 +++ b/Source/cons.f90 @@ -535,7 +535,7 @@ MODULE GLOBAL_CONSTANTS INTEGER :: LU_HISTOGRAM,LU_HVAC INTEGER :: LU_GEOC=-1,LU_TGA,LU_INFO,LU_DEVC_CTRL=-1,LU_STL INTEGER, ALLOCATABLE, DIMENSION(:) :: LU_PART,LU_PROF,LU_XYZ,LU_TERRAIN,LU_PL3D,LU_DEVC,LU_STATE,LU_CTRL,LU_CORE,LU_RESTART -INTEGER, ALLOCATABLE, DIMENSION(:) :: LU_VEG_OUT,LU_GEOM,LU_CFACE_GEOM +INTEGER, ALLOCATABLE, DIMENSION(:) :: LU_VEG_OUT,LU_GEOM,LU_CFACE_GEOM,LU_VTK INTEGER :: LU_GEOM_TRAN INTEGER, ALLOCATABLE, DIMENSION(:,:) :: LU_SLCF,LU_SLCF_GEOM,LU_BNDF,LU_BNDG,LU_ISOF,LU_ISOF2, & LU_SMOKE3D,LU_RADF diff --git a/Source/dump.f90 b/Source/dump.f90 index af7a5e15841..3e01a6c32d4 100644 --- a/Source/dump.f90 +++ b/Source/dump.f90 @@ -23,6 +23,9 @@ MODULE DUMP USE PENF USE VTK_FORTRAN, ONLY : VTK_FILE #endif /* WITH_VTK */ +USE VTK, ONLY : INITIALIZE_VTK, WRITE_VTK_SLICE_GEOMETRY, WRITE_VTK_SLICE_CELLS, WRITE_VTK_SLICE_DATA,& + FINALIZE_VTK + IMPLICIT NONE (TYPE,EXTERNAL) PRIVATE @@ -133,6 +136,7 @@ SUBROUTINE DUMP_MESH_OUTPUTS(T,DT,NM) ENDDO ENDIF +#ifdef WITH_VTK IF (T>=VTK_CLOCK(VTK_COUNTER(NM)) .OR. STOP_STATUS==INSTABILITY_STOP) THEN CALL DUMP_SLCF(T,DT,NM,3) DO WHILE(VTK_COUNTER(NM)<SIZE(VTK_CLOCK)-1) @@ -140,6 +144,7 @@ SUBROUTINE DUMP_MESH_OUTPUTS(T,DT,NM) IF (VTK_CLOCK(VTK_COUNTER(NM))>=T) EXIT ENDDO ENDIF +#endif /* WITH_VTK */ IF (T>=BNDF_CLOCK(BNDF_COUNTER(NM))) THEN CALL DUMP_BNDF(T,DT,NM) @@ -339,6 +344,7 @@ SUBROUTINE ASSIGN_FILE_NAMES ALLOCATE(FN_PL3D(2*NMESHES)) ALLOCATE(LU_PL3D(2*NMESHES)) ALLOCATE(FN_VTK(NMESHES)) +ALLOCATE(LU_VTK(NMESHES)) ALLOCATE(FN_ISOF(N_ISOF,NMESHES)) ALLOCATE(LU_ISOF(N_ISOF,NMESHES)) @@ -485,6 +491,10 @@ SUBROUTINE ASSIGN_FILE_NAMES WRITE(FN_RESTART(NM),'(A,A,I0,A)') TRIM(RESTART_CHID),'_',NM,'.restart' LU_CORE(NM) = GET_FILE_NUMBER() WRITE(FN_CORE(NM), '(A,A,I0,A)') TRIM(CHID),'_',NM,'.restart' + + ! VTK Files + LU_VTK(NM) = GET_FILE_NUMBER() ! slice file + ENDDO MESH_LOOP @@ -6030,6 +6040,12 @@ SUBROUTINE DUMP_SLCF(T,DT,NM,IFRMT) VTK_ERROR = A_VTK_FILE%XML_WRITER%WRITE_CONNECTIVITY(NC=NC, CONNECTIVITY=CONNECT, OFFSET=OFFSETS, CELL_TYPE=CELL_TYPE) VTK_ERROR = A_VTK_FILE%XML_WRITER%WRITE_DATAARRAY(LOCATION='NODE', ACTION='OPEN') + WRITE(FN_VTK(NM),'(A,A,I0,A,I8.8,I2.2,A)') TRIM(CHID),'_',NM,'_',ITM,ITM1,'_new.vtu' + CALL INITIALIZE_VTK(NM,'UnstructuredGrid') + CALL WRITE_VTK_SLICE_GEOMETRY(NM, NP, NC, X_PTS, Y_PTS, Z_PTS, 'ascii') + CALL WRITE_VTK_SLICE_CELLS(NM, CONNECT, OFFSETS, CELL_TYPE, 'ascii') + WRITE(FN_VTK(NM),'(A,A,I0,A,I8.8,I2.2,A)') TRIM(CHID),'_',NM,'_',ITM,ITM1,'.vtu' + DEALLOCATE(OFFSETS) DEALLOCATE(CELL_TYPE) DEALLOCATE(CONNECT) @@ -6331,20 +6347,30 @@ SUBROUTINE DUMP_SLCF(T,DT,NM,IFRMT) ! write one quantity VTK_ERROR = A_VTK_FILE%XML_WRITER%WRITE_DATAARRAY(DATA_NAME=SL%SMOKEVIEW_LABEL(1:30), X=QQ_PACK) + + WRITE(FN_VTK(NM),'(A,A,I0,A,I8.8,I2.2,A)') TRIM(CHID),'_',NM,'_',ITM,ITM1,'_new.vtu' + CALL WRITE_VTK_SLICE_DATA(NM, QQ_PACK, SL%SMOKEVIEW_LABEL(1:30), 'ascii') + WRITE(FN_VTK(NM),'(A,A,I0,A,I8.8,I2.2,A)') TRIM(CHID),'_',NM,'_',ITM,ITM1,'.vtu' + DEALLOCATE(QQ_PACK) ENDIF ENDIF ENDIF +ENDDO QUANTITY_LOOP + IF (VTK3D) THEN ! finish after writing all pieces VTK_ERROR = A_VTK_FILE%XML_WRITER%WRITE_DATAARRAY(LOCATION='NODE', ACTION='CLOSE') VTK_ERROR = A_VTK_FILE%XML_WRITER%WRITE_PIECE() VTK_ERROR = A_VTK_FILE%FINALIZE() + + WRITE(FN_VTK(NM),'(A,A,I0,A,I8.8,I2.2,A)') TRIM(CHID),'_',NM,'_',ITM,ITM1,'_new.vtu' + CALL FINALIZE_VTK(NM,'UnstructuredGrid') + WRITE(FN_VTK(NM),'(A,A,I0,A,I8.8,I2.2,A)') TRIM(CHID),'_',NM,'_',ITM,ITM1,'.vtu' + ENDIF -ENDDO QUANTITY_LOOP - ! Write out the PLOT3D ``q'' file IF (PLOT3D) THEN diff --git a/Source/vtk.f90 b/Source/vtk.f90 new file mode 100644 index 00000000000..37329eebe77 --- /dev/null +++ b/Source/vtk.f90 @@ -0,0 +1,183 @@ +!> \brief Routines for handling vtk output + +MODULE VTK + +USE MESH_VARIABLES +USE GLOBAL_CONSTANTS + +IMPLICIT NONE (TYPE,EXTERNAL) +PRIVATE + +PUBLIC INITIALIZE_VTK,WRITE_VTK_SLICE_GEOMETRY,WRITE_VTK_SLICE_CELLS,WRITE_VTK_SLICE_DATA,FINALIZE_VTK + +CONTAINS + +SUBROUTINE INITIALIZE_VTK(NM,MESH_TOPOLOGY) + +INTEGER, INTENT(IN) :: NM +CHARACTER(LEN=*), INTENT(IN) :: MESH_TOPOLOGY + +OPEN(LU_VTK(NM),FILE=FN_VTK(NM),FORM='FORMATTED') +WRITE(LU_VTK(NM),'(A)',ADVANCE='YES') '<?xml version="1.0"?>' +WRITE(LU_VTK(NM),'(A,A,A)',ADVANCE='YES') '<VTKFile type="',TRIM(MESH_TOPOLOGY),'" version="1.0" byte_order="LittleEndian">' +WRITE(LU_VTK(NM),'(A,A,A)',ADVANCE='YES') ' <',TRIM(MESH_TOPOLOGY),'>' +CLOSE(LU_VTK(NM)) +END SUBROUTINE INITIALIZE_VTK + +SUBROUTINE WRITE_VTK_SLICE_GEOMETRY(NM, NP, NC, X_PTS, Y_PTS, Z_PTS, FORMAT) + +INTEGER, INTENT(IN) :: NM, NC, NP +REAL(FB), DIMENSION(:), INTENT(IN) :: X_PTS, Y_PTS, Z_PTS +CHARACTER(LEN=*), INTENT(IN) :: FORMAT +INTEGER :: I + +OPEN(LU_VTK(NM),FILE=FN_VTK(NM),FORM='FORMATTED',STATUS='OLD',POSITION='APPEND') +WRITE(LU_VTK(NM),'(A,I0,A,I0,A)',ADVANCE='YES') ' <Piece NumberOfPoints="',NP,'" NumberOfCells="',NC,'">' +WRITE(LU_VTK(NM),'(A)',ADVANCE='YES') ' <Points>' +WRITE(LU_VTK(NM),'(A,A,A)',ADVANCE='YES') & + ' <DataArray type="Float32" NumberOfComponents="3" Name="Points" format="',FORMAT,'">' + +WRITE(LU_VTK(NM),'(A)',ADVANCE='NO') ' ' +IF (TRIM(ADJUSTL(FORMAT)) .eq. 'ascii') THEN + DO I=1,NP + WRITE(LU_VTK(NM),'(E15.8,A,E15.8,A,E15.8,A)',ADVANCE='NO') X_PTS(I),' ',Y_PTS(I),' ',Z_PTS(I),' ' + ENDDO +ENDIF +WRITE(LU_VTK(NM),'(A)',ADVANCE='YES') ' ' +WRITE(LU_VTK(NM),'(A)',ADVANCE='YES') ' </DataArray>' +WRITE(LU_VTK(NM),'(A)',ADVANCE='YES') ' </Points>' +CLOSE(LU_VTK(NM)) + +END SUBROUTINE WRITE_VTK_SLICE_GEOMETRY + +SUBROUTINE WRITE_VTK_SLICE_CELLS(NM, CONNECT, OFFSETS, CELL_TYPE, FORMAT) + +INTEGER, INTENT(IN) :: NM +INTEGER, DIMENSION(:), INTENT(IN) :: CONNECT, OFFSETS +INTEGER(IB4), DIMENSION(:), INTENT(IN) :: CELL_TYPE +CHARACTER(LEN=*), INTENT(IN) :: FORMAT +INTEGER :: I + +! Open cells section +OPEN(LU_VTK(NM),FILE=FN_VTK(NM),FORM='FORMATTED',STATUS='OLD',POSITION='APPEND') +WRITE(LU_VTK(NM),'(A)',ADVANCE='YES') ' <Cells>' + +! Write connectivity +WRITE(LU_VTK(NM),'(A,A,A)',ADVANCE='YES') & + ' <DataArray type="Int32" NumberOfComponents="1" Name="connectivity" format="',FORMAT,'">' + +WRITE(LU_VTK(NM),'(A)',ADVANCE='NO') ' ' +IF (TRIM(ADJUSTL(FORMAT)) .eq. 'ascii') THEN + DO I=1,SIZE(CONNECT) + WRITE(LU_VTK(NM),'(I0,A)',ADVANCE='NO') CONNECT(I), ' ' + ENDDO +ENDIF +WRITE(LU_VTK(NM),'(A)',ADVANCE='YES') ' ' +WRITE(LU_VTK(NM),'(A)',ADVANCE='YES') ' </DataArray>' + +! Write offsets +WRITE(LU_VTK(NM),'(A,A,A)',ADVANCE='YES') & + ' <DataArray type="Int32" NumberOfComponents="1" Name="offsets" format="',FORMAT,'">' + +WRITE(LU_VTK(NM),'(A)',ADVANCE='NO') ' ' +IF (TRIM(ADJUSTL(FORMAT)) .eq. 'ascii') THEN + DO I=1,SIZE(OFFSETS) + WRITE(LU_VTK(NM),'(I0,A)',ADVANCE='NO') OFFSETS(I), ' ' + ENDDO +ENDIF +WRITE(LU_VTK(NM),'(A)',ADVANCE='YES') ' ' +WRITE(LU_VTK(NM),'(A)',ADVANCE='YES') ' </DataArray>' + +! Write cell types +WRITE(LU_VTK(NM),'(A,A,A)',ADVANCE='YES') & + ' <DataArray type="Int8" NumberOfComponents="1" Name="types" format="',FORMAT,'">' + +WRITE(LU_VTK(NM),'(A)',ADVANCE='NO') ' ' +IF (TRIM(ADJUSTL(FORMAT)) .eq. 'ascii') THEN + DO I=1,SIZE(CELL_TYPE) + WRITE(LU_VTK(NM),'(I0,A)',ADVANCE='NO') CELL_TYPE(I), ' ' + ENDDO +ENDIF +WRITE(LU_VTK(NM),'(A)',ADVANCE='YES') ' ' +WRITE(LU_VTK(NM),'(A)',ADVANCE='YES') ' </DataArray>' + +! Close cell section +WRITE(LU_VTK(NM),'(A)',ADVANCE='YES') ' </Cells>' + +! Open point data section +WRITE(LU_VTK(NM),'(A)',ADVANCE='YES') ' <PointData>' + +CLOSE(LU_VTK(NM)) + +END SUBROUTINE WRITE_VTK_SLICE_CELLS + +SUBROUTINE WRITE_VTK_SLICE_DATA(NM, DATA, DATA_NAME, FORMAT) + +INTEGER, INTENT(IN) :: NM +CHARACTER(LEN=*), INTENT(IN) :: FORMAT, DATA_NAME +CHARACTER(LEN=:), ALLOCATABLE :: CODE +REAL(FB), DIMENSION(:) :: DATA +INTEGER :: I + +! Open data section +OPEN(LU_VTK(NM),FILE=FN_VTK(NM),FORM='FORMATTED',STATUS='OLD',POSITION='APPEND') + +! Write data +WRITE(LU_VTK(NM),'(A,A,A,A,A)',ADVANCE='YES') & + ' <DataArray type="Float32" NumberOfComponents="1" Name="',& + TRIM(DATA_NAME),'" format="',FORMAT,'">' + +WRITE(LU_VTK(NM),'(A)',ADVANCE='NO') ' ' +IF (TRIM(ADJUSTL(FORMAT)) .EQ. 'ascii') THEN + DO I=1,SIZE(DATA) + WRITE(LU_VTK(NM),'(E15.8,A)',ADVANCE='NO') DATA(I), ' ' + ENDDO +ELSEIF (TRIM(ADJUSTL(FORMAT)) .EQ. 'binary') THEN + !CODE=ENCODE_ASCII_DATAARRAY1_RANK1_FB(DATA) + !WRITE(LU_VTK(NM)) CODE +ENDIF +WRITE(LU_VTK(NM),'(A)',ADVANCE='YES') ' ' + +! Close data section +WRITE(LU_VTK(NM),'(A)',ADVANCE='YES') ' </DataArray>' +CLOSE(LU_VTK(NM)) + +END SUBROUTINE WRITE_VTK_SLICE_DATA + +SUBROUTINE FINALIZE_VTK(NM,MESH_TOPOLOGY) + +INTEGER, INTENT(IN) :: NM +CHARACTER(LEN=*), INTENT(IN) :: MESH_TOPOLOGY + +! Close VTK file +OPEN(LU_VTK(NM),FILE=FN_VTK(NM),FORM='FORMATTED',STATUS='OLD',POSITION='APPEND') +WRITE(LU_VTK(NM),'(A)',ADVANCE='YES') ' </PointData>' +WRITE(LU_VTK(NM),'(A)',ADVANCE='YES') ' </Piece>' +WRITE(LU_VTK(NM),'(A,A,A)',ADVANCE='YES') ' </',TRIM(MESH_TOPOLOGY),'>' +WRITE(LU_VTK(NM),'(A)',ADVANCE='YES') '</VTKFile>' + +CLOSE(LU_VTK(NM)) +END SUBROUTINE FINALIZE_VTK + +END MODULE VTK + +!FUNCTION ENCODE_ASCII_DATAARRAY1_RANK1_FB(X) RESULT(CODE) +!!< Encode (Base64) a dataarray with 1 components of rank 1 (FB). +!REAL(FB), INTENT(IN) :: X(1:) !< Data variable. +!CHARACTER(len=:), ALLOCATABLE :: CODE !< Encoded base64 dataarray. +!INTEGER(IB16) :: N !< Counter. +!INTEGER(IB16) :: L !< Length +!INTEGER(IB16) :: SP !< String pointer +!INTEGER(IB16) :: SIZE_N!< Dimension size +! +!SIZE_N = SIZE(X,DIM=1) +!L = DI2P+1 +!SP = 0 +!CODE = REPEAT(' ',L*SIZE_N) +!DO N = 1,SIZE_N +! CODE(SP+1:SP+L) = STR(N=X(N)) +! SP = SP + L +!ENDDO +!ENDFUNCTION ENCODE_ASCII_DATAARRAY1_RANK1_FB +! +!END MODULE VTK From 12c916597b1bc3cd5cbb1810de2cc5899e47a8b1 Mon Sep 17 00:00:00 2001 From: Jonathan Hodges <johodges@vt.edu> Date: Thu, 28 Dec 2023 22:18:29 -0500 Subject: [PATCH 17/31] swap to custom vtk module --- Source/dump.f90 | 32 -------------------------------- 1 file changed, 32 deletions(-) diff --git a/Source/dump.f90 b/Source/dump.f90 index 3e01a6c32d4..d0432b95d2d 100644 --- a/Source/dump.f90 +++ b/Source/dump.f90 @@ -19,10 +19,6 @@ MODULE DUMP CC_VGSC,CC_GASPHASE,MAKE_UNIQUE_VERT_ARRAY,AVERAGE_FACE_VALUES USE CC_SCALARS, ONLY : ADD_Q_DOT_CUTCELLS,GET_PRES_CFACE,GET_PRES_CFACE_TEST,GET_UVWGAS_CFACE,GET_MUDNS_CFACE -#ifdef WITH_VTK -USE PENF -USE VTK_FORTRAN, ONLY : VTK_FILE -#endif /* WITH_VTK */ USE VTK, ONLY : INITIALIZE_VTK, WRITE_VTK_SLICE_GEOMETRY, WRITE_VTK_SLICE_CELLS, WRITE_VTK_SLICE_DATA,& FINALIZE_VTK @@ -136,7 +132,6 @@ SUBROUTINE DUMP_MESH_OUTPUTS(T,DT,NM) ENDDO ENDIF -#ifdef WITH_VTK IF (T>=VTK_CLOCK(VTK_COUNTER(NM)) .OR. STOP_STATUS==INSTABILITY_STOP) THEN CALL DUMP_SLCF(T,DT,NM,3) DO WHILE(VTK_COUNTER(NM)<SIZE(VTK_CLOCK)-1) @@ -144,7 +139,6 @@ SUBROUTINE DUMP_MESH_OUTPUTS(T,DT,NM) IF (VTK_CLOCK(VTK_COUNTER(NM))>=T) EXIT ENDDO ENDIF -#endif /* WITH_VTK */ IF (T>=BNDF_CLOCK(BNDF_COUNTER(NM))) THEN CALL DUMP_BNDF(T,DT,NM) @@ -5813,8 +5807,6 @@ SUBROUTINE DUMP_SLCF(T,DT,NM,IFRMT) INTEGER(IB4), ALLOCATABLE, DIMENSION(:) :: CELL_TYPE REAL(FB) :: UVEL, VVEL, WVEL, VEL, PLOT3D_MIN, PLOT3D_MAX INTEGER :: IERROR -TYPE(VTK_FILE) :: A_VTK_FILE ! A VTK file. -INTEGER(IB4) :: VTK_ERROR=0_IB4 !< IO Error status. LOGICAL :: VTK_INITIALIZED ! Return if there are no slices to process and this is not a Plot3D dump @@ -5973,11 +5965,6 @@ SUBROUTINE DUMP_SLCF(T,DT,NM,IFRMT) ENDIF WRITE(FN_VTK(NM),'(A,A,I0,A,I8.8,I2.2,A)') TRIM(CHID),'_',NM,'_',ITM,ITM1,'.vtu' IF (SL%SLICETYPE=='STRUCTURED') THEN ! write out slice file using original slice file format - IF (VTK_BINARY) THEN - VTK_ERROR = A_VTK_FILE%INITIALIZE(FORMAT='BINARY', FILENAME=FN_VTK(NM), MESH_TOPOLOGY='UnstructuredGrid') - ELSE - VTK_ERROR = A_VTK_FILE%INITIALIZE(FORMAT='ASCII', FILENAME=FN_VTK(NM), MESH_TOPOLOGY='UnstructuredGrid') - ENDIF ! do not change capitalization on mesh topology I1=SL%I1 I2=SL%I2 @@ -6035,16 +6022,9 @@ SUBROUTINE DUMP_SLCF(T,DT,NM,IFRMT) CELL_TYPE(I) = 11_IB4 ENDDO - VTK_ERROR = A_VTK_FILE%XML_WRITER%WRITE_PIECE(NP=NP, NC=NC) - VTK_ERROR = A_VTK_FILE%XML_WRITER%WRITE_GEO(NP=NP, NC=NC, X=X_PTS, Y=Y_PTS, Z=Z_PTS) - VTK_ERROR = A_VTK_FILE%XML_WRITER%WRITE_CONNECTIVITY(NC=NC, CONNECTIVITY=CONNECT, OFFSET=OFFSETS, CELL_TYPE=CELL_TYPE) - VTK_ERROR = A_VTK_FILE%XML_WRITER%WRITE_DATAARRAY(LOCATION='NODE', ACTION='OPEN') - - WRITE(FN_VTK(NM),'(A,A,I0,A,I8.8,I2.2,A)') TRIM(CHID),'_',NM,'_',ITM,ITM1,'_new.vtu' CALL INITIALIZE_VTK(NM,'UnstructuredGrid') CALL WRITE_VTK_SLICE_GEOMETRY(NM, NP, NC, X_PTS, Y_PTS, Z_PTS, 'ascii') CALL WRITE_VTK_SLICE_CELLS(NM, CONNECT, OFFSETS, CELL_TYPE, 'ascii') - WRITE(FN_VTK(NM),'(A,A,I0,A,I8.8,I2.2,A)') TRIM(CHID),'_',NM,'_',ITM,ITM1,'.vtu' DEALLOCATE(OFFSETS) DEALLOCATE(CELL_TYPE) @@ -6345,12 +6325,7 @@ SUBROUTINE DUMP_SLCF(T,DT,NM,IFRMT) ENDDO ENDDO - ! write one quantity - VTK_ERROR = A_VTK_FILE%XML_WRITER%WRITE_DATAARRAY(DATA_NAME=SL%SMOKEVIEW_LABEL(1:30), X=QQ_PACK) - - WRITE(FN_VTK(NM),'(A,A,I0,A,I8.8,I2.2,A)') TRIM(CHID),'_',NM,'_',ITM,ITM1,'_new.vtu' CALL WRITE_VTK_SLICE_DATA(NM, QQ_PACK, SL%SMOKEVIEW_LABEL(1:30), 'ascii') - WRITE(FN_VTK(NM),'(A,A,I0,A,I8.8,I2.2,A)') TRIM(CHID),'_',NM,'_',ITM,ITM1,'.vtu' DEALLOCATE(QQ_PACK) ENDIF @@ -6361,14 +6336,7 @@ SUBROUTINE DUMP_SLCF(T,DT,NM,IFRMT) IF (VTK3D) THEN ! finish after writing all pieces - VTK_ERROR = A_VTK_FILE%XML_WRITER%WRITE_DATAARRAY(LOCATION='NODE', ACTION='CLOSE') - VTK_ERROR = A_VTK_FILE%XML_WRITER%WRITE_PIECE() - VTK_ERROR = A_VTK_FILE%FINALIZE() - - WRITE(FN_VTK(NM),'(A,A,I0,A,I8.8,I2.2,A)') TRIM(CHID),'_',NM,'_',ITM,ITM1,'_new.vtu' CALL FINALIZE_VTK(NM,'UnstructuredGrid') - WRITE(FN_VTK(NM),'(A,A,I0,A,I8.8,I2.2,A)') TRIM(CHID),'_',NM,'_',ITM,ITM1,'.vtu' - ENDIF ! Write out the PLOT3D ``q'' file From e17c7a971a7025d0bd4da4359c4cdaa1d47a9def Mon Sep 17 00:00:00 2001 From: Jonathan Hodges <johodges@vt.edu> Date: Fri, 29 Dec 2023 12:16:00 -0500 Subject: [PATCH 18/31] locate vtk files in results/ directory --- Source/c_mkdir.c | 11 +++++++++++ Source/dump.f90 | 6 +++++- Source/f_mkdir.f90 | 12 ++++++++++++ Source/vtk.f90 | 1 - 4 files changed, 28 insertions(+), 2 deletions(-) create mode 100644 Source/c_mkdir.c create mode 100644 Source/f_mkdir.f90 diff --git a/Source/c_mkdir.c b/Source/c_mkdir.c new file mode 100644 index 00000000000..de730241478 --- /dev/null +++ b/Source/c_mkdir.c @@ -0,0 +1,11 @@ +#include <sys/types.h> +#include <sys/stat.h> +#include <unistd.h> + +void c_mkdir(const char*directory){ + struct stat st = {0}; + if (stat(directory, &st) == -1) { + mkdir(directory, 0700); + } +} + diff --git a/Source/dump.f90 b/Source/dump.f90 index d0432b95d2d..b8ed92c7e8c 100644 --- a/Source/dump.f90 +++ b/Source/dump.f90 @@ -22,6 +22,9 @@ MODULE DUMP USE VTK, ONLY : INITIALIZE_VTK, WRITE_VTK_SLICE_GEOMETRY, WRITE_VTK_SLICE_CELLS, WRITE_VTK_SLICE_DATA,& FINALIZE_VTK +USE F_MKDIR, ONLY : C_MKDIR +USE ISO_C_BINDING + IMPLICIT NONE (TYPE,EXTERNAL) PRIVATE @@ -5963,7 +5966,7 @@ SUBROUTINE DUMP_SLCF(T,DT,NM,IFRMT) ITM = ITM+1 ITM1 = 0 ENDIF - WRITE(FN_VTK(NM),'(A,A,I0,A,I8.8,I2.2,A)') TRIM(CHID),'_',NM,'_',ITM,ITM1,'.vtu' + WRITE(FN_VTK(NM),'(A,A,A,I0,A,I8.8,I2.2,A)') "./results/",TRIM(CHID),'_',NM,'_',ITM,ITM1,'.vtu' IF (SL%SLICETYPE=='STRUCTURED') THEN ! write out slice file using original slice file format I1=SL%I1 @@ -6022,6 +6025,7 @@ SUBROUTINE DUMP_SLCF(T,DT,NM,IFRMT) CELL_TYPE(I) = 11_IB4 ENDDO + CALL C_MKDIR("./results"//char(0)) CALL INITIALIZE_VTK(NM,'UnstructuredGrid') CALL WRITE_VTK_SLICE_GEOMETRY(NM, NP, NC, X_PTS, Y_PTS, Z_PTS, 'ascii') CALL WRITE_VTK_SLICE_CELLS(NM, CONNECT, OFFSETS, CELL_TYPE, 'ascii') diff --git a/Source/f_mkdir.f90 b/Source/f_mkdir.f90 new file mode 100644 index 00000000000..5ee69b0f6e6 --- /dev/null +++ b/Source/f_mkdir.f90 @@ -0,0 +1,12 @@ +MODULE F_MKDIR + + USE ISO_C_BINDING + + INTERFACE + SUBROUTINE C_MKDIR(DIRECTORY) BIND(C) + USE ISO_C_BINDING + CHARACTER(KIND=C_CHAR),INTENT(IN) :: DIRECTORY(*) + END SUBROUTINE + END INTERFACE + +END MODULE diff --git a/Source/vtk.f90 b/Source/vtk.f90 index 37329eebe77..59fe3780ee6 100644 --- a/Source/vtk.f90 +++ b/Source/vtk.f90 @@ -16,7 +16,6 @@ SUBROUTINE INITIALIZE_VTK(NM,MESH_TOPOLOGY) INTEGER, INTENT(IN) :: NM CHARACTER(LEN=*), INTENT(IN) :: MESH_TOPOLOGY - OPEN(LU_VTK(NM),FILE=FN_VTK(NM),FORM='FORMATTED') WRITE(LU_VTK(NM),'(A)',ADVANCE='YES') '<?xml version="1.0"?>' WRITE(LU_VTK(NM),'(A,A,A)',ADVANCE='YES') '<VTKFile type="',TRIM(MESH_TOPOLOGY),'" version="1.0" byte_order="LittleEndian">' From 29af7f755163a0dfe2f4b7d8d83b6c51683c9826 Mon Sep 17 00:00:00 2001 From: Jonathan Hodges <johodges@vt.edu> Date: Sat, 30 Dec 2023 21:47:17 -0500 Subject: [PATCH 19/31] add SMOKE3D VTK output --- Source/cons.f90 | 56 +++--- Source/dump.f90 | 183 +++++++++--------- Source/func.f90 | 3 +- Source/vtk.f90 | 482 +++++++++++++++++++++++++++++++++++++++++------- 4 files changed, 540 insertions(+), 184 deletions(-) diff --git a/Source/cons.f90 b/Source/cons.f90 index 6f61fa3c0bf..18ccfd1d280 100644 --- a/Source/cons.f90 +++ b/Source/cons.f90 @@ -535,7 +535,7 @@ MODULE GLOBAL_CONSTANTS INTEGER :: LU_HISTOGRAM,LU_HVAC INTEGER :: LU_GEOC=-1,LU_TGA,LU_INFO,LU_DEVC_CTRL=-1,LU_STL INTEGER, ALLOCATABLE, DIMENSION(:) :: LU_PART,LU_PROF,LU_XYZ,LU_TERRAIN,LU_PL3D,LU_DEVC,LU_STATE,LU_CTRL,LU_CORE,LU_RESTART -INTEGER, ALLOCATABLE, DIMENSION(:) :: LU_VEG_OUT,LU_GEOM,LU_CFACE_GEOM,LU_VTK +INTEGER, ALLOCATABLE, DIMENSION(:) :: LU_VEG_OUT,LU_GEOM,LU_CFACE_GEOM,LU_SL3D_VTK,LU_SMOKE3D_VTK INTEGER :: LU_GEOM_TRAN INTEGER, ALLOCATABLE, DIMENSION(:,:) :: LU_SLCF,LU_SLCF_GEOM,LU_BNDF,LU_BNDG,LU_ISOF,LU_ISOF2, & LU_SMOKE3D,LU_RADF @@ -546,10 +546,10 @@ MODULE GLOBAL_CONSTANTS CHARACTER(80) :: FN_MASS,FN_HRR,FN_STEPS,FN_SMV,FN_END,FN_ERR,FN_NOTREADY,FN_VELOCITY_ERROR,FN_GIT CHARACTER(80) :: FN_LINE,FN_HISTOGRAM,FN_CUTCELL,FN_TGA,FN_DEVC_CTRL,FN_HVAC,FN_STL CHARACTER(80), ALLOCATABLE, DIMENSION(:) :: FN_PART,FN_PROF,FN_XYZ,FN_TERRAIN,FN_PL3D,FN_DEVC,FN_STATE,FN_CTRL,FN_CORE,FN_RESTART -CHARACTER(80), ALLOCATABLE, DIMENSION(:) :: FN_VEG_OUT,FN_GEOM, FN_CFACE_GEOM, FN_VTK +CHARACTER(80), ALLOCATABLE, DIMENSION(:) :: FN_VEG_OUT,FN_GEOM, FN_CFACE_GEOM CHARACTER(80), ALLOCATABLE, DIMENSION(:,:) :: FN_SLCF,FN_SLCF_GEOM,FN_BNDF,FN_BNDG, & FN_ISOF,FN_ISOF2,FN_SMOKE3D,FN_RADF - +CHARACTER(200), ALLOCATABLE, DIMENSION(:) :: FN_SL3D_VTK,FN_SMOKE3D_VTK CHARACTER(9) :: FMT_R LOGICAL :: OUT_FILE_OPENED=.FALSE. @@ -739,35 +739,37 @@ MODULE OUTPUT_CLOCKS USE PRECISION_PARAMETERS IMPLICIT NONE (TYPE,EXTERNAL) -INTEGER :: RAMP_BNDF_INDEX=0 !< Ramp index for boundary file time series -INTEGER :: RAMP_CTRL_INDEX=0 !< Ramp index for control file time series -INTEGER :: RAMP_CPU_INDEX =0 !< Ramp index for CPU file time series -INTEGER :: RAMP_DEVC_INDEX=0 !< Ramp index for device file time series -INTEGER :: RAMP_FLSH_INDEX=0 !< Ramp index for flush time series -INTEGER :: RAMP_GEOM_INDEX=0 !< Ramp index for geometry output -INTEGER :: RAMP_HRR_INDEX =0 !< Ramp index for hrr file time series -INTEGER :: RAMP_HVAC_INDEX=0 !< Ramp index for hvac file time series -INTEGER :: RAMP_ISOF_INDEX=0 !< Ramp index for isosurface file time series -INTEGER :: RAMP_MASS_INDEX=0 !< Ramp index for mass file time series -INTEGER :: RAMP_PART_INDEX=0 !< Ramp index for particle file time series -INTEGER :: RAMP_PL3D_INDEX=0 !< Ramp index for Plot3D file time series -INTEGER :: RAMP_PROF_INDEX=0 !< Ramp index for profile file time series -INTEGER :: RAMP_RADF_INDEX=0 !< Ramp index for radiation file time series -INTEGER :: RAMP_RSRT_INDEX=0 !< Ramp index for restart file time series -INTEGER :: RAMP_SLCF_INDEX=0 !< Ramp index for slice file time series -INTEGER :: RAMP_SL3D_INDEX=0 !< Ramp index for 3D slice file time series -INTEGER :: RAMP_SM3D_INDEX=0 !< Ramp index for smoke3d file time series -INTEGER :: RAMP_UVW_INDEX =0 !< Ramp index for velocity file time series -INTEGER :: RAMP_TMP_INDEX =0 !< Ramp index for temperature file time series -INTEGER :: RAMP_SPEC_INDEX=0 !< Ramp index for species file time series -INTEGER :: RAMP_VTK_INDEX=0 !< Ramp index for vtk file time series +INTEGER :: RAMP_BNDF_INDEX=0 !< Ramp index for boundary file time series +INTEGER :: RAMP_CTRL_INDEX=0 !< Ramp index for control file time series +INTEGER :: RAMP_CPU_INDEX =0 !< Ramp index for CPU file time series +INTEGER :: RAMP_DEVC_INDEX=0 !< Ramp index for device file time series +INTEGER :: RAMP_FLSH_INDEX=0 !< Ramp index for flush time series +INTEGER :: RAMP_GEOM_INDEX=0 !< Ramp index for geometry output +INTEGER :: RAMP_HRR_INDEX =0 !< Ramp index for hrr file time series +INTEGER :: RAMP_HVAC_INDEX=0 !< Ramp index for hvac file time series +INTEGER :: RAMP_ISOF_INDEX=0 !< Ramp index for isosurface file time series +INTEGER :: RAMP_MASS_INDEX=0 !< Ramp index for mass file time series +INTEGER :: RAMP_PART_INDEX=0 !< Ramp index for particle file time series +INTEGER :: RAMP_PL3D_INDEX=0 !< Ramp index for Plot3D file time series +INTEGER :: RAMP_PROF_INDEX=0 !< Ramp index for profile file time series +INTEGER :: RAMP_RADF_INDEX=0 !< Ramp index for radiation file time series +INTEGER :: RAMP_RSRT_INDEX=0 !< Ramp index for restart file time series +INTEGER :: RAMP_SLCF_INDEX=0 !< Ramp index for slice file time series +INTEGER :: RAMP_SL3D_INDEX=0 !< Ramp index for 3D slice file time series +INTEGER :: RAMP_SM3D_INDEX=0 !< Ramp index for smoke3d file time series +INTEGER :: RAMP_UVW_INDEX =0 !< Ramp index for velocity file time series +INTEGER :: RAMP_TMP_INDEX =0 !< Ramp index for temperature file time series +INTEGER :: RAMP_SPEC_INDEX=0 !< Ramp index for species file time series +INTEGER :: RAMP_SL3D_VTK_INDEX=0 !< Ramp index for vtk file time series +INTEGER :: RAMP_SM3D_VTK_INDEX=0 !< Ramp index for vtk file time series REAL(EB), ALLOCATABLE, DIMENSION(:) :: BNDF_CLOCK, CPU_CLOCK,CTRL_CLOCK,DEVC_CLOCK,FLSH_CLOCK,GEOM_CLOCK, HRR_CLOCK,HVAC_CLOCK,& ISOF_CLOCK,MASS_CLOCK,PART_CLOCK,PL3D_CLOCK,PROF_CLOCK,RADF_CLOCK,RSRT_CLOCK,& - SLCF_CLOCK,SL3D_CLOCK,SM3D_CLOCK,UVW_CLOCK ,TMP_CLOCK ,SPEC_CLOCK,VTK_CLOCK + SLCF_CLOCK,SL3D_CLOCK,SM3D_CLOCK,UVW_CLOCK ,TMP_CLOCK ,SPEC_CLOCK,& + SL3D_VTK_CLOCK,SM3D_VTK_CLOCK INTEGER, ALLOCATABLE, DIMENSION(:) :: BNDF_COUNTER, CPU_COUNTER,CTRL_COUNTER,DEVC_COUNTER,FLSH_COUNTER,GEOM_COUNTER, HRR_COUNTER,& HVAC_COUNTER,ISOF_COUNTER,MASS_COUNTER,PART_COUNTER,PL3D_COUNTER,PROF_COUNTER,RADF_COUNTER,& RSRT_COUNTER,SLCF_COUNTER,SL3D_COUNTER,SM3D_COUNTER,UVW_COUNTER ,TMP_COUNTER ,SPEC_COUNTER,& - VTK_COUNTER + SL3D_VTK_COUNTER,SM3D_VTK_COUNTER REAL(EB) :: TURB_INIT_CLOCK=-1.E10_EB REAL(EB) :: MMS_TIMER=1.E10_EB REAL(EB) :: DT_SLCF,DT_BNDF,DT_DEVC,DT_PL3D,DT_PART,DT_RESTART,DT_ISOF,DT_HRR,DT_HVAC,DT_MASS,DT_PROF,DT_CTRL,& diff --git a/Source/dump.f90 b/Source/dump.f90 index b8ed92c7e8c..f81e5ff0d0e 100644 --- a/Source/dump.f90 +++ b/Source/dump.f90 @@ -20,7 +20,7 @@ MODULE DUMP USE CC_SCALARS, ONLY : ADD_Q_DOT_CUTCELLS,GET_PRES_CFACE,GET_PRES_CFACE_TEST,GET_UVWGAS_CFACE,GET_MUDNS_CFACE USE VTK, ONLY : INITIALIZE_VTK, WRITE_VTK_SLICE_GEOMETRY, WRITE_VTK_SLICE_CELLS, WRITE_VTK_SLICE_DATA,& - FINALIZE_VTK + FINALIZE_VTK,WRITE_VTK_SLICE_WRAPPER,BUILD_VTK_GAS_PHASE_GEOMETRY,WRITE_VTK_SM3D_WRAPPER USE F_MKDIR, ONLY : C_MKDIR USE ISO_C_BINDING @@ -112,7 +112,8 @@ SUBROUTINE DUMP_MESH_OUTPUTS(T,DT,NM) ENDIF IF (T>=SM3D_CLOCK(SM3D_COUNTER(NM)) .AND. SMOKE3D) THEN - CALL DUMP_SMOKE3D(T,DT,NM) + CALL C_MKDIR("./results"//char(0)) + CALL DUMP_SMOKE3D(T,DT,NM,0) DO WHILE(SM3D_COUNTER(NM)<SIZE(SM3D_CLOCK)-1) SM3D_COUNTER(NM) = SM3D_COUNTER(NM) + 1 IF (SM3D_CLOCK(SM3D_COUNTER(NM))>=T) EXIT @@ -120,6 +121,7 @@ SUBROUTINE DUMP_MESH_OUTPUTS(T,DT,NM) ENDIF IF (T>=SLCF_CLOCK(SLCF_COUNTER(NM))) THEN + CALL C_MKDIR("./results"//char(0)) CALL DUMP_SLCF(T,DT,NM,0) DO WHILE(SLCF_COUNTER(NM)<SIZE(SLCF_CLOCK)-1) SLCF_COUNTER(NM) = SLCF_COUNTER(NM) + 1 @@ -135,11 +137,27 @@ SUBROUTINE DUMP_MESH_OUTPUTS(T,DT,NM) ENDDO ENDIF -IF (T>=VTK_CLOCK(VTK_COUNTER(NM)) .OR. STOP_STATUS==INSTABILITY_STOP) THEN +! VTK 3-D slices +IF (T>=SL3D_VTK_CLOCK(SL3D_VTK_COUNTER(NM)) .OR. STOP_STATUS==INSTABILITY_STOP) THEN + IF (NM .EQ. 1) THEN + CALL WRITE_VTK_SLICE_WRAPPER(T,NMESHES,'PUnstructuredGrid') + ENDIF CALL DUMP_SLCF(T,DT,NM,3) - DO WHILE(VTK_COUNTER(NM)<SIZE(VTK_CLOCK)-1) - VTK_COUNTER(NM) = VTK_COUNTER(NM) + 1 - IF (VTK_CLOCK(VTK_COUNTER(NM))>=T) EXIT + DO WHILE(SL3D_VTK_COUNTER(NM)<SIZE(SL3D_VTK_CLOCK)-1) + SL3D_VTK_COUNTER(NM) = SL3D_VTK_COUNTER(NM) + 1 + IF (SL3D_VTK_CLOCK(SL3D_VTK_COUNTER(NM))>=T) EXIT + ENDDO +ENDIF + +! VTK Smoke 3D slices +IF (T>=SM3D_VTK_CLOCK(SM3D_VTK_COUNTER(NM)) .OR. STOP_STATUS==INSTABILITY_STOP) THEN + IF (NM .EQ. 1) THEN + CALL WRITE_VTK_SM3D_WRAPPER(T,NMESHES,'PUnstructuredGrid') + ENDIF + CALL DUMP_SMOKE3D(T,DT,NM,1) + DO WHILE(SM3D_VTK_COUNTER(NM)<SIZE(SM3D_VTK_CLOCK)-1) + SM3D_VTK_COUNTER(NM) = SM3D_VTK_COUNTER(NM) + 1 + IF (SM3D_VTK_CLOCK(SM3D_VTK_COUNTER(NM))>=T) EXIT ENDDO ENDIF @@ -340,8 +358,6 @@ SUBROUTINE ASSIGN_FILE_NAMES ALLOCATE(LU_XYZ(NMESHES)) ALLOCATE(FN_PL3D(2*NMESHES)) ALLOCATE(LU_PL3D(2*NMESHES)) -ALLOCATE(FN_VTK(NMESHES)) -ALLOCATE(LU_VTK(NMESHES)) ALLOCATE(FN_ISOF(N_ISOF,NMESHES)) ALLOCATE(LU_ISOF(N_ISOF,NMESHES)) @@ -378,6 +394,12 @@ SUBROUTINE ASSIGN_FILE_NAMES ALLOCATE(FN_RESTART(NMESHES)) ALLOCATE(LU_RESTART(NMESHES)) +! VTK Files +ALLOCATE(FN_SL3D_VTK(NMESHES+1)) +ALLOCATE(LU_SL3D_VTK(NMESHES+1)) +ALLOCATE(FN_SMOKE3D_VTK(NMESHES+1)) +ALLOCATE(LU_SMOKE3D_VTK(NMESHES+1)) + MESH_LOOP: DO NM=1,NMESHES IF (PROCESS(NM)/=MY_RANK) CYCLE MESH_LOOP @@ -490,7 +512,7 @@ SUBROUTINE ASSIGN_FILE_NAMES WRITE(FN_CORE(NM), '(A,A,I0,A)') TRIM(CHID),'_',NM,'.restart' ! VTK Files - LU_VTK(NM) = GET_FILE_NUMBER() ! slice file + LU_SL3D_VTK(NM) = GET_FILE_NUMBER() ! slice file ENDDO MESH_LOOP @@ -4255,21 +4277,29 @@ END SUBROUTINE DUMP_ISOF !> \param T Current simulation time (s) !> \param DT Current time step size (s) !> \param NM Mesh number +!> \param IFRMT SMV (IFRMT=0) or VTK (IFRMT=1) -SUBROUTINE DUMP_SMOKE3D(T,DT,NM) +SUBROUTINE DUMP_SMOKE3D(T,DT,NM,IFRMT) USE ISOSMOKE, ONLY: SMOKE3D_TO_FILE REAL(EB), INTENT(IN) :: T,DT -INTEGER, INTENT(IN) :: NM -INTEGER :: I,J,K,N +INTEGER, INTENT(IN) :: NM,IFRMT +INTEGER :: I,J,K,N,IFACT,JFACT,KFACT,ITM,ITM1 REAL(FB) :: DXX,STIME REAL(EB), POINTER, DIMENSION(:,:,:) :: FF REAL(FB), ALLOCATABLE, DIMENSION(:) :: QQ_PACK -REAL(EB) :: FR_C +REAL(EB) :: FR_C,TT TYPE(SMOKE3D_TYPE), POINTER :: S3 +LOGICAL :: SMV_OUT,VTK_OUT CALL POINT_TO_MESH(NM) +! Swap case +SELECT CASE(IFRMT) + CASE(0) ; SMV_OUT=.TRUE. ; VTK_OUT=.FALSE. + CASE(1) ; SMV_OUT=.FALSE. ; VTK_OUT=.TRUE. +END SELECT + ! Miscellaneous settings DRY = .FALSE. @@ -4323,13 +4353,52 @@ SUBROUTINE DUMP_SMOKE3D(T,DT,NM) ! Pack the data into a 1-D array and send to the routine that writes the file for Smokeview - ALLOCATE(QQ_PACK(IBP1*JBP1*KBP1)) - QQ_PACK = PACK(QQ(0:IBAR,0:JBAR,0:KBAR,1),MASK=.TRUE.) - CALL SMOKE3D_TO_FILE(NM,STIME,DXX,N,QQ_PACK,IBP1,JBP1,KBP1,SMOKE3D_16) + IF (SMV_OUT) THEN + ALLOCATE(QQ_PACK(IBP1*JBP1*KBP1)) + QQ_PACK = PACK(QQ(0:IBAR,0:JBAR,0:KBAR,1),MASK=.TRUE.) + CALL SMOKE3D_TO_FILE(NM,STIME,DXX,N,QQ_PACK,IBP1,JBP1,KBP1,SMOKE3D_16) + ENDIF + IF (VTK_OUT) THEN + TT = T_BEGIN + (T-T_BEGIN)*TIME_SHRINK_FACTOR + ITM = INT(TT) + ITM1 = NINT(ABS(TT-ITM)*100) + IF (ITM1==100) THEN + ITM = ITM+1 + ITM1 = 0 + ENDIF + WRITE(FN_SMOKE3D_VTK(NM),'(A,A,A,I0,A,I8.8,I2.2,A)') "./results/",TRIM(CHID),'_SM3D_',NM,'_',ITM,ITM1,'.vtu' + !WRITE(*,*) "ARRAY SIZES ", IBAR, JBAR, KBAR, IBP1, JBP1, KBP1 + ALLOCATE(QQ_PACK(IBP1*JBP1*KBP1)) + DO I = 0, IBAR + IFACT = I + DO J = 0, JBAR + JFACT = J*(IBAR) + DO K = 0, KBAR + KFACT = K*(JBAR)*(IBAR) + QQ_PACK(1+IFACT+JFACT+KFACT) = QQ(I,J,K,1) + ENDDO + ENDDO + ENDDO + IF (N .EQ. 1) THEN + CALL INITIALIZE_VTK(LU_SMOKE3D_VTK(NM),FN_SMOKE3D_VTK(NM),'UnstructuredGrid') + CALL BUILD_VTK_GAS_PHASE_GEOMETRY(NM, 'UnstructuredGrid', FN_SMOKE3D_VTK(NM), LU_SMOKE3D_VTK(NM)) + ENDIF + IF (VTK_BINARY) THEN + CALL WRITE_VTK_SLICE_DATA(LU_SMOKE3D_VTK(NM), FN_SMOKE3D_VTK(NM),& + QQ_PACK, S3%SMOKEVIEW_LABEL(1:30), 'ascii') + ELSE + CALL WRITE_VTK_SLICE_DATA(LU_SMOKE3D_VTK(NM), FN_SMOKE3D_VTK(NM),& + QQ_PACK, S3%SMOKEVIEW_LABEL(1:30), 'ascii') + ENDIF + ENDIF DEALLOCATE(QQ_PACK) ENDDO DATA_FILE_LOOP +IF (VTK_OUT) THEN + CALL FINALIZE_VTK(LU_SMOKE3D_VTK(NM),FN_SMOKE3D_VTK(NM),'UnstructuredGrid') +ENDIF + END SUBROUTINE DUMP_SMOKE3D @@ -5966,76 +6035,10 @@ SUBROUTINE DUMP_SLCF(T,DT,NM,IFRMT) ITM = ITM+1 ITM1 = 0 ENDIF - WRITE(FN_VTK(NM),'(A,A,A,I0,A,I8.8,I2.2,A)') "./results/",TRIM(CHID),'_',NM,'_',ITM,ITM1,'.vtu' + WRITE(FN_SL3D_VTK(NM),'(A,A,A,I0,A,I8.8,I2.2,A)') "./results/",TRIM(CHID),'_SL3D_',NM,'_',ITM,ITM1,'.vtu' IF (SL%SLICETYPE=='STRUCTURED') THEN ! write out slice file using original slice file format - - I1=SL%I1 - I2=SL%I2 - J1=SL%J1 - J2=SL%J2 - K1=SL%K1 - K2=SL%K2 - NX = I2 + 1 - I1 - NY = J2 + 1 - J1 - NZ = K2 + 1 - K1 - NP = NX*NY*NZ - NC = (NX-1)*(NY-1)*(NZ-1) - - ! Fill point data - ALLOCATE(X_PTS(NP)) - ALLOCATE(Y_PTS(NP)) - ALLOCATE(Z_PTS(NP)) - IFACT = 1 - DO K = 0, NZ-1 - DO J = 0, NY-1 - DO I = 0, NX-1 - X_PTS(IFACT)=MESHES(NM)%X(I) - Y_PTS(IFACT)=MESHES(NM)%Y(J) - Z_PTS(IFACT)=MESHES(NM)%Z(K) - IFACT = IFACT + 1 - ENDDO - ENDDO - ENDDO - - ! Fill cell data - ALLOCATE(CONNECT(NC*8)) - DO I = 1, NX-1 - IFACT = (I-1) - DO J = 1, NY-1 - JFACT = (J-1)*(NX-1) - DO K = 1, NZ-1 - KFACT = (K - 1)*(NY-1)*(NX-1) - CONNECT((IFACT+JFACT+KFACT)*8+1) = (K-1)*(NY*NX) + (J-1)*NX + I-1 - CONNECT((IFACT+JFACT+KFACT)*8+2) = (K-1)*(NY*NX) + (J-1)*NX + I - CONNECT((IFACT+JFACT+KFACT)*8+3) = (K-1)*(NY*NX) + (J)*NX + I-1 - CONNECT((IFACT+JFACT+KFACT)*8+4) = (K-1)*(NY*NX) + (J)*NX + I - CONNECT((IFACT+JFACT+KFACT)*8+5) = (K)*(NY*NX) + (J-1)*NX + I-1 - CONNECT((IFACT+JFACT+KFACT)*8+6) = (K)*(NY*NX) + (J-1)*NX + I - CONNECT((IFACT+JFACT+KFACT)*8+7) = (K)*(NY*NX) + (J)*NX + I-1 - CONNECT((IFACT+JFACT+KFACT)*8+8) = (K)*(NY*NX) + (J)*NX + I - ENDDO - ENDDO - ENDDO - - ALLOCATE(OFFSETS(NC)) - ALLOCATE(CELL_TYPE(NC)) - - DO I=1,NC - OFFSETS(I) = (I)*8_IB4 - CELL_TYPE(I) = 11_IB4 - ENDDO - - CALL C_MKDIR("./results"//char(0)) - CALL INITIALIZE_VTK(NM,'UnstructuredGrid') - CALL WRITE_VTK_SLICE_GEOMETRY(NM, NP, NC, X_PTS, Y_PTS, Z_PTS, 'ascii') - CALL WRITE_VTK_SLICE_CELLS(NM, CONNECT, OFFSETS, CELL_TYPE, 'ascii') - - DEALLOCATE(OFFSETS) - DEALLOCATE(CELL_TYPE) - DEALLOCATE(CONNECT) - DEALLOCATE(X_PTS) - DEALLOCATE(Y_PTS) - DEALLOCATE(Z_PTS) + CALL INITIALIZE_VTK(LU_SL3D_VTK(NM),FN_SL3D_VTK(NM),'UnstructuredGrid') + CALL BUILD_VTK_GAS_PHASE_GEOMETRY(NM, 'UnstructuredGrid', FN_SL3D_VTK(NM), LU_SL3D_VTK(NM)) ENDIF VTK_INITIALIZED=.TRUE. ENDIF @@ -6329,7 +6332,13 @@ SUBROUTINE DUMP_SLCF(T,DT,NM,IFRMT) ENDDO ENDDO - CALL WRITE_VTK_SLICE_DATA(NM, QQ_PACK, SL%SMOKEVIEW_LABEL(1:30), 'ascii') + IF (VTK_BINARY) THEN + CALL WRITE_VTK_SLICE_DATA(LU_SL3D_VTK(NM), FN_SL3D_VTK(NM),& + QQ_PACK, SL%SMOKEVIEW_LABEL(1:30), 'ascii') + ELSE + CALL WRITE_VTK_SLICE_DATA(LU_SL3D_VTK(NM), FN_SL3D_VTK(NM),& + QQ_PACK, SL%SMOKEVIEW_LABEL(1:30), 'ascii') + ENDIF DEALLOCATE(QQ_PACK) ENDIF @@ -6340,7 +6349,7 @@ SUBROUTINE DUMP_SLCF(T,DT,NM,IFRMT) IF (VTK3D) THEN ! finish after writing all pieces - CALL FINALIZE_VTK(NM,'UnstructuredGrid') + CALL FINALIZE_VTK(LU_SL3D_VTK(NM),FN_SL3D_VTK(NM),'UnstructuredGrid') ENDIF ! Write out the PLOT3D ``q'' file diff --git a/Source/func.f90 b/Source/func.f90 index bd92f564667..4e05f7605a0 100644 --- a/Source/func.f90 +++ b/Source/func.f90 @@ -481,7 +481,8 @@ SUBROUTINE INITIALIZE_OUTPUT_CLOCKS(T) CALL SET_OUTPUT_CLOCK(DT_UVW ,RAMP_UVW_INDEX , UVW_CLOCK, UVW_COUNTER,.TRUE. ,.TRUE. ) CALL SET_OUTPUT_CLOCK(DT_TMP ,RAMP_TMP_INDEX , TMP_CLOCK, TMP_COUNTER,.TRUE. ,.TRUE. ) CALL SET_OUTPUT_CLOCK(DT_SPEC ,RAMP_SPEC_INDEX,SPEC_CLOCK,SPEC_COUNTER,.TRUE. ,.TRUE. ) -CALL SET_OUTPUT_CLOCK(DT_VTK ,RAMP_VTK_INDEX, VTK_CLOCK, VTK_COUNTER,.TRUE. ,.TRUE. ) +CALL SET_OUTPUT_CLOCK(DT_VTK ,RAMP_SL3D_VTK_INDEX, SL3D_VTK_CLOCK, SL3D_VTK_COUNTER,.TRUE. ,.TRUE. ) +CALL SET_OUTPUT_CLOCK(DT_VTK ,RAMP_SM3D_VTK_INDEX, SM3D_VTK_CLOCK, SM3D_VTK_COUNTER,.TRUE. ,.TRUE. ) ! Special cases diff --git a/Source/vtk.f90 b/Source/vtk.f90 index 59fe3780ee6..3af31662e85 100644 --- a/Source/vtk.f90 +++ b/Source/vtk.f90 @@ -4,160 +4,504 @@ MODULE VTK USE MESH_VARIABLES USE GLOBAL_CONSTANTS +USE MESH_POINTERS +USE OUTPUT_DATA IMPLICIT NONE (TYPE,EXTERNAL) PRIVATE -PUBLIC INITIALIZE_VTK,WRITE_VTK_SLICE_GEOMETRY,WRITE_VTK_SLICE_CELLS,WRITE_VTK_SLICE_DATA,FINALIZE_VTK +PUBLIC INITIALIZE_VTK,WRITE_VTK_SLICE_GEOMETRY,WRITE_VTK_SLICE_CELLS,WRITE_VTK_SLICE_DATA,FINALIZE_VTK,& + WRITE_VTK_SLICE_WRAPPER,BUILD_VTK_GAS_PHASE_GEOMETRY,WRITE_VTK_SM3D_WRAPPER CONTAINS -SUBROUTINE INITIALIZE_VTK(NM,MESH_TOPOLOGY) +SUBROUTINE INITIALIZE_VTK(LU,FN,MESH_TOPOLOGY) -INTEGER, INTENT(IN) :: NM -CHARACTER(LEN=*), INTENT(IN) :: MESH_TOPOLOGY -OPEN(LU_VTK(NM),FILE=FN_VTK(NM),FORM='FORMATTED') -WRITE(LU_VTK(NM),'(A)',ADVANCE='YES') '<?xml version="1.0"?>' -WRITE(LU_VTK(NM),'(A,A,A)',ADVANCE='YES') '<VTKFile type="',TRIM(MESH_TOPOLOGY),'" version="1.0" byte_order="LittleEndian">' -WRITE(LU_VTK(NM),'(A,A,A)',ADVANCE='YES') ' <',TRIM(MESH_TOPOLOGY),'>' -CLOSE(LU_VTK(NM)) +INTEGER, INTENT(IN) :: LU +CHARACTER(LEN=*), INTENT(IN) :: MESH_TOPOLOGY,FN +OPEN(LU,FILE=FN,FORM='FORMATTED') +WRITE(LU,'(A)',ADVANCE='YES') '<?xml version="1.0"?>' +WRITE(LU,'(A,A,A)',ADVANCE='YES') '<VTKFile type="',TRIM(MESH_TOPOLOGY),'" version="1.0" byte_order="LittleEndian">' +WRITE(LU,'(A,A,A)',ADVANCE='YES') ' <',TRIM(MESH_TOPOLOGY),'>' +CLOSE(LU) END SUBROUTINE INITIALIZE_VTK -SUBROUTINE WRITE_VTK_SLICE_GEOMETRY(NM, NP, NC, X_PTS, Y_PTS, Z_PTS, FORMAT) +SUBROUTINE WRITE_VTK_SLICE_GEOMETRY(LU, FN, NP, NC, X_PTS, Y_PTS, Z_PTS, FORMAT) -INTEGER, INTENT(IN) :: NM, NC, NP +INTEGER, INTENT(IN) :: LU, NC, NP REAL(FB), DIMENSION(:), INTENT(IN) :: X_PTS, Y_PTS, Z_PTS -CHARACTER(LEN=*), INTENT(IN) :: FORMAT +CHARACTER(LEN=*), INTENT(IN) :: FN, FORMAT INTEGER :: I -OPEN(LU_VTK(NM),FILE=FN_VTK(NM),FORM='FORMATTED',STATUS='OLD',POSITION='APPEND') -WRITE(LU_VTK(NM),'(A,I0,A,I0,A)',ADVANCE='YES') ' <Piece NumberOfPoints="',NP,'" NumberOfCells="',NC,'">' -WRITE(LU_VTK(NM),'(A)',ADVANCE='YES') ' <Points>' -WRITE(LU_VTK(NM),'(A,A,A)',ADVANCE='YES') & +OPEN(LU,FILE=FN,FORM='FORMATTED',STATUS='OLD',POSITION='APPEND') +WRITE(LU,'(A,I0,A,I0,A)',ADVANCE='YES') ' <Piece NumberOfPoints="',NP,'" NumberOfCells="',NC,'">' +WRITE(LU,'(A)',ADVANCE='YES') ' <Points>' +WRITE(LU,'(A,A,A)',ADVANCE='YES') & ' <DataArray type="Float32" NumberOfComponents="3" Name="Points" format="',FORMAT,'">' -WRITE(LU_VTK(NM),'(A)',ADVANCE='NO') ' ' +WRITE(LU,'(A)',ADVANCE='NO') ' ' IF (TRIM(ADJUSTL(FORMAT)) .eq. 'ascii') THEN DO I=1,NP - WRITE(LU_VTK(NM),'(E15.8,A,E15.8,A,E15.8,A)',ADVANCE='NO') X_PTS(I),' ',Y_PTS(I),' ',Z_PTS(I),' ' + WRITE(LU,'(E15.8,A,E15.8,A,E15.8,A)',ADVANCE='NO') X_PTS(I),' ',Y_PTS(I),' ',Z_PTS(I),' ' ENDDO ENDIF -WRITE(LU_VTK(NM),'(A)',ADVANCE='YES') ' ' -WRITE(LU_VTK(NM),'(A)',ADVANCE='YES') ' </DataArray>' -WRITE(LU_VTK(NM),'(A)',ADVANCE='YES') ' </Points>' -CLOSE(LU_VTK(NM)) +WRITE(LU,'(A)',ADVANCE='YES') ' ' +WRITE(LU,'(A)',ADVANCE='YES') ' </DataArray>' +WRITE(LU,'(A)',ADVANCE='YES') ' </Points>' +CLOSE(LU) END SUBROUTINE WRITE_VTK_SLICE_GEOMETRY -SUBROUTINE WRITE_VTK_SLICE_CELLS(NM, CONNECT, OFFSETS, CELL_TYPE, FORMAT) +SUBROUTINE WRITE_VTK_SLICE_CELLS(LU, FN, CONNECT, OFFSETS, CELL_TYPE, FORMAT) -INTEGER, INTENT(IN) :: NM +INTEGER, INTENT(IN) :: LU INTEGER, DIMENSION(:), INTENT(IN) :: CONNECT, OFFSETS INTEGER(IB4), DIMENSION(:), INTENT(IN) :: CELL_TYPE -CHARACTER(LEN=*), INTENT(IN) :: FORMAT +CHARACTER(LEN=*), INTENT(IN) :: FN, FORMAT INTEGER :: I ! Open cells section -OPEN(LU_VTK(NM),FILE=FN_VTK(NM),FORM='FORMATTED',STATUS='OLD',POSITION='APPEND') -WRITE(LU_VTK(NM),'(A)',ADVANCE='YES') ' <Cells>' +OPEN(LU,FILE=FN,FORM='FORMATTED',STATUS='OLD',POSITION='APPEND') +WRITE(LU,'(A)',ADVANCE='YES') ' <Cells>' ! Write connectivity -WRITE(LU_VTK(NM),'(A,A,A)',ADVANCE='YES') & +WRITE(LU,'(A,A,A)',ADVANCE='YES') & ' <DataArray type="Int32" NumberOfComponents="1" Name="connectivity" format="',FORMAT,'">' -WRITE(LU_VTK(NM),'(A)',ADVANCE='NO') ' ' -IF (TRIM(ADJUSTL(FORMAT)) .eq. 'ascii') THEN +WRITE(LU,'(A)',ADVANCE='NO') ' ' +IF (TRIM(ADJUSTL(FORMAT)) .EQ. 'ascii') THEN DO I=1,SIZE(CONNECT) - WRITE(LU_VTK(NM),'(I0,A)',ADVANCE='NO') CONNECT(I), ' ' + WRITE(LU,'(I0,A)',ADVANCE='NO') CONNECT(I), ' ' ENDDO ENDIF -WRITE(LU_VTK(NM),'(A)',ADVANCE='YES') ' ' -WRITE(LU_VTK(NM),'(A)',ADVANCE='YES') ' </DataArray>' +WRITE(LU,'(A)',ADVANCE='YES') ' ' +WRITE(LU,'(A)',ADVANCE='YES') ' </DataArray>' ! Write offsets -WRITE(LU_VTK(NM),'(A,A,A)',ADVANCE='YES') & +WRITE(LU,'(A,A,A)',ADVANCE='YES') & ' <DataArray type="Int32" NumberOfComponents="1" Name="offsets" format="',FORMAT,'">' -WRITE(LU_VTK(NM),'(A)',ADVANCE='NO') ' ' -IF (TRIM(ADJUSTL(FORMAT)) .eq. 'ascii') THEN +WRITE(LU,'(A)',ADVANCE='NO') ' ' +IF (TRIM(ADJUSTL(FORMAT)) .EQ. 'ascii') THEN DO I=1,SIZE(OFFSETS) - WRITE(LU_VTK(NM),'(I0,A)',ADVANCE='NO') OFFSETS(I), ' ' + WRITE(LU,'(I0,A)',ADVANCE='NO') OFFSETS(I), ' ' ENDDO ENDIF -WRITE(LU_VTK(NM),'(A)',ADVANCE='YES') ' ' -WRITE(LU_VTK(NM),'(A)',ADVANCE='YES') ' </DataArray>' +WRITE(LU,'(A)',ADVANCE='YES') ' ' +WRITE(LU,'(A)',ADVANCE='YES') ' </DataArray>' ! Write cell types -WRITE(LU_VTK(NM),'(A,A,A)',ADVANCE='YES') & +WRITE(LU,'(A,A,A)',ADVANCE='YES') & ' <DataArray type="Int8" NumberOfComponents="1" Name="types" format="',FORMAT,'">' -WRITE(LU_VTK(NM),'(A)',ADVANCE='NO') ' ' -IF (TRIM(ADJUSTL(FORMAT)) .eq. 'ascii') THEN +WRITE(LU,'(A)',ADVANCE='NO') ' ' +IF (TRIM(ADJUSTL(FORMAT)) .EQ. 'ascii') THEN DO I=1,SIZE(CELL_TYPE) - WRITE(LU_VTK(NM),'(I0,A)',ADVANCE='NO') CELL_TYPE(I), ' ' + WRITE(LU,'(I0,A)',ADVANCE='NO') CELL_TYPE(I), ' ' ENDDO ENDIF -WRITE(LU_VTK(NM),'(A)',ADVANCE='YES') ' ' -WRITE(LU_VTK(NM),'(A)',ADVANCE='YES') ' </DataArray>' +WRITE(LU,'(A)',ADVANCE='YES') ' ' +WRITE(LU,'(A)',ADVANCE='YES') ' </DataArray>' ! Close cell section -WRITE(LU_VTK(NM),'(A)',ADVANCE='YES') ' </Cells>' +WRITE(LU,'(A)',ADVANCE='YES') ' </Cells>' ! Open point data section -WRITE(LU_VTK(NM),'(A)',ADVANCE='YES') ' <PointData>' +WRITE(LU,'(A)',ADVANCE='YES') ' <PointData>' -CLOSE(LU_VTK(NM)) +CLOSE(LU) END SUBROUTINE WRITE_VTK_SLICE_CELLS -SUBROUTINE WRITE_VTK_SLICE_DATA(NM, DATA, DATA_NAME, FORMAT) +SUBROUTINE WRITE_VTK_SLICE_DATA(LU, FN, DATA, DATA_NAME, FORMAT) -INTEGER, INTENT(IN) :: NM -CHARACTER(LEN=*), INTENT(IN) :: FORMAT, DATA_NAME +INTEGER, INTENT(IN) :: LU +CHARACTER(LEN=*), INTENT(IN) :: FORMAT, DATA_NAME, FN CHARACTER(LEN=:), ALLOCATABLE :: CODE REAL(FB), DIMENSION(:) :: DATA -INTEGER :: I +INTEGER :: I, NBITS_DATA, NSTRINGS_DATA +CHARACTER(LEN=:), ALLOCATABLE :: BIT_DATA + +!real(R16P), intent(in) :: n !< Number to be encoded. +integer(I1P), allocatable :: nI1P(:) !< One byte integer array containing n. +integer(I4P) :: padd !< Number of padding characters ('='). + +integer(I4P) :: BYR16P = 2_I1P + + + ! Open data section -OPEN(LU_VTK(NM),FILE=FN_VTK(NM),FORM='FORMATTED',STATUS='OLD',POSITION='APPEND') +OPEN(LU,FILE=FN,FORM='FORMATTED',STATUS='OLD',POSITION='APPEND') ! Write data -WRITE(LU_VTK(NM),'(A,A,A,A,A)',ADVANCE='YES') & +WRITE(LU,'(A,A,A,A,A)',ADVANCE='YES') & ' <DataArray type="Float32" NumberOfComponents="1" Name="',& TRIM(DATA_NAME),'" format="',FORMAT,'">' -WRITE(LU_VTK(NM),'(A)',ADVANCE='NO') ' ' +WRITE(LU,'(A)',ADVANCE='NO') ' ' IF (TRIM(ADJUSTL(FORMAT)) .EQ. 'ascii') THEN DO I=1,SIZE(DATA) - WRITE(LU_VTK(NM),'(E15.8,A)',ADVANCE='NO') DATA(I), ' ' + WRITE(LU,'(E15.8,A)',ADVANCE='NO') DATA(I), ' ' ENDDO ELSEIF (TRIM(ADJUSTL(FORMAT)) .EQ. 'binary') THEN + CLOSE(LU) + OPEN(LU,FILE=FN,FORM='UNFORMATTED',STATUS='OLD',POSITION='APPEND') + !NBITS_DATA = SIZE(DATA) * SIZEOF(FB)*2 + !NSTRINGS_DATA = INT(FLOAT(NBITS_DATA)/3+0.9) + + allocate(nI1P(1:((BYR16P+2)/3)*3)) ; nI1P = 0_I1P + code = repeat(' ',((BYR16P+2)/3)*4) + nI1P = transfer(DATA,nI1P) + padd = mod((BYR16P),3) ; if (padd>0_I4P) padd = 3_I4P - padd + + + + CALL ENCODE_BITS(BITS=NI1P,PADD=PADD,CODE=CODE) + + WRITE(*,*) "SIZES", SIZE(DATA), NBITS_DATA + WRITE(*,*) PADD + WRITE(*,*) CODE + !ALLOCATE(CHARACTER(LEN=NBITS_DATA) :: BIT_DATA) + !WRITE(BIT_DATA,'(B64)') DATA + !WRITE(*,*) BIT_DATA + !DEALLOCATE(BIT_DATA) + !DO I=0,NSTRINGS_DATA + ! STRINGBITS = DATA(I*6:(I+1)*6) + ! WRITE(*,*), "DATA ", I, " ", STRINGBITS + !ENDDO + !WRITE(LU_SL3D_VTK(NM)) NBITS_DATA , (DATA(I),I=1,SIZE(DATA)) + CLOSE(LU) + OPEN(LU,FILE=FN,FORM='FORMATTED',STATUS='OLD',POSITION='APPEND') + !CODE=ENCODE_ASCII_DATAARRAY1_RANK1_FB(DATA) + !WRITE(LU_SL3D_VTK(NM)) CODE +ELSEIF (TRIM(ADJUSTL(FORMAT)) .EQ. 'appended') THEN + CLOSE(LU) + OPEN(LU,FILE=FN,FORM='UNFORMATTED',STATUS='OLD',POSITION='APPEND') + NBITS_DATA = SIZE(DATA) * SIZEOF(FB) + WRITE(LU) NBITS_DATA , (DATA(I),I=1,SIZE(DATA)) + CLOSE(LU) + OPEN(LU,FILE=FN,FORM='FORMATTED',STATUS='OLD',POSITION='APPEND') !CODE=ENCODE_ASCII_DATAARRAY1_RANK1_FB(DATA) - !WRITE(LU_VTK(NM)) CODE + !WRITE(LU_SL3D_VTK(NM)) CODE ENDIF -WRITE(LU_VTK(NM),'(A)',ADVANCE='YES') ' ' +WRITE(LU,'(A)',ADVANCE='YES') ' ' ! Close data section -WRITE(LU_VTK(NM),'(A)',ADVANCE='YES') ' </DataArray>' -CLOSE(LU_VTK(NM)) +WRITE(LU,'(A)',ADVANCE='YES') ' </DataArray>' +CLOSE(LU) END SUBROUTINE WRITE_VTK_SLICE_DATA -SUBROUTINE FINALIZE_VTK(NM,MESH_TOPOLOGY) +SUBROUTINE FINALIZE_VTK(LU,FN,MESH_TOPOLOGY) -INTEGER, INTENT(IN) :: NM -CHARACTER(LEN=*), INTENT(IN) :: MESH_TOPOLOGY +INTEGER, INTENT(IN) :: LU +CHARACTER(LEN=*), INTENT(IN) :: MESH_TOPOLOGY,FN ! Close VTK file -OPEN(LU_VTK(NM),FILE=FN_VTK(NM),FORM='FORMATTED',STATUS='OLD',POSITION='APPEND') -WRITE(LU_VTK(NM),'(A)',ADVANCE='YES') ' </PointData>' -WRITE(LU_VTK(NM),'(A)',ADVANCE='YES') ' </Piece>' -WRITE(LU_VTK(NM),'(A,A,A)',ADVANCE='YES') ' </',TRIM(MESH_TOPOLOGY),'>' -WRITE(LU_VTK(NM),'(A)',ADVANCE='YES') '</VTKFile>' +OPEN(LU,FILE=FN,FORM='FORMATTED',STATUS='OLD',POSITION='APPEND') +WRITE(LU,'(A)',ADVANCE='YES') ' </PointData>' +WRITE(LU,'(A)',ADVANCE='YES') ' </Piece>' +WRITE(LU,'(A,A,A)',ADVANCE='YES') ' </',TRIM(MESH_TOPOLOGY),'>' +WRITE(LU,'(A)',ADVANCE='YES') '</VTKFile>' -CLOSE(LU_VTK(NM)) +CLOSE(LU) END SUBROUTINE FINALIZE_VTK +SUBROUTINE WRITE_VTK_SLICE_WRAPPER(T,NMESHES,MESH_TOPOLOGY) +INTEGER, INTENT(IN) :: NMESHES +CHARACTER(LEN=*), INTENT(IN) :: MESH_TOPOLOGY +REAL(EB), INTENT(IN) :: T +TYPE (SLICE_TYPE), POINTER :: SL +INTEGER :: I,NQT,I1,I2,J1,J2,K1,K2,IQ,ITM,ITM1 +REAL(FB) :: STIME +REAL(EB) :: TT +CHARACTER(200) :: TMP_FILE + +! Generate filename +STIME = REAL(T_BEGIN + (T-T_BEGIN)*TIME_SHRINK_FACTOR,FB) +TT = T_BEGIN + (T-T_BEGIN)*TIME_SHRINK_FACTOR +ITM = INT(TT) +ITM1 = NINT(ABS(TT-ITM)*100) +IF (ITM1==100) THEN + ITM = ITM+1 + ITM1 = 0 +ENDIF +WRITE(FN_SL3D_VTK(NMESHES+1),'(A,A,A,I8.8,I2.2,A)') "./results/",TRIM(CHID),'_SL3D_',ITM,ITM1,'.pvtu' + +! First part of header before quantities +OPEN(LU_SL3D_VTK(NMESHES+1),FILE=FN_SL3D_VTK(NMESHES+1),FORM='FORMATTED') +WRITE(LU_SL3D_VTK(NMESHES+1),'(A)',ADVANCE='YES') '<?xml version="1.0"?>' +WRITE(LU_SL3D_VTK(NMESHES+1),'(A,A,A)',ADVANCE='YES') & + '<VTKFile type="',TRIM(MESH_TOPOLOGY),'" version="1.0" byte_order="LittleEndian">' +WRITE(LU_SL3D_VTK(NMESHES+1),'(A,A,A)',ADVANCE='YES') ' <',TRIM(MESH_TOPOLOGY),' GhostLevel="0">' +WRITE(LU_SL3D_VTK(NMESHES+1),'(A)',ADVANCE='YES') ' <PPointData>' + +! Add PointData arrays +NQT = MESHES(1)%N_SLCF +QUANTITY_LOOP2: DO IQ=1,NQT + SL => SLICE(IQ) + I1 = SL%I1 + I2 = SL%I2 + J1 = SL%J1 + J2 = SL%J2 + K1 = SL%K1 + K2 = SL%K2 + IF (I2-I1==0 .OR. J2-J1==0 .OR. K2-K1==0) CYCLE QUANTITY_LOOP2 + WRITE(LU_SL3D_VTK(NMESHES+1),'(A)',ADVANCE='NO') ' <PDataArray type="Float32" NumberOfComponents="1" Name=' + WRITE(LU_SL3D_VTK(NMESHES+1),'(A,A,A)',ADVANCE='NO') '"',TRIM(SL%SMOKEVIEW_LABEL(1:30)),'" format=' + IF (VTK_BINARY) THEN + WRITE(LU_SL3D_VTK(NMESHES+1),'(A)',ADVANCE='YES') '"binary"/>' + ELSE + WRITE(LU_SL3D_VTK(NMESHES+1),'(A)',ADVANCE='YES') '"ascii"/>' + ENDIF +ENDDO QUANTITY_LOOP2 + +! Close PointData +WRITE(LU_SL3D_VTK(NMESHES+1),'(A)',ADVANCE='YES') ' </PPointData>' + +! Add Point arrays +WRITE(LU_SL3D_VTK(NMESHES+1),'(A)',ADVANCE='YES') ' <PPoints>' +WRITE(LU_SL3D_VTK(NMESHES+1),'(A)',ADVANCE='NO') ' <PDataArray type="Float32" NumberOfComponents="3" Name="Points" format=' +IF (VTK_BINARY) THEN + WRITE(LU_SL3D_VTK(NMESHES+1),'(A)',ADVANCE='YES') '"binary"/>' +ELSE + WRITE(LU_SL3D_VTK(NMESHES+1),'(A)',ADVANCE='YES') '"ascii"/>' +ENDIF +WRITE(LU_SL3D_VTK(NMESHES+1),'(A)',ADVANCE='YES') ' </PPoints>' + +! Add CellData +WRITE(LU_SL3D_VTK(NMESHES+1),'(A)',ADVANCE='YES') ' <PCellData></PCellData>' + +! Write pieces +DO I=1,NMESHES + WRITE(TMP_FILE,'(A,A,I0,A,I8.8,I2.2,A)') TRIM(CHID),'_SL3D_',I,'_',ITM,ITM1,'.vtu' + WRITE(LU_SL3D_VTK(NMESHES+1),'(A,A,A)',ADVANCE='YES') ' <Piece Source="',TRIM(TMP_FILE),'"/>' +ENDDO + +! Finalize file +WRITE(LU_SL3D_VTK(NMESHES+1),'(A,A,A)',ADVANCE='YES') ' </',TRIM(MESH_TOPOLOGY),'>' +WRITE(LU_SL3D_VTK(NMESHES+1),'(A)',ADVANCE='YES') '</VTKFile>' +CLOSE(LU_SL3D_VTK(NMESHES+1)) +END SUBROUTINE WRITE_VTK_SLICE_WRAPPER + + + + + + + + + + + + + + + + + +SUBROUTINE WRITE_VTK_SM3D_WRAPPER(T,NMESHES,MESH_TOPOLOGY) +INTEGER, INTENT(IN) :: NMESHES +CHARACTER(LEN=*), INTENT(IN) :: MESH_TOPOLOGY +REAL(EB), INTENT(IN) :: T +TYPE (SLICE_TYPE), POINTER :: SL +INTEGER :: I,NQT,I1,I2,J1,J2,K1,K2,IQ,ITM,ITM1,N +REAL(FB) :: STIME +REAL(EB) :: TT +CHARACTER(200) :: TMP_FILE +TYPE(SMOKE3D_TYPE), POINTER :: S3 + +! Generate filename +STIME = REAL(T_BEGIN + (T-T_BEGIN)*TIME_SHRINK_FACTOR,FB) +TT = T_BEGIN + (T-T_BEGIN)*TIME_SHRINK_FACTOR +ITM = INT(TT) +ITM1 = NINT(ABS(TT-ITM)*100) +IF (ITM1==100) THEN + ITM = ITM+1 + ITM1 = 0 +ENDIF +WRITE(FN_SMOKE3D_VTK(NMESHES+1),'(A,A,A,A,A,I8.8,I2.2,A)') "./results/",TRIM(CHID),'_','SM3D','_',ITM,ITM1,'.pvtu' + +! First part of header before quantities +OPEN(LU_SMOKE3D_VTK(NMESHES+1),FILE=FN_SMOKE3D_VTK(NMESHES+1),FORM='FORMATTED') +WRITE(LU_SMOKE3D_VTK(NMESHES+1),'(A)',ADVANCE='YES') '<?xml version="1.0"?>' +WRITE(LU_SMOKE3D_VTK(NMESHES+1),'(A,A,A)',ADVANCE='YES') & + '<VTKFile type="',TRIM(MESH_TOPOLOGY),'" version="1.0" byte_order="LittleEndian">' +WRITE(LU_SMOKE3D_VTK(NMESHES+1),'(A,A,A)',ADVANCE='YES') ' <',TRIM(MESH_TOPOLOGY),' GhostLevel="0">' +WRITE(LU_SMOKE3D_VTK(NMESHES+1),'(A)',ADVANCE='YES') ' <PPointData>' + +! Add PointData arrays +DATA_FILE_LOOP2: DO N=1,N_SMOKE3D + + S3 => SMOKE3D_FILE(N) + WRITE(*,*) "SMOKE3D QUANTITY", S3%SMOKEVIEW_LABEL(1:30) + WRITE(LU_SMOKE3D_VTK(NMESHES+1),'(A)',ADVANCE='NO') ' <PDataArray type="Float32" NumberOfComponents="1" Name=' + WRITE(LU_SMOKE3D_VTK(NMESHES+1),'(A,A,A)',ADVANCE='NO') '"',TRIM(S3%SMOKEVIEW_LABEL(1:30)),'" format=' + IF (VTK_BINARY) THEN + WRITE(LU_SMOKE3D_VTK(NMESHES+1),'(A)',ADVANCE='YES') '"binary"/>' + ELSE + WRITE(LU_SMOKE3D_VTK(NMESHES+1),'(A)',ADVANCE='YES') '"ascii"/>' + ENDIF +ENDDO DATA_FILE_LOOP2 + +! Close PointData +WRITE(LU_SMOKE3D_VTK(NMESHES+1),'(A)',ADVANCE='YES') ' </PPointData>' + +! Add Point arrays +WRITE(LU_SMOKE3D_VTK(NMESHES+1),'(A)',ADVANCE='YES') ' <PPoints>' +WRITE(LU_SMOKE3D_VTK(NMESHES+1),'(A)',ADVANCE='NO') ' <PDataArray type="Float32" NumberOfComponents="3" Name="Points" format=' +IF (VTK_BINARY) THEN + WRITE(LU_SMOKE3D_VTK(NMESHES+1),'(A)',ADVANCE='YES') '"binary"/>' +ELSE + WRITE(LU_SMOKE3D_VTK(NMESHES+1),'(A)',ADVANCE='YES') '"ascii"/>' +ENDIF +WRITE(LU_SMOKE3D_VTK(NMESHES+1),'(A)',ADVANCE='YES') ' </PPoints>' + +! Add CellData +WRITE(LU_SMOKE3D_VTK(NMESHES+1),'(A)',ADVANCE='YES') ' <PCellData></PCellData>' + +! Write pieces +DO I=1,NMESHES + WRITE(TMP_FILE,'(A,A,I0,A,I8.8,I2.2,A)') TRIM(CHID),'_SM3D_',I,'_',ITM,ITM1,'.vtu' + WRITE(LU_SMOKE3D_VTK(NMESHES+1),'(A,A,A)',ADVANCE='YES') ' <Piece Source="',TRIM(TMP_FILE),'"/>' +ENDDO + +! Finalize file +WRITE(LU_SMOKE3D_VTK(NMESHES+1),'(A,A,A)',ADVANCE='YES') ' </',TRIM(MESH_TOPOLOGY),'>' +WRITE(LU_SMOKE3D_VTK(NMESHES+1),'(A)',ADVANCE='YES') '</VTKFile>' +CLOSE(LU_SMOKE3D_VTK(NMESHES+1)) +END SUBROUTINE WRITE_VTK_SM3D_WRAPPER + + + +SUBROUTINE BUILD_VTK_GAS_PHASE_GEOMETRY(NM, MESH_TOPOLOGY, FN, LU) + +INTEGER :: NX, NY, NZ, NC, NP, I, J, K, IFACT, JFACT, KFACT +REAL(FB), ALLOCATABLE, DIMENSION(:) :: QQ_PACK, X_PTS, Y_PTS, Z_PTS +INTEGER, ALLOCATABLE, DIMENSION(:) :: CONNECT, OFFSETS +INTEGER(IB4), ALLOCATABLE, DIMENSION(:) :: CELL_TYPE +CHARACTER(LEN=*), INTENT(IN) :: MESH_TOPOLOGY, FN +INTEGER, INTENT(IN) :: NM, LU + +NX = SIZE(MESHES(NM)%X) +NY = SIZE(MESHES(NM)%Y) +NZ = SIZE(MESHES(NM)%Z) + +NP = NX*NY*NZ +NC = (NX-1)*(NY-1)*(NZ-1) + +! Fill point data +ALLOCATE(X_PTS(NP)) +ALLOCATE(Y_PTS(NP)) +ALLOCATE(Z_PTS(NP)) +IFACT = 1 +DO K = 0, NZ-1 + DO J = 0, NY-1 + DO I = 0, NX-1 + X_PTS(IFACT)=MESHES(NM)%X(I) + Y_PTS(IFACT)=MESHES(NM)%Y(J) + Z_PTS(IFACT)=MESHES(NM)%Z(K) + IFACT = IFACT + 1 + ENDDO + ENDDO +ENDDO + +! Fill cell data +ALLOCATE(CONNECT(NC*8)) +DO I = 1, NX-1 + IFACT = (I-1) + DO J = 1, NY-1 + JFACT = (J-1)*(NX-1) + DO K = 1, NZ-1 + KFACT = (K - 1)*(NY-1)*(NX-1) + CONNECT((IFACT+JFACT+KFACT)*8+1) = (K-1)*(NY*NX) + (J-1)*NX + I-1 + CONNECT((IFACT+JFACT+KFACT)*8+2) = (K-1)*(NY*NX) + (J-1)*NX + I + CONNECT((IFACT+JFACT+KFACT)*8+3) = (K-1)*(NY*NX) + (J)*NX + I-1 + CONNECT((IFACT+JFACT+KFACT)*8+4) = (K-1)*(NY*NX) + (J)*NX + I + CONNECT((IFACT+JFACT+KFACT)*8+5) = (K)*(NY*NX) + (J-1)*NX + I-1 + CONNECT((IFACT+JFACT+KFACT)*8+6) = (K)*(NY*NX) + (J-1)*NX + I + CONNECT((IFACT+JFACT+KFACT)*8+7) = (K)*(NY*NX) + (J)*NX + I-1 + CONNECT((IFACT+JFACT+KFACT)*8+8) = (K)*(NY*NX) + (J)*NX + I + ENDDO + ENDDO +ENDDO + +ALLOCATE(OFFSETS(NC)) +ALLOCATE(CELL_TYPE(NC)) + +DO I=1,NC + OFFSETS(I) = (I)*8_IB4 + CELL_TYPE(I) = 11_IB4 +ENDDO + +IF (VTK_BINARY) THEN + CALL WRITE_VTK_SLICE_GEOMETRY(LU,FN,NP,NC,X_PTS,Y_PTS,Z_PTS,'ascii') + CALL WRITE_VTK_SLICE_CELLS(LU,FN,CONNECT,OFFSETS,CELL_TYPE,'ascii') +ELSE + CALL WRITE_VTK_SLICE_GEOMETRY(LU,FN,NP,NC,X_PTS,Y_PTS,Z_PTS,'ascii') + CALL WRITE_VTK_SLICE_CELLS(LU,FN,CONNECT,OFFSETS,CELL_TYPE,'ascii') +ENDIF + +DEALLOCATE(OFFSETS) +DEALLOCATE(CELL_TYPE) +DEALLOCATE(CONNECT) +DEALLOCATE(X_PTS) +DEALLOCATE(Y_PTS) +DEALLOCATE(Z_PTS) + +ENDSUBROUTINE BUILD_VTK_GAS_PHASE_GEOMETRY + + +SUBROUTINE ENCODE_BITS(BITS, PADD, CODE) +!< Encode a bits stream (must be multiple of 24 bits) into base64 charcaters code (of length multiple of 4). +!< +!< The bits stream are encoded in chunks of 24 bits as the following example (in little endian order) +!<``` +!< +--first octet--+-second octet--+--third octet--+ +!< |7 6 5 4 3 2 1 0|7 6 5 4 3 2 1 0|7 6 5 4 3 2 1 0| +!< +-----------+---+-------+-------+---+-----------+ +!< |5 4 3 2 1 0|5 4 3 2 1 0|5 4 3 2 1 0|5 4 3 2 1 0| +!< +--1.index--+--2.index--+--3.index--+--4.index--+ +!<``` +!< @note The 4 indexes are stored into 4 elements 8 bits array, thus 2 bits of each array element are not used. +!< +!< @note The number of paddings must be computed outside this procedure, into the calling scope. +!< +!< @warning This procedure is the backend of encoding, thus it must be never called outside the module. +integer(I1P), intent(in) :: bits(1:) !< Bits to be encoded. +integer(I4P), intent(in) :: padd !< Number of padding characters ('='). +character(*), intent(out) :: code !< Characters code. +integer(I1P) :: sixb(1:4) !< 6 bits slices (stored into 8 bits integer) of 24 bits input. +integer(I8P) :: c !< Counter. +integer(I8P) :: e !< Counter. +integer(I8P) :: Nb !< Length of bits array. +character(64) :: base64="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/" !< Base64 alphabet. + +Nb=size(bits,dim=1,kind=I8P) +c = 1_I8P +do e=1_I8P,Nb,3_I8P ! loop over array elements: 3 bytes (24 bits) scanning + sixb = 0_I1P + call mvbits(bits(e ),2,6,sixb(1),0) + call mvbits(bits(e ),0,2,sixb(2),4) + if (e+1<=Nb) then + call mvbits(bits(e+1),4,4,sixb(2),0) + call mvbits(bits(e+1),0,4,sixb(3),2) + endif + if (e+2<=Nb) then + call mvbits(bits(e+2),6,2,sixb(3),0) + call mvbits(bits(e+2),0,6,sixb(4),0) + endif + sixb = sixb + 1_I1P + code(c :c ) = base64(sixb(1):sixb(1)) + code(c+1:c+1) = base64(sixb(2):sixb(2)) + code(c+2:c+2) = base64(sixb(3):sixb(3)) + code(c+3:c+3) = base64(sixb(4):sixb(4)) + c = c + 4_I8P +enddo +if (padd>0) code(len(code)-padd+1:)=repeat('=',padd) +endsubroutine encode_bits + END MODULE VTK !FUNCTION ENCODE_ASCII_DATAARRAY1_RANK1_FB(X) RESULT(CODE) From f47276a674ddfcf29d5570f4078a00711ce86dbd Mon Sep 17 00:00:00 2001 From: Jonathan Hodges <johodges@vt.edu> Date: Tue, 2 Jan 2024 13:07:58 -0500 Subject: [PATCH 20/31] revert storing files in results/ directory --- Source/c_mkdir.c | 11 ----------- Source/dump.f90 | 12 +++++------- Source/f_mkdir.f90 | 12 ------------ 3 files changed, 5 insertions(+), 30 deletions(-) delete mode 100644 Source/c_mkdir.c delete mode 100644 Source/f_mkdir.f90 diff --git a/Source/c_mkdir.c b/Source/c_mkdir.c deleted file mode 100644 index de730241478..00000000000 --- a/Source/c_mkdir.c +++ /dev/null @@ -1,11 +0,0 @@ -#include <sys/types.h> -#include <sys/stat.h> -#include <unistd.h> - -void c_mkdir(const char*directory){ - struct stat st = {0}; - if (stat(directory, &st) == -1) { - mkdir(directory, 0700); - } -} - diff --git a/Source/dump.f90 b/Source/dump.f90 index f81e5ff0d0e..d5f0e44a2c2 100644 --- a/Source/dump.f90 +++ b/Source/dump.f90 @@ -22,9 +22,6 @@ MODULE DUMP USE VTK, ONLY : INITIALIZE_VTK, WRITE_VTK_SLICE_GEOMETRY, WRITE_VTK_SLICE_CELLS, WRITE_VTK_SLICE_DATA,& FINALIZE_VTK,WRITE_VTK_SLICE_WRAPPER,BUILD_VTK_GAS_PHASE_GEOMETRY,WRITE_VTK_SM3D_WRAPPER -USE F_MKDIR, ONLY : C_MKDIR -USE ISO_C_BINDING - IMPLICIT NONE (TYPE,EXTERNAL) PRIVATE @@ -112,7 +109,7 @@ SUBROUTINE DUMP_MESH_OUTPUTS(T,DT,NM) ENDIF IF (T>=SM3D_CLOCK(SM3D_COUNTER(NM)) .AND. SMOKE3D) THEN - CALL C_MKDIR("./results"//char(0)) + !CALL C_MKDIR("./results"//char(0)) CALL DUMP_SMOKE3D(T,DT,NM,0) DO WHILE(SM3D_COUNTER(NM)<SIZE(SM3D_CLOCK)-1) SM3D_COUNTER(NM) = SM3D_COUNTER(NM) + 1 @@ -121,7 +118,7 @@ SUBROUTINE DUMP_MESH_OUTPUTS(T,DT,NM) ENDIF IF (T>=SLCF_CLOCK(SLCF_COUNTER(NM))) THEN - CALL C_MKDIR("./results"//char(0)) + !CALL C_MKDIR("./results"//char(0)) CALL DUMP_SLCF(T,DT,NM,0) DO WHILE(SLCF_COUNTER(NM)<SIZE(SLCF_CLOCK)-1) SLCF_COUNTER(NM) = SLCF_COUNTER(NM) + 1 @@ -4366,7 +4363,8 @@ SUBROUTINE DUMP_SMOKE3D(T,DT,NM,IFRMT) ITM = ITM+1 ITM1 = 0 ENDIF - WRITE(FN_SMOKE3D_VTK(NM),'(A,A,A,I0,A,I8.8,I2.2,A)') "./results/",TRIM(CHID),'_SM3D_',NM,'_',ITM,ITM1,'.vtu' + WRITE(FN_SMOKE3D_VTK(NM),'(A,A,A,I0,A,I8.8,I2.2,A)') "",TRIM(CHID),'_SM3D_',NM,'_',ITM,ITM1,'.vtu' + !WRITE(FN_SMOKE3D_VTK(NM),'(A,A,A,I0,A,I8.8,I2.2,A)') "./results/",TRIM(CHID),'_SM3D_',NM,'_',ITM,ITM1,'.vtu' !WRITE(*,*) "ARRAY SIZES ", IBAR, JBAR, KBAR, IBP1, JBP1, KBP1 ALLOCATE(QQ_PACK(IBP1*JBP1*KBP1)) DO I = 0, IBAR @@ -6035,7 +6033,7 @@ SUBROUTINE DUMP_SLCF(T,DT,NM,IFRMT) ITM = ITM+1 ITM1 = 0 ENDIF - WRITE(FN_SL3D_VTK(NM),'(A,A,A,I0,A,I8.8,I2.2,A)') "./results/",TRIM(CHID),'_SL3D_',NM,'_',ITM,ITM1,'.vtu' + WRITE(FN_SL3D_VTK(NM),'(A,A,A,I0,A,I8.8,I2.2,A)') "",TRIM(CHID),'_SL3D_',NM,'_',ITM,ITM1,'.vtu' IF (SL%SLICETYPE=='STRUCTURED') THEN ! write out slice file using original slice file format CALL INITIALIZE_VTK(LU_SL3D_VTK(NM),FN_SL3D_VTK(NM),'UnstructuredGrid') CALL BUILD_VTK_GAS_PHASE_GEOMETRY(NM, 'UnstructuredGrid', FN_SL3D_VTK(NM), LU_SL3D_VTK(NM)) diff --git a/Source/f_mkdir.f90 b/Source/f_mkdir.f90 deleted file mode 100644 index 5ee69b0f6e6..00000000000 --- a/Source/f_mkdir.f90 +++ /dev/null @@ -1,12 +0,0 @@ -MODULE F_MKDIR - - USE ISO_C_BINDING - - INTERFACE - SUBROUTINE C_MKDIR(DIRECTORY) BIND(C) - USE ISO_C_BINDING - CHARACTER(KIND=C_CHAR),INTENT(IN) :: DIRECTORY(*) - END SUBROUTINE - END INTERFACE - -END MODULE From 1c2b1ea6c936aea0284e75f4bd7ceb14921f546a Mon Sep 17 00:00:00 2001 From: Jonathan Hodges <johodges@vt.edu> Date: Tue, 2 Jan 2024 17:16:40 -0500 Subject: [PATCH 21/31] add vtkfortran module --- Build/makefile | 22 +- Source/dump.f90 | 140 +- Source/prec.f90 | 2 +- Source/vtk.f90 | 526 -- Source/vtkf.f90 | 19593 ++++++++++++++++++++++++++++++++++++++++++++++ 5 files changed, 19719 insertions(+), 564 deletions(-) delete mode 100644 Source/vtk.f90 create mode 100644 Source/vtkf.f90 diff --git a/Build/makefile b/Build/makefile index 9532c762a04..8f7de5a076e 100644 --- a/Build/makefile +++ b/Build/makefile @@ -117,7 +117,7 @@ endif # MKLROOT test obj_mpi = prec.o cons.o prop.o devc.o type.o data.o mesh.o func.o gsmv.o smvv.o rcal.o turb.o soot.o \ pois.o geom.o ccib.o radi.o part.o vege.o ctrl.o hvac.o mass.o \ - wall.o fire.o velo.o pres.o init.o dump.o read.o divg.o main.o + wall.o fire.o velo.o pres.o init.o vtkf.o dump.o read.o divg.o main.o objwin_mpi = $(obj_mpi:.o=.obj) @@ -139,7 +139,7 @@ setup_win: $(FCOMPL) -c $(FFLAGS) $< .f90.obj: $(FCOMPL) -c $(FFLAGS) $< - + # Files which have OpenMP compiler directives are compiled using the FOPENMPFLAG and can be enabled/disabled on a per-file basis. divg.o: FFLAGS += $(FOPENMPFLAGS) @@ -162,6 +162,12 @@ velo.obj: FFLAGS += $(FOPENMPFLAGS) radi.obj: FFLAGS += $(FOPENMPFLAGS) main.obj: FFLAGS += $(FOPENMPFLAGS) +# Add flags for VTKF compilation +#vtkf.o: FFLAGS += -D_R16P +#vtkf.obj: FFLAGS += -D_R16P +#vtkf.o: FFLAGS += -D_R_P_IS_R4P -D_ASCII_SUPPORTED + + # Windows Intel Fortran Compiler and Intel MPI #*** Note: the script, Build\Scripts\setup_intel_compilers.bat, must be run before running make with this target @@ -227,7 +233,7 @@ impi_intel_win_openmp_db : setup_win $(objwin_mpi) # Linux Intel Fortran Compiler and Intel MPI -impi_intel_linux : FFLAGS = -m64 -fc=$(I_IFORT) -O2 -ipo -no-wrap-margin $(GITINFO) $(INTELMPI_COMPINFO) $(FFLAGSMKL_INTEL) -DUSE_IFPORT +impi_intel_linux : FFLAGS = -m64 -fc=$(I_IFORT) -O2 -no-wrap-margin $(GITINFO) $(INTELMPI_COMPINFO) $(FFLAGSMKL_INTEL) -DUSE_IFPORT impi_intel_linux : LFLAGSMKL = $(LFLAGSMKL_INTEL) impi_intel_linux : FCOMPL = mpiifort impi_intel_linux : obj = fds_impi_intel_linux @@ -397,10 +403,11 @@ fire.o : func.o prec.o cons.o type.o mesh.o mass.o soot.o radi.o velo.o : func.o prec.o cons.o type.o mesh.o turb.o geom.o ccib.o pres.o : func.o prec.o cons.o type.o mesh.o pois.o velo.o geom.o ccib.o imkl.o init.o : func.o prec.o cons.o type.o mesh.o devc.o radi.o pois.o data.o pres.o geom.o -dump.o : func.o prec.o cons.o type.o mesh.o devc.o smvv.o turb.o data.o radi.o soot.o geom.o ccib.o fire.o +vtkf.o : func.o prec.o cons.o type.o mesh.o data.o +dump.o : func.o prec.o cons.o type.o mesh.o devc.o smvv.o turb.o data.o radi.o soot.o geom.o ccib.o fire.o vtkf.o read.o : func.o prec.o cons.o type.o mesh.o devc.o ctrl.o radi.o hvac.o data.o geom.o mass.o soot.o prop.o divg.o : func.o prec.o cons.o type.o mesh.o mass.o ccib.o -main.o : func.o prec.o cons.o type.o mesh.o devc.o smvv.o mass.o divg.o velo.o wall.o fire.o radi.o part.o vege.o dump.o read.o init.o pres.o pois.o ctrl.o turb.o hvac.o data.o geom.o ccib.o soot.o prop.o +main.o : func.o prec.o cons.o type.o mesh.o devc.o smvv.o mass.o divg.o velo.o wall.o fire.o radi.o part.o vege.o dump.o read.o init.o pres.o pois.o ctrl.o turb.o hvac.o data.o geom.o ccib.o soot.o prop.o vtkf.o prec.obj : imkl.obj : @@ -430,10 +437,11 @@ fire.obj : func.obj prec.obj cons.obj type.obj mesh.obj mass.obj soot.obj radi.o velo.obj : func.obj prec.obj cons.obj type.obj mesh.obj turb.obj geom.obj ccib.obj pres.obj : func.obj prec.obj cons.obj type.obj mesh.obj pois.obj velo.obj geom.obj ccib.obj imkl.obj init.obj : func.obj prec.obj cons.obj type.obj mesh.obj devc.obj pois.obj data.obj pres.obj geom.obj -dump.obj : func.obj prec.obj cons.obj type.obj mesh.obj devc.obj smvv.obj turb.obj data.obj radi.obj soot.obj geom.obj ccib.obj fire.obj +vtkf.obj : func.obj prec.obj cons.obj type.obj mesh.obj data.obj +dump.obj : func.obj prec.obj cons.obj type.obj mesh.obj devc.obj smvv.obj turb.obj data.obj radi.obj soot.obj geom.obj ccib.obj fire.obj vtkf.obj read.obj : func.obj prec.obj cons.obj type.obj mesh.obj devc.obj ctrl.obj radi.obj hvac.obj data.obj geom.obj mass.obj soot.obj prop.obj divg.obj : func.obj prec.obj cons.obj type.obj mesh.obj mass.obj ccib.obj -main.obj : func.obj prec.obj cons.obj type.obj mesh.obj devc.obj smvv.obj mass.obj divg.obj velo.obj wall.obj fire.obj radi.obj part.obj vege.obj dump.obj read.obj init.obj pres.obj pois.obj ctrl.obj turb.obj hvac.obj data.obj geom.obj ccib.obj soot.obj prop.obj +main.obj : func.obj prec.obj cons.obj type.obj mesh.obj devc.obj smvv.obj mass.obj divg.obj velo.obj wall.obj fire.obj radi.obj part.obj vege.obj dump.obj read.obj init.obj pres.obj pois.obj ctrl.obj turb.obj hvac.obj data.obj geom.obj ccib.obj soot.obj prop.obj vtkf.obj #*** Clean Target to remove Object and Module files *** diff --git a/Source/dump.f90 b/Source/dump.f90 index d5f0e44a2c2..4ac629df9f6 100644 --- a/Source/dump.f90 +++ b/Source/dump.f90 @@ -19,8 +19,9 @@ MODULE DUMP CC_VGSC,CC_GASPHASE,MAKE_UNIQUE_VERT_ARRAY,AVERAGE_FACE_VALUES USE CC_SCALARS, ONLY : ADD_Q_DOT_CUTCELLS,GET_PRES_CFACE,GET_PRES_CFACE_TEST,GET_UVWGAS_CFACE,GET_MUDNS_CFACE -USE VTK, ONLY : INITIALIZE_VTK, WRITE_VTK_SLICE_GEOMETRY, WRITE_VTK_SLICE_CELLS, WRITE_VTK_SLICE_DATA,& - FINALIZE_VTK,WRITE_VTK_SLICE_WRAPPER,BUILD_VTK_GAS_PHASE_GEOMETRY,WRITE_VTK_SM3D_WRAPPER +USE VTK_FDS_INTERFACE, ONLY : WRITE_VTK_SLICE_WRAPPER,BUILD_VTK_GAS_PHASE_GEOMETRY,& + WRITE_VTK_SM3D_WRAPPER,WRITE_VTK_SL3D_WRAPPER,DEALLOCATE_VTK_GAS_PHASE_GEOMETRY +USE VTK_FORTRAN, ONLY : VTK_FILE, PVTK_FILE IMPLICIT NONE (TYPE,EXTERNAL) PRIVATE @@ -109,7 +110,6 @@ SUBROUTINE DUMP_MESH_OUTPUTS(T,DT,NM) ENDIF IF (T>=SM3D_CLOCK(SM3D_COUNTER(NM)) .AND. SMOKE3D) THEN - !CALL C_MKDIR("./results"//char(0)) CALL DUMP_SMOKE3D(T,DT,NM,0) DO WHILE(SM3D_COUNTER(NM)<SIZE(SM3D_CLOCK)-1) SM3D_COUNTER(NM) = SM3D_COUNTER(NM) + 1 @@ -118,7 +118,6 @@ SUBROUTINE DUMP_MESH_OUTPUTS(T,DT,NM) ENDIF IF (T>=SLCF_CLOCK(SLCF_COUNTER(NM))) THEN - !CALL C_MKDIR("./results"//char(0)) CALL DUMP_SLCF(T,DT,NM,0) DO WHILE(SLCF_COUNTER(NM)<SIZE(SLCF_CLOCK)-1) SLCF_COUNTER(NM) = SLCF_COUNTER(NM) + 1 @@ -137,7 +136,7 @@ SUBROUTINE DUMP_MESH_OUTPUTS(T,DT,NM) ! VTK 3-D slices IF (T>=SL3D_VTK_CLOCK(SL3D_VTK_COUNTER(NM)) .OR. STOP_STATUS==INSTABILITY_STOP) THEN IF (NM .EQ. 1) THEN - CALL WRITE_VTK_SLICE_WRAPPER(T,NMESHES,'PUnstructuredGrid') + CALL WRITE_VTK_SL3D_WRAPPER(T,NMESHES,'PUnstructuredGrid') ENDIF CALL DUMP_SLCF(T,DT,NM,3) DO WHILE(SL3D_VTK_COUNTER(NM)<SIZE(SL3D_VTK_CLOCK)-1) @@ -1436,7 +1435,7 @@ SUBROUTINE WRITE_STL_FILE CHARACTER(LEN=80) :: TITLE REAL(FB) :: VERTICES(8,3), XB(6) REAL(FB) :: GEOM_VERTICES(3,3) - INTEGER(IB4) :: COLOR(3), ONE + INTEGER(IB8) :: COLOR(3), ONE INTEGER(IB32) :: NUM_FACETS COLOR = (/0,0,0/) @@ -4281,13 +4280,20 @@ SUBROUTINE DUMP_SMOKE3D(T,DT,NM,IFRMT) USE ISOSMOKE, ONLY: SMOKE3D_TO_FILE REAL(EB), INTENT(IN) :: T,DT INTEGER, INTENT(IN) :: NM,IFRMT -INTEGER :: I,J,K,N,IFACT,JFACT,KFACT,ITM,ITM1 +INTEGER :: I,J,K,N,IFACT,JFACT,KFACT,ITM,ITM1,NC,NP REAL(FB) :: DXX,STIME REAL(EB), POINTER, DIMENSION(:,:,:) :: FF REAL(FB), ALLOCATABLE, DIMENSION(:) :: QQ_PACK +INTEGER(IB8), ALLOCATABLE, DIMENSION(:) :: QQ_PACK_INT +REAL(FB), ALLOCATABLE, DIMENSION(:) :: X_PTS, Y_PTS, Z_PTS +INTEGER(IB32), ALLOCATABLE, DIMENSION(:) :: CONNECT, OFFSETS +INTEGER(IB8), ALLOCATABLE, DIMENSION(:) :: VTKC_TYPE REAL(EB) :: FR_C,TT TYPE(SMOKE3D_TYPE), POINTER :: S3 LOGICAL :: SMV_OUT,VTK_OUT +TYPE(VTK_FILE) :: A_VTK_FILE ! A VTK file. +INTEGER(IB8) :: VTK_ERROR=0_IB8 !< IO Error status. +REAL(FB) :: FACTOR,VAL_FDS,VAL_SMV,TEMP_MIN CALL POINT_TO_MESH(NM) @@ -4378,23 +4384,77 @@ SUBROUTINE DUMP_SMOKE3D(T,DT,NM,IFRMT) ENDDO ENDDO IF (N .EQ. 1) THEN - CALL INITIALIZE_VTK(LU_SMOKE3D_VTK(NM),FN_SMOKE3D_VTK(NM),'UnstructuredGrid') - CALL BUILD_VTK_GAS_PHASE_GEOMETRY(NM, 'UnstructuredGrid', FN_SMOKE3D_VTK(NM), LU_SMOKE3D_VTK(NM)) + !CALL INITIALIZE_VTK(LU_SMOKE3D_VTK(NM),FN_SMOKE3D_VTK(NM),'UnstructuredGrid') + !CALL BUILD_VTK_GAS_PHASE_GEOMETRY(NM, 'UnstructuredGrid', FN_SMOKE3D_VTK(NM), & + ! NC, NP, X_PTS, Y_PTS, Z_PTS, CONNECT, OFFSETS, VTKC_TYPE) + !CALL DEALLOCATE_VTK_GAS_PHASE_GEOMETRY(X_PTS,Y_PTS,Z_PTS,OFFSETS,VTKC_TYPE,CONNECT) + ! + IF (VTK_BINARY) THEN + VTK_ERROR = A_VTK_FILE%INITIALIZE(FORMAT='raw', FILENAME=FN_SMOKE3D_VTK(NM), MESH_TOPOLOGY='UnstructuredGrid') + ELSE + VTK_ERROR = A_VTK_FILE%INITIALIZE(FORMAT='ascii', FILENAME=FN_SMOKE3D_VTK(NM), MESH_TOPOLOGY='UnstructuredGrid') + ENDIF ! do not change capitalization on mesh topology + CALL BUILD_VTK_GAS_PHASE_GEOMETRY(NM, 'UnstructuredGrid', FN_SMOKE3D_VTK(NM), & + NC, NP, X_PTS, Y_PTS, Z_PTS, CONNECT, OFFSETS, VTKC_TYPE) + VTK_ERROR = A_VTK_FILE%XML_WRITER%WRITE_PIECE(NP=NP, NC=NC) + VTK_ERROR = A_VTK_FILE%XML_WRITER%WRITE_GEO(NP=NP, NC=NC, X=X_PTS, Y=Y_PTS, Z=Z_PTS) + VTK_ERROR = A_VTK_FILE%XML_WRITER%WRITE_CONNECTIVITY(NC=NC, CONNECTIVITY=CONNECT, OFFSET=OFFSETS, VTKC_TYPE=VTKC_TYPE) + VTK_ERROR = A_VTK_FILE%XML_WRITER%W_DATA(LOCATION='NODE', ACTION='OPEN') + CALL DEALLOCATE_VTK_GAS_PHASE_GEOMETRY(X_PTS,Y_PTS,Z_PTS,OFFSETS,VTKC_TYPE,CONNECT) + ENDIF - IF (VTK_BINARY) THEN - CALL WRITE_VTK_SLICE_DATA(LU_SMOKE3D_VTK(NM), FN_SMOKE3D_VTK(NM),& - QQ_PACK, S3%SMOKEVIEW_LABEL(1:30), 'ascii') + ALLOCATE(QQ_PACK_INT(IBP1*JBP1*KBP1)) + IF (S3%DISPLAY_TYPE=='GAS') THEN + + FACTOR=-REAL(S3%MASS_EXTINCTION_COEFFICIENT,FB)*DXX + DO I=1,NP + VAL_FDS = MAX(0.0_FB,QQ_PACK(I)) + VAL_SMV = 254*(1.0_FB-EXP(FACTOR*VAL_FDS)) + QQ_PACK_INT(I) = NINT(VAL_SMV) + ENDDO + + ELSEIF (S3%DISPLAY_TYPE=='FIRE') THEN + + DO I=1,NP + VAL_FDS = MIN(HRRPUV_MAX_SMV,MAX(0._FB,QQ_PACK(I))) + VAL_SMV = 254*(VAL_FDS/HRRPUV_MAX_SMV) + QQ_PACK_INT(I) = NINT(VAL_SMV) + ENDDO + + ELSEIF (S3%DISPLAY_TYPE=='TEMPERATURE') THEN + + TEMP_MIN = REAL(TMPA-TMPM,FB) + DO I=1,NP + VAL_FDS = MIN(TEMP_MAX_SMV,MAX(TEMP_MIN,QQ_PACK(I))) + VAL_SMV = 254*((VAL_FDS-TEMP_MIN)/(TEMP_MAX_SMV-TEMP_MIN)) + QQ_PACK_INT(I) = NINT(VAL_SMV) + ENDDO + ELSE - CALL WRITE_VTK_SLICE_DATA(LU_SMOKE3D_VTK(NM), FN_SMOKE3D_VTK(NM),& - QQ_PACK, S3%SMOKEVIEW_LABEL(1:30), 'ascii') + DO I=1,NP + QQ_PACK_INT(I) = NINT(QQ_PACK(I)) + ENDDO ENDIF + + VTK_ERROR = A_VTK_FILE%XML_WRITER%W_DATA(DATA_NAME=S3%SMOKEVIEW_LABEL(1:30), X=QQ_PACK_INT) + !IF (VTK_BINARY) THEN + ! CALL WRITE_VTK_SLICE_DATA(LU_SMOKE3D_VTK(NM), FN_SMOKE3D_VTK(NM),& + ! QQ_PACK, S3%SMOKEVIEW_LABEL(1:30), 'ascii') + !ELSE + ! CALL WRITE_VTK_SLICE_DATA(LU_SMOKE3D_VTK(NM), FN_SMOKE3D_VTK(NM),& + ! QQ_PACK, S3%SMOKEVIEW_LABEL(1:30), 'ascii') + !ENDIF + DEALLOCATE(QQ_PACK_INT) ENDIF DEALLOCATE(QQ_PACK) ENDDO DATA_FILE_LOOP IF (VTK_OUT) THEN - CALL FINALIZE_VTK(LU_SMOKE3D_VTK(NM),FN_SMOKE3D_VTK(NM),'UnstructuredGrid') + !CALL FINALIZE_VTK(LU_SMOKE3D_VTK(NM),FN_SMOKE3D_VTK(NM),'UnstructuredGrid') + VTK_ERROR = A_VTK_FILE%XML_WRITER%W_DATA(LOCATION='NODE', ACTION='CLOSE') + VTK_ERROR = A_VTK_FILE%XML_WRITER%WRITE_PIECE() + VTK_ERROR = A_VTK_FILE%FINALIZE() ENDIF END SUBROUTINE DUMP_SMOKE3D @@ -5872,11 +5932,14 @@ SUBROUTINE DUMP_SLCF(T,DT,NM,IFRMT) REAL(FB) :: SLICE_MIN, SLICE_MAX, DSLICE INTEGER :: NX, NY, NZ, NC, NP INTEGER :: IFACT, JFACT, KFACT -REAL(FB), ALLOCATABLE, DIMENSION(:) :: QQ_PACK, X_PTS, Y_PTS, Z_PTS -INTEGER, ALLOCATABLE, DIMENSION(:) :: CONNECT, OFFSETS -INTEGER(IB4), ALLOCATABLE, DIMENSION(:) :: CELL_TYPE +REAL(FB), ALLOCATABLE, DIMENSION(:) :: QQ_PACK +REAL(FB), ALLOCATABLE, DIMENSION(:) :: X_PTS, Y_PTS, Z_PTS +INTEGER(IB32), ALLOCATABLE, DIMENSION(:) :: CONNECT, OFFSETS +INTEGER(IB8), ALLOCATABLE, DIMENSION(:) :: VTKC_TYPE REAL(FB) :: UVEL, VVEL, WVEL, VEL, PLOT3D_MIN, PLOT3D_MAX INTEGER :: IERROR +TYPE(VTK_FILE) :: A_VTK_FILE ! A VTK file. +INTEGER(IB8) :: VTK_ERROR=0_IB8 !< IO Error status. LOGICAL :: VTK_INITIALIZED ! Return if there are no slices to process and this is not a Plot3D dump @@ -6034,10 +6097,23 @@ SUBROUTINE DUMP_SLCF(T,DT,NM,IFRMT) ITM1 = 0 ENDIF WRITE(FN_SL3D_VTK(NM),'(A,A,A,I0,A,I8.8,I2.2,A)') "",TRIM(CHID),'_SL3D_',NM,'_',ITM,ITM1,'.vtu' - IF (SL%SLICETYPE=='STRUCTURED') THEN ! write out slice file using original slice file format - CALL INITIALIZE_VTK(LU_SL3D_VTK(NM),FN_SL3D_VTK(NM),'UnstructuredGrid') - CALL BUILD_VTK_GAS_PHASE_GEOMETRY(NM, 'UnstructuredGrid', FN_SL3D_VTK(NM), LU_SL3D_VTK(NM)) - ENDIF + IF (VTK_BINARY) THEN + VTK_ERROR = A_VTK_FILE%INITIALIZE(FORMAT='raw', FILENAME=FN_SL3D_VTK(NM), MESH_TOPOLOGY='UnstructuredGrid') + ELSE + VTK_ERROR = A_VTK_FILE%INITIALIZE(FORMAT='ascii', FILENAME=FN_SL3D_VTK(NM), MESH_TOPOLOGY='UnstructuredGrid') + ENDIF ! do not change capitalization on mesh topology + CALL BUILD_VTK_GAS_PHASE_GEOMETRY(NM, 'UnstructuredGrid', FN_SL3D_VTK(NM), & + NC, NP, X_PTS, Y_PTS, Z_PTS, CONNECT, OFFSETS, VTKC_TYPE) + VTK_ERROR = A_VTK_FILE%XML_WRITER%WRITE_PIECE(NP=NP, NC=NC) + VTK_ERROR = A_VTK_FILE%XML_WRITER%WRITE_GEO(NP=NP, NC=NC, X=X_PTS, Y=Y_PTS, Z=Z_PTS) + VTK_ERROR = A_VTK_FILE%XML_WRITER%WRITE_CONNECTIVITY(NC=NC, CONNECTIVITY=CONNECT, OFFSET=OFFSETS, VTKC_TYPE=VTKC_TYPE) + VTK_ERROR = A_VTK_FILE%XML_WRITER%W_DATA(LOCATION='NODE', ACTION='OPEN') + CALL DEALLOCATE_VTK_GAS_PHASE_GEOMETRY(X_PTS,Y_PTS,Z_PTS,OFFSETS,VTKC_TYPE,CONNECT) + + !IF (SL%SLICETYPE=='STRUCTURED') THEN ! write out slice file using original slice file format + ! CALL INITIALIZE_VTK(LU_SL3D_VTK(NM),FN_SL3D_VTK(NM),'UnstructuredGrid') + ! CALL BUILD_VTK_GAS_PHASE_GEOMETRY(NM, 'UnstructuredGrid', FN_SL3D_VTK(NM), LU_SL3D_VTK(NM)) + !ENDIF VTK_INITIALIZED=.TRUE. ENDIF @@ -6330,13 +6406,14 @@ SUBROUTINE DUMP_SLCF(T,DT,NM,IFRMT) ENDDO ENDDO - IF (VTK_BINARY) THEN - CALL WRITE_VTK_SLICE_DATA(LU_SL3D_VTK(NM), FN_SL3D_VTK(NM),& - QQ_PACK, SL%SMOKEVIEW_LABEL(1:30), 'ascii') - ELSE - CALL WRITE_VTK_SLICE_DATA(LU_SL3D_VTK(NM), FN_SL3D_VTK(NM),& - QQ_PACK, SL%SMOKEVIEW_LABEL(1:30), 'ascii') - ENDIF + VTK_ERROR = A_VTK_FILE%XML_WRITER%W_DATA(DATA_NAME=SL%SMOKEVIEW_LABEL(1:30), X=QQ_PACK) + !IF (VTK_BINARY) THEN + ! CALL WRITE_VTK_SLICE_DATA(LU_SL3D_VTK(NM), FN_SL3D_VTK(NM),& + ! QQ_PACK, SL%SMOKEVIEW_LABEL(1:30), 'ascii') + !ELSE + ! CALL WRITE_VTK_SLICE_DATA(LU_SL3D_VTK(NM), FN_SL3D_VTK(NM),& + ! QQ_PACK, SL%SMOKEVIEW_LABEL(1:30), 'ascii') + !ENDIF DEALLOCATE(QQ_PACK) ENDIF @@ -6347,7 +6424,10 @@ SUBROUTINE DUMP_SLCF(T,DT,NM,IFRMT) IF (VTK3D) THEN ! finish after writing all pieces - CALL FINALIZE_VTK(LU_SL3D_VTK(NM),FN_SL3D_VTK(NM),'UnstructuredGrid') + !CALL FINALIZE_VTK(LU_SL3D_VTK(NM),FN_SL3D_VTK(NM),'UnstructuredGrid') + VTK_ERROR = A_VTK_FILE%XML_WRITER%W_DATA(LOCATION='NODE', ACTION='CLOSE') + VTK_ERROR = A_VTK_FILE%XML_WRITER%WRITE_PIECE() + VTK_ERROR = A_VTK_FILE%FINALIZE() ENDIF ! Write out the PLOT3D ``q'' file diff --git a/Source/prec.f90 b/Source/prec.f90 index 10791f7d953..17695231bc6 100644 --- a/Source/prec.f90 +++ b/Source/prec.f90 @@ -6,7 +6,7 @@ MODULE PRECISION_PARAMETERS INTEGER, PARAMETER :: FB = SELECTED_REAL_KIND(6) !< Precision of "Four Byte" reals INTEGER, PARAMETER :: EB = SELECTED_REAL_KIND(12) !< Precision of "Eight Byte" reals -INTEGER, PARAMETER :: IB4 = SELECTED_INT_KIND(1) !< Precision of "One Byte" ints +INTEGER, PARAMETER :: IB8 = SELECTED_INT_KIND(2) !< Precision of "One Byte" ints INTEGER, PARAMETER :: IB16 = SELECTED_INT_KIND(3) !< Precision of "Two Byte" ints INTEGER, PARAMETER :: IB32 = SELECTED_INT_KIND(6) !< Precision of "Four Byte" ints INTEGER, PARAMETER :: QB = SELECTED_REAL_KIND(33,4931) !< Precision of "Sixteen Byte" reals diff --git a/Source/vtk.f90 b/Source/vtk.f90 deleted file mode 100644 index 3af31662e85..00000000000 --- a/Source/vtk.f90 +++ /dev/null @@ -1,526 +0,0 @@ -!> \brief Routines for handling vtk output - -MODULE VTK - -USE MESH_VARIABLES -USE GLOBAL_CONSTANTS -USE MESH_POINTERS -USE OUTPUT_DATA - -IMPLICIT NONE (TYPE,EXTERNAL) -PRIVATE - -PUBLIC INITIALIZE_VTK,WRITE_VTK_SLICE_GEOMETRY,WRITE_VTK_SLICE_CELLS,WRITE_VTK_SLICE_DATA,FINALIZE_VTK,& - WRITE_VTK_SLICE_WRAPPER,BUILD_VTK_GAS_PHASE_GEOMETRY,WRITE_VTK_SM3D_WRAPPER - -CONTAINS - -SUBROUTINE INITIALIZE_VTK(LU,FN,MESH_TOPOLOGY) - -INTEGER, INTENT(IN) :: LU -CHARACTER(LEN=*), INTENT(IN) :: MESH_TOPOLOGY,FN -OPEN(LU,FILE=FN,FORM='FORMATTED') -WRITE(LU,'(A)',ADVANCE='YES') '<?xml version="1.0"?>' -WRITE(LU,'(A,A,A)',ADVANCE='YES') '<VTKFile type="',TRIM(MESH_TOPOLOGY),'" version="1.0" byte_order="LittleEndian">' -WRITE(LU,'(A,A,A)',ADVANCE='YES') ' <',TRIM(MESH_TOPOLOGY),'>' -CLOSE(LU) -END SUBROUTINE INITIALIZE_VTK - -SUBROUTINE WRITE_VTK_SLICE_GEOMETRY(LU, FN, NP, NC, X_PTS, Y_PTS, Z_PTS, FORMAT) - -INTEGER, INTENT(IN) :: LU, NC, NP -REAL(FB), DIMENSION(:), INTENT(IN) :: X_PTS, Y_PTS, Z_PTS -CHARACTER(LEN=*), INTENT(IN) :: FN, FORMAT -INTEGER :: I - -OPEN(LU,FILE=FN,FORM='FORMATTED',STATUS='OLD',POSITION='APPEND') -WRITE(LU,'(A,I0,A,I0,A)',ADVANCE='YES') ' <Piece NumberOfPoints="',NP,'" NumberOfCells="',NC,'">' -WRITE(LU,'(A)',ADVANCE='YES') ' <Points>' -WRITE(LU,'(A,A,A)',ADVANCE='YES') & - ' <DataArray type="Float32" NumberOfComponents="3" Name="Points" format="',FORMAT,'">' - -WRITE(LU,'(A)',ADVANCE='NO') ' ' -IF (TRIM(ADJUSTL(FORMAT)) .eq. 'ascii') THEN - DO I=1,NP - WRITE(LU,'(E15.8,A,E15.8,A,E15.8,A)',ADVANCE='NO') X_PTS(I),' ',Y_PTS(I),' ',Z_PTS(I),' ' - ENDDO -ENDIF -WRITE(LU,'(A)',ADVANCE='YES') ' ' -WRITE(LU,'(A)',ADVANCE='YES') ' </DataArray>' -WRITE(LU,'(A)',ADVANCE='YES') ' </Points>' -CLOSE(LU) - -END SUBROUTINE WRITE_VTK_SLICE_GEOMETRY - -SUBROUTINE WRITE_VTK_SLICE_CELLS(LU, FN, CONNECT, OFFSETS, CELL_TYPE, FORMAT) - -INTEGER, INTENT(IN) :: LU -INTEGER, DIMENSION(:), INTENT(IN) :: CONNECT, OFFSETS -INTEGER(IB4), DIMENSION(:), INTENT(IN) :: CELL_TYPE -CHARACTER(LEN=*), INTENT(IN) :: FN, FORMAT -INTEGER :: I - -! Open cells section -OPEN(LU,FILE=FN,FORM='FORMATTED',STATUS='OLD',POSITION='APPEND') -WRITE(LU,'(A)',ADVANCE='YES') ' <Cells>' - -! Write connectivity -WRITE(LU,'(A,A,A)',ADVANCE='YES') & - ' <DataArray type="Int32" NumberOfComponents="1" Name="connectivity" format="',FORMAT,'">' - -WRITE(LU,'(A)',ADVANCE='NO') ' ' -IF (TRIM(ADJUSTL(FORMAT)) .EQ. 'ascii') THEN - DO I=1,SIZE(CONNECT) - WRITE(LU,'(I0,A)',ADVANCE='NO') CONNECT(I), ' ' - ENDDO -ENDIF -WRITE(LU,'(A)',ADVANCE='YES') ' ' -WRITE(LU,'(A)',ADVANCE='YES') ' </DataArray>' - -! Write offsets -WRITE(LU,'(A,A,A)',ADVANCE='YES') & - ' <DataArray type="Int32" NumberOfComponents="1" Name="offsets" format="',FORMAT,'">' - -WRITE(LU,'(A)',ADVANCE='NO') ' ' -IF (TRIM(ADJUSTL(FORMAT)) .EQ. 'ascii') THEN - DO I=1,SIZE(OFFSETS) - WRITE(LU,'(I0,A)',ADVANCE='NO') OFFSETS(I), ' ' - ENDDO -ENDIF -WRITE(LU,'(A)',ADVANCE='YES') ' ' -WRITE(LU,'(A)',ADVANCE='YES') ' </DataArray>' - -! Write cell types -WRITE(LU,'(A,A,A)',ADVANCE='YES') & - ' <DataArray type="Int8" NumberOfComponents="1" Name="types" format="',FORMAT,'">' - -WRITE(LU,'(A)',ADVANCE='NO') ' ' -IF (TRIM(ADJUSTL(FORMAT)) .EQ. 'ascii') THEN - DO I=1,SIZE(CELL_TYPE) - WRITE(LU,'(I0,A)',ADVANCE='NO') CELL_TYPE(I), ' ' - ENDDO -ENDIF -WRITE(LU,'(A)',ADVANCE='YES') ' ' -WRITE(LU,'(A)',ADVANCE='YES') ' </DataArray>' - -! Close cell section -WRITE(LU,'(A)',ADVANCE='YES') ' </Cells>' - -! Open point data section -WRITE(LU,'(A)',ADVANCE='YES') ' <PointData>' - -CLOSE(LU) - -END SUBROUTINE WRITE_VTK_SLICE_CELLS - -SUBROUTINE WRITE_VTK_SLICE_DATA(LU, FN, DATA, DATA_NAME, FORMAT) - -INTEGER, INTENT(IN) :: LU -CHARACTER(LEN=*), INTENT(IN) :: FORMAT, DATA_NAME, FN -CHARACTER(LEN=:), ALLOCATABLE :: CODE -REAL(FB), DIMENSION(:) :: DATA -INTEGER :: I, NBITS_DATA, NSTRINGS_DATA -CHARACTER(LEN=:), ALLOCATABLE :: BIT_DATA - -!real(R16P), intent(in) :: n !< Number to be encoded. -integer(I1P), allocatable :: nI1P(:) !< One byte integer array containing n. -integer(I4P) :: padd !< Number of padding characters ('='). - -integer(I4P) :: BYR16P = 2_I1P - - - - -! Open data section -OPEN(LU,FILE=FN,FORM='FORMATTED',STATUS='OLD',POSITION='APPEND') - -! Write data -WRITE(LU,'(A,A,A,A,A)',ADVANCE='YES') & - ' <DataArray type="Float32" NumberOfComponents="1" Name="',& - TRIM(DATA_NAME),'" format="',FORMAT,'">' - -WRITE(LU,'(A)',ADVANCE='NO') ' ' -IF (TRIM(ADJUSTL(FORMAT)) .EQ. 'ascii') THEN - DO I=1,SIZE(DATA) - WRITE(LU,'(E15.8,A)',ADVANCE='NO') DATA(I), ' ' - ENDDO -ELSEIF (TRIM(ADJUSTL(FORMAT)) .EQ. 'binary') THEN - CLOSE(LU) - OPEN(LU,FILE=FN,FORM='UNFORMATTED',STATUS='OLD',POSITION='APPEND') - !NBITS_DATA = SIZE(DATA) * SIZEOF(FB)*2 - !NSTRINGS_DATA = INT(FLOAT(NBITS_DATA)/3+0.9) - - allocate(nI1P(1:((BYR16P+2)/3)*3)) ; nI1P = 0_I1P - code = repeat(' ',((BYR16P+2)/3)*4) - nI1P = transfer(DATA,nI1P) - padd = mod((BYR16P),3) ; if (padd>0_I4P) padd = 3_I4P - padd - - - - CALL ENCODE_BITS(BITS=NI1P,PADD=PADD,CODE=CODE) - - WRITE(*,*) "SIZES", SIZE(DATA), NBITS_DATA - WRITE(*,*) PADD - WRITE(*,*) CODE - !ALLOCATE(CHARACTER(LEN=NBITS_DATA) :: BIT_DATA) - !WRITE(BIT_DATA,'(B64)') DATA - !WRITE(*,*) BIT_DATA - !DEALLOCATE(BIT_DATA) - !DO I=0,NSTRINGS_DATA - ! STRINGBITS = DATA(I*6:(I+1)*6) - ! WRITE(*,*), "DATA ", I, " ", STRINGBITS - !ENDDO - !WRITE(LU_SL3D_VTK(NM)) NBITS_DATA , (DATA(I),I=1,SIZE(DATA)) - CLOSE(LU) - OPEN(LU,FILE=FN,FORM='FORMATTED',STATUS='OLD',POSITION='APPEND') - !CODE=ENCODE_ASCII_DATAARRAY1_RANK1_FB(DATA) - !WRITE(LU_SL3D_VTK(NM)) CODE -ELSEIF (TRIM(ADJUSTL(FORMAT)) .EQ. 'appended') THEN - CLOSE(LU) - OPEN(LU,FILE=FN,FORM='UNFORMATTED',STATUS='OLD',POSITION='APPEND') - NBITS_DATA = SIZE(DATA) * SIZEOF(FB) - WRITE(LU) NBITS_DATA , (DATA(I),I=1,SIZE(DATA)) - CLOSE(LU) - OPEN(LU,FILE=FN,FORM='FORMATTED',STATUS='OLD',POSITION='APPEND') - !CODE=ENCODE_ASCII_DATAARRAY1_RANK1_FB(DATA) - !WRITE(LU_SL3D_VTK(NM)) CODE -ENDIF -WRITE(LU,'(A)',ADVANCE='YES') ' ' - -! Close data section -WRITE(LU,'(A)',ADVANCE='YES') ' </DataArray>' -CLOSE(LU) - -END SUBROUTINE WRITE_VTK_SLICE_DATA - -SUBROUTINE FINALIZE_VTK(LU,FN,MESH_TOPOLOGY) - -INTEGER, INTENT(IN) :: LU -CHARACTER(LEN=*), INTENT(IN) :: MESH_TOPOLOGY,FN - -! Close VTK file -OPEN(LU,FILE=FN,FORM='FORMATTED',STATUS='OLD',POSITION='APPEND') -WRITE(LU,'(A)',ADVANCE='YES') ' </PointData>' -WRITE(LU,'(A)',ADVANCE='YES') ' </Piece>' -WRITE(LU,'(A,A,A)',ADVANCE='YES') ' </',TRIM(MESH_TOPOLOGY),'>' -WRITE(LU,'(A)',ADVANCE='YES') '</VTKFile>' - -CLOSE(LU) -END SUBROUTINE FINALIZE_VTK - -SUBROUTINE WRITE_VTK_SLICE_WRAPPER(T,NMESHES,MESH_TOPOLOGY) -INTEGER, INTENT(IN) :: NMESHES -CHARACTER(LEN=*), INTENT(IN) :: MESH_TOPOLOGY -REAL(EB), INTENT(IN) :: T -TYPE (SLICE_TYPE), POINTER :: SL -INTEGER :: I,NQT,I1,I2,J1,J2,K1,K2,IQ,ITM,ITM1 -REAL(FB) :: STIME -REAL(EB) :: TT -CHARACTER(200) :: TMP_FILE - -! Generate filename -STIME = REAL(T_BEGIN + (T-T_BEGIN)*TIME_SHRINK_FACTOR,FB) -TT = T_BEGIN + (T-T_BEGIN)*TIME_SHRINK_FACTOR -ITM = INT(TT) -ITM1 = NINT(ABS(TT-ITM)*100) -IF (ITM1==100) THEN - ITM = ITM+1 - ITM1 = 0 -ENDIF -WRITE(FN_SL3D_VTK(NMESHES+1),'(A,A,A,I8.8,I2.2,A)') "./results/",TRIM(CHID),'_SL3D_',ITM,ITM1,'.pvtu' - -! First part of header before quantities -OPEN(LU_SL3D_VTK(NMESHES+1),FILE=FN_SL3D_VTK(NMESHES+1),FORM='FORMATTED') -WRITE(LU_SL3D_VTK(NMESHES+1),'(A)',ADVANCE='YES') '<?xml version="1.0"?>' -WRITE(LU_SL3D_VTK(NMESHES+1),'(A,A,A)',ADVANCE='YES') & - '<VTKFile type="',TRIM(MESH_TOPOLOGY),'" version="1.0" byte_order="LittleEndian">' -WRITE(LU_SL3D_VTK(NMESHES+1),'(A,A,A)',ADVANCE='YES') ' <',TRIM(MESH_TOPOLOGY),' GhostLevel="0">' -WRITE(LU_SL3D_VTK(NMESHES+1),'(A)',ADVANCE='YES') ' <PPointData>' - -! Add PointData arrays -NQT = MESHES(1)%N_SLCF -QUANTITY_LOOP2: DO IQ=1,NQT - SL => SLICE(IQ) - I1 = SL%I1 - I2 = SL%I2 - J1 = SL%J1 - J2 = SL%J2 - K1 = SL%K1 - K2 = SL%K2 - IF (I2-I1==0 .OR. J2-J1==0 .OR. K2-K1==0) CYCLE QUANTITY_LOOP2 - WRITE(LU_SL3D_VTK(NMESHES+1),'(A)',ADVANCE='NO') ' <PDataArray type="Float32" NumberOfComponents="1" Name=' - WRITE(LU_SL3D_VTK(NMESHES+1),'(A,A,A)',ADVANCE='NO') '"',TRIM(SL%SMOKEVIEW_LABEL(1:30)),'" format=' - IF (VTK_BINARY) THEN - WRITE(LU_SL3D_VTK(NMESHES+1),'(A)',ADVANCE='YES') '"binary"/>' - ELSE - WRITE(LU_SL3D_VTK(NMESHES+1),'(A)',ADVANCE='YES') '"ascii"/>' - ENDIF -ENDDO QUANTITY_LOOP2 - -! Close PointData -WRITE(LU_SL3D_VTK(NMESHES+1),'(A)',ADVANCE='YES') ' </PPointData>' - -! Add Point arrays -WRITE(LU_SL3D_VTK(NMESHES+1),'(A)',ADVANCE='YES') ' <PPoints>' -WRITE(LU_SL3D_VTK(NMESHES+1),'(A)',ADVANCE='NO') ' <PDataArray type="Float32" NumberOfComponents="3" Name="Points" format=' -IF (VTK_BINARY) THEN - WRITE(LU_SL3D_VTK(NMESHES+1),'(A)',ADVANCE='YES') '"binary"/>' -ELSE - WRITE(LU_SL3D_VTK(NMESHES+1),'(A)',ADVANCE='YES') '"ascii"/>' -ENDIF -WRITE(LU_SL3D_VTK(NMESHES+1),'(A)',ADVANCE='YES') ' </PPoints>' - -! Add CellData -WRITE(LU_SL3D_VTK(NMESHES+1),'(A)',ADVANCE='YES') ' <PCellData></PCellData>' - -! Write pieces -DO I=1,NMESHES - WRITE(TMP_FILE,'(A,A,I0,A,I8.8,I2.2,A)') TRIM(CHID),'_SL3D_',I,'_',ITM,ITM1,'.vtu' - WRITE(LU_SL3D_VTK(NMESHES+1),'(A,A,A)',ADVANCE='YES') ' <Piece Source="',TRIM(TMP_FILE),'"/>' -ENDDO - -! Finalize file -WRITE(LU_SL3D_VTK(NMESHES+1),'(A,A,A)',ADVANCE='YES') ' </',TRIM(MESH_TOPOLOGY),'>' -WRITE(LU_SL3D_VTK(NMESHES+1),'(A)',ADVANCE='YES') '</VTKFile>' -CLOSE(LU_SL3D_VTK(NMESHES+1)) -END SUBROUTINE WRITE_VTK_SLICE_WRAPPER - - - - - - - - - - - - - - - - - -SUBROUTINE WRITE_VTK_SM3D_WRAPPER(T,NMESHES,MESH_TOPOLOGY) -INTEGER, INTENT(IN) :: NMESHES -CHARACTER(LEN=*), INTENT(IN) :: MESH_TOPOLOGY -REAL(EB), INTENT(IN) :: T -TYPE (SLICE_TYPE), POINTER :: SL -INTEGER :: I,NQT,I1,I2,J1,J2,K1,K2,IQ,ITM,ITM1,N -REAL(FB) :: STIME -REAL(EB) :: TT -CHARACTER(200) :: TMP_FILE -TYPE(SMOKE3D_TYPE), POINTER :: S3 - -! Generate filename -STIME = REAL(T_BEGIN + (T-T_BEGIN)*TIME_SHRINK_FACTOR,FB) -TT = T_BEGIN + (T-T_BEGIN)*TIME_SHRINK_FACTOR -ITM = INT(TT) -ITM1 = NINT(ABS(TT-ITM)*100) -IF (ITM1==100) THEN - ITM = ITM+1 - ITM1 = 0 -ENDIF -WRITE(FN_SMOKE3D_VTK(NMESHES+1),'(A,A,A,A,A,I8.8,I2.2,A)') "./results/",TRIM(CHID),'_','SM3D','_',ITM,ITM1,'.pvtu' - -! First part of header before quantities -OPEN(LU_SMOKE3D_VTK(NMESHES+1),FILE=FN_SMOKE3D_VTK(NMESHES+1),FORM='FORMATTED') -WRITE(LU_SMOKE3D_VTK(NMESHES+1),'(A)',ADVANCE='YES') '<?xml version="1.0"?>' -WRITE(LU_SMOKE3D_VTK(NMESHES+1),'(A,A,A)',ADVANCE='YES') & - '<VTKFile type="',TRIM(MESH_TOPOLOGY),'" version="1.0" byte_order="LittleEndian">' -WRITE(LU_SMOKE3D_VTK(NMESHES+1),'(A,A,A)',ADVANCE='YES') ' <',TRIM(MESH_TOPOLOGY),' GhostLevel="0">' -WRITE(LU_SMOKE3D_VTK(NMESHES+1),'(A)',ADVANCE='YES') ' <PPointData>' - -! Add PointData arrays -DATA_FILE_LOOP2: DO N=1,N_SMOKE3D - - S3 => SMOKE3D_FILE(N) - WRITE(*,*) "SMOKE3D QUANTITY", S3%SMOKEVIEW_LABEL(1:30) - WRITE(LU_SMOKE3D_VTK(NMESHES+1),'(A)',ADVANCE='NO') ' <PDataArray type="Float32" NumberOfComponents="1" Name=' - WRITE(LU_SMOKE3D_VTK(NMESHES+1),'(A,A,A)',ADVANCE='NO') '"',TRIM(S3%SMOKEVIEW_LABEL(1:30)),'" format=' - IF (VTK_BINARY) THEN - WRITE(LU_SMOKE3D_VTK(NMESHES+1),'(A)',ADVANCE='YES') '"binary"/>' - ELSE - WRITE(LU_SMOKE3D_VTK(NMESHES+1),'(A)',ADVANCE='YES') '"ascii"/>' - ENDIF -ENDDO DATA_FILE_LOOP2 - -! Close PointData -WRITE(LU_SMOKE3D_VTK(NMESHES+1),'(A)',ADVANCE='YES') ' </PPointData>' - -! Add Point arrays -WRITE(LU_SMOKE3D_VTK(NMESHES+1),'(A)',ADVANCE='YES') ' <PPoints>' -WRITE(LU_SMOKE3D_VTK(NMESHES+1),'(A)',ADVANCE='NO') ' <PDataArray type="Float32" NumberOfComponents="3" Name="Points" format=' -IF (VTK_BINARY) THEN - WRITE(LU_SMOKE3D_VTK(NMESHES+1),'(A)',ADVANCE='YES') '"binary"/>' -ELSE - WRITE(LU_SMOKE3D_VTK(NMESHES+1),'(A)',ADVANCE='YES') '"ascii"/>' -ENDIF -WRITE(LU_SMOKE3D_VTK(NMESHES+1),'(A)',ADVANCE='YES') ' </PPoints>' - -! Add CellData -WRITE(LU_SMOKE3D_VTK(NMESHES+1),'(A)',ADVANCE='YES') ' <PCellData></PCellData>' - -! Write pieces -DO I=1,NMESHES - WRITE(TMP_FILE,'(A,A,I0,A,I8.8,I2.2,A)') TRIM(CHID),'_SM3D_',I,'_',ITM,ITM1,'.vtu' - WRITE(LU_SMOKE3D_VTK(NMESHES+1),'(A,A,A)',ADVANCE='YES') ' <Piece Source="',TRIM(TMP_FILE),'"/>' -ENDDO - -! Finalize file -WRITE(LU_SMOKE3D_VTK(NMESHES+1),'(A,A,A)',ADVANCE='YES') ' </',TRIM(MESH_TOPOLOGY),'>' -WRITE(LU_SMOKE3D_VTK(NMESHES+1),'(A)',ADVANCE='YES') '</VTKFile>' -CLOSE(LU_SMOKE3D_VTK(NMESHES+1)) -END SUBROUTINE WRITE_VTK_SM3D_WRAPPER - - - -SUBROUTINE BUILD_VTK_GAS_PHASE_GEOMETRY(NM, MESH_TOPOLOGY, FN, LU) - -INTEGER :: NX, NY, NZ, NC, NP, I, J, K, IFACT, JFACT, KFACT -REAL(FB), ALLOCATABLE, DIMENSION(:) :: QQ_PACK, X_PTS, Y_PTS, Z_PTS -INTEGER, ALLOCATABLE, DIMENSION(:) :: CONNECT, OFFSETS -INTEGER(IB4), ALLOCATABLE, DIMENSION(:) :: CELL_TYPE -CHARACTER(LEN=*), INTENT(IN) :: MESH_TOPOLOGY, FN -INTEGER, INTENT(IN) :: NM, LU - -NX = SIZE(MESHES(NM)%X) -NY = SIZE(MESHES(NM)%Y) -NZ = SIZE(MESHES(NM)%Z) - -NP = NX*NY*NZ -NC = (NX-1)*(NY-1)*(NZ-1) - -! Fill point data -ALLOCATE(X_PTS(NP)) -ALLOCATE(Y_PTS(NP)) -ALLOCATE(Z_PTS(NP)) -IFACT = 1 -DO K = 0, NZ-1 - DO J = 0, NY-1 - DO I = 0, NX-1 - X_PTS(IFACT)=MESHES(NM)%X(I) - Y_PTS(IFACT)=MESHES(NM)%Y(J) - Z_PTS(IFACT)=MESHES(NM)%Z(K) - IFACT = IFACT + 1 - ENDDO - ENDDO -ENDDO - -! Fill cell data -ALLOCATE(CONNECT(NC*8)) -DO I = 1, NX-1 - IFACT = (I-1) - DO J = 1, NY-1 - JFACT = (J-1)*(NX-1) - DO K = 1, NZ-1 - KFACT = (K - 1)*(NY-1)*(NX-1) - CONNECT((IFACT+JFACT+KFACT)*8+1) = (K-1)*(NY*NX) + (J-1)*NX + I-1 - CONNECT((IFACT+JFACT+KFACT)*8+2) = (K-1)*(NY*NX) + (J-1)*NX + I - CONNECT((IFACT+JFACT+KFACT)*8+3) = (K-1)*(NY*NX) + (J)*NX + I-1 - CONNECT((IFACT+JFACT+KFACT)*8+4) = (K-1)*(NY*NX) + (J)*NX + I - CONNECT((IFACT+JFACT+KFACT)*8+5) = (K)*(NY*NX) + (J-1)*NX + I-1 - CONNECT((IFACT+JFACT+KFACT)*8+6) = (K)*(NY*NX) + (J-1)*NX + I - CONNECT((IFACT+JFACT+KFACT)*8+7) = (K)*(NY*NX) + (J)*NX + I-1 - CONNECT((IFACT+JFACT+KFACT)*8+8) = (K)*(NY*NX) + (J)*NX + I - ENDDO - ENDDO -ENDDO - -ALLOCATE(OFFSETS(NC)) -ALLOCATE(CELL_TYPE(NC)) - -DO I=1,NC - OFFSETS(I) = (I)*8_IB4 - CELL_TYPE(I) = 11_IB4 -ENDDO - -IF (VTK_BINARY) THEN - CALL WRITE_VTK_SLICE_GEOMETRY(LU,FN,NP,NC,X_PTS,Y_PTS,Z_PTS,'ascii') - CALL WRITE_VTK_SLICE_CELLS(LU,FN,CONNECT,OFFSETS,CELL_TYPE,'ascii') -ELSE - CALL WRITE_VTK_SLICE_GEOMETRY(LU,FN,NP,NC,X_PTS,Y_PTS,Z_PTS,'ascii') - CALL WRITE_VTK_SLICE_CELLS(LU,FN,CONNECT,OFFSETS,CELL_TYPE,'ascii') -ENDIF - -DEALLOCATE(OFFSETS) -DEALLOCATE(CELL_TYPE) -DEALLOCATE(CONNECT) -DEALLOCATE(X_PTS) -DEALLOCATE(Y_PTS) -DEALLOCATE(Z_PTS) - -ENDSUBROUTINE BUILD_VTK_GAS_PHASE_GEOMETRY - - -SUBROUTINE ENCODE_BITS(BITS, PADD, CODE) -!< Encode a bits stream (must be multiple of 24 bits) into base64 charcaters code (of length multiple of 4). -!< -!< The bits stream are encoded in chunks of 24 bits as the following example (in little endian order) -!<``` -!< +--first octet--+-second octet--+--third octet--+ -!< |7 6 5 4 3 2 1 0|7 6 5 4 3 2 1 0|7 6 5 4 3 2 1 0| -!< +-----------+---+-------+-------+---+-----------+ -!< |5 4 3 2 1 0|5 4 3 2 1 0|5 4 3 2 1 0|5 4 3 2 1 0| -!< +--1.index--+--2.index--+--3.index--+--4.index--+ -!<``` -!< @note The 4 indexes are stored into 4 elements 8 bits array, thus 2 bits of each array element are not used. -!< -!< @note The number of paddings must be computed outside this procedure, into the calling scope. -!< -!< @warning This procedure is the backend of encoding, thus it must be never called outside the module. -integer(I1P), intent(in) :: bits(1:) !< Bits to be encoded. -integer(I4P), intent(in) :: padd !< Number of padding characters ('='). -character(*), intent(out) :: code !< Characters code. -integer(I1P) :: sixb(1:4) !< 6 bits slices (stored into 8 bits integer) of 24 bits input. -integer(I8P) :: c !< Counter. -integer(I8P) :: e !< Counter. -integer(I8P) :: Nb !< Length of bits array. -character(64) :: base64="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/" !< Base64 alphabet. - -Nb=size(bits,dim=1,kind=I8P) -c = 1_I8P -do e=1_I8P,Nb,3_I8P ! loop over array elements: 3 bytes (24 bits) scanning - sixb = 0_I1P - call mvbits(bits(e ),2,6,sixb(1),0) - call mvbits(bits(e ),0,2,sixb(2),4) - if (e+1<=Nb) then - call mvbits(bits(e+1),4,4,sixb(2),0) - call mvbits(bits(e+1),0,4,sixb(3),2) - endif - if (e+2<=Nb) then - call mvbits(bits(e+2),6,2,sixb(3),0) - call mvbits(bits(e+2),0,6,sixb(4),0) - endif - sixb = sixb + 1_I1P - code(c :c ) = base64(sixb(1):sixb(1)) - code(c+1:c+1) = base64(sixb(2):sixb(2)) - code(c+2:c+2) = base64(sixb(3):sixb(3)) - code(c+3:c+3) = base64(sixb(4):sixb(4)) - c = c + 4_I8P -enddo -if (padd>0) code(len(code)-padd+1:)=repeat('=',padd) -endsubroutine encode_bits - -END MODULE VTK - -!FUNCTION ENCODE_ASCII_DATAARRAY1_RANK1_FB(X) RESULT(CODE) -!!< Encode (Base64) a dataarray with 1 components of rank 1 (FB). -!REAL(FB), INTENT(IN) :: X(1:) !< Data variable. -!CHARACTER(len=:), ALLOCATABLE :: CODE !< Encoded base64 dataarray. -!INTEGER(IB16) :: N !< Counter. -!INTEGER(IB16) :: L !< Length -!INTEGER(IB16) :: SP !< String pointer -!INTEGER(IB16) :: SIZE_N!< Dimension size -! -!SIZE_N = SIZE(X,DIM=1) -!L = DI2P+1 -!SP = 0 -!CODE = REPEAT(' ',L*SIZE_N) -!DO N = 1,SIZE_N -! CODE(SP+1:SP+L) = STR(N=X(N)) -! SP = SP + L -!ENDDO -!ENDFUNCTION ENCODE_ASCII_DATAARRAY1_RANK1_FB -! -!END MODULE VTK diff --git a/Source/vtkf.f90 b/Source/vtkf.f90 new file mode 100644 index 00000000000..59943682cd5 --- /dev/null +++ b/Source/vtkf.f90 @@ -0,0 +1,19593 @@ +!< PENF GLOBAL PARAMETERS AND VARIABLES. + +MODULE PENF_GLOBAL_PARAMETERS_VARIABLES +!< PENF GLOBAL PARAMETERS AND VARIABLES. +!< +!< @NOTE ALL MODULE DEFINED ENTITIES ARE PUBLIC. + +IMPLICIT NONE +PUBLIC +SAVE + +INTEGER, PARAMETER :: ENDIANL = 1 !< LITTLE ENDIAN PARAMETER. +INTEGER, PARAMETER :: ENDIANB = 0 !< BIG ENDIAN PARAMETER. + +! PORTABLE KIND PARAMETERS +#ifdef _ASCII_SUPPORTED +INTEGER, PARAMETER :: ASCII = SELECTED_CHAR_KIND('ASCII') !< ASCII CHARACTER SET KIND. +#else +INTEGER, PARAMETER :: ASCII = SELECTED_CHAR_KIND('DEFAULT') !< ASCII CHARACTER SET KIND DEFINED AS DEFAULT SET. +#endif +#ifdef _UCS4_SUPPORTED +INTEGER, PARAMETER :: UCS4 = SELECTED_CHAR_KIND('ISO_10646') !< UNICODE CHARACTER SET KIND. +#else +INTEGER, PARAMETER :: UCS4 = SELECTED_CHAR_KIND('DEFAULT') !< UNICODE CHARACTER SET KIND DEFINED AS DEFAULT SET. +#endif +#if defined _CK_IS_DEFAULT +INTEGER, PARAMETER :: CK = SELECTED_CHAR_KIND('DEFAULT') !< DEFAULT KIND CHARACTER. +#elif defined _CK_IS_ASCII +INTEGER, PARAMETER :: CK = ASCII !< DEFAULT KIND CHARACTER. +#elif defined _CK_IS_UCS4 +INTEGER, PARAMETER :: CK = UCS4 !< DEFAULT KIND CHARACTER. +#else +INTEGER, PARAMETER :: CK = SELECTED_CHAR_KIND('DEFAULT') !< DEFAULT KIND CHARACTER. +#endif + +INTEGER, PARAMETER :: R16P = SELECTED_REAL_KIND(33,4931) !< 33 DIGITS, RANGE \([10^{-4931}, 10^{+4931} - 1]\); 128 BITS. +INTEGER, PARAMETER :: R8P = SELECTED_REAL_KIND(15,307) !< 15 DIGITS, RANGE \([10^{-307} , 10^{+307} - 1]\); 64 BITS. +INTEGER, PARAMETER :: R4P = SELECTED_REAL_KIND(6,37) !< 6 DIGITS, RANGE \([10^{-37} , 10^{+37} - 1]\); 32 BITS. +#if defined _R_P_IS_R16P +INTEGER, PARAMETER :: R_P = R16P !< DEFAULT REAL PRECISION. +#elif defined _R_P_IS_R8P +INTEGER, PARAMETER :: R_P = R8P !< DEFAULT REAL PRECISION. +#elif defined _R_P_IS_R4P +INTEGER, PARAMETER :: R_P = R4P !< DEFAULT REAL PRECISION. +#else +INTEGER, PARAMETER :: R_P = R8P !< DEFAULT REAL PRECISION. +#endif + +INTEGER, PARAMETER :: I8P = SELECTED_INT_KIND(18) !< RANGE \([-2^{63},+2^{63} - 1]\), 19 DIGITS PLUS SIGN; 64 BITS. +INTEGER, PARAMETER :: I4P = SELECTED_INT_KIND(9) !< RANGE \([-2^{31},+2^{31} - 1]\), 10 DIGITS PLUS SIGN; 32 BITS. +INTEGER, PARAMETER :: I2P = SELECTED_INT_KIND(4) !< RANGE \([-2^{15},+2^{15} - 1]\), 5 DIGITS PLUS SIGN; 16 BITS. +INTEGER, PARAMETER :: I1P = SELECTED_INT_KIND(2) !< RANGE \([-2^{7} ,+2^{7} - 1]\), 3 DIGITS PLUS SIGN; 8 BITS. +INTEGER, PARAMETER :: I_P = I4P !< DEFAULT INTEGER PRECISION. + +! FORMAT PARAMETERS +CHARACTER(*), PARAMETER :: FR16P = '(E42.33E4)' !< OUTPUT FORMAT FOR KIND=R16P REAL. +CHARACTER(*), PARAMETER :: FR8P = '(E23.15E3)' !< OUTPUT FORMAT FOR KIND=R8P REAL. +CHARACTER(*), PARAMETER :: FR4P = '(E13.6E2)' !< OUTPUT FORMAT FOR KIND=R4P REAL. +#if defined _R_P_IS_R16P +CHARACTER(*), PARAMETER :: FR_P = FR16P !< OUTPUT FORMAT FOR KIND=R_P REAL. +#elif defined _R_P_IS_R8P +CHARACTER(*), PARAMETER :: FR_P = FR8P !< OUTPUT FORMAT FOR KIND=R_P REAL. +#elif defined _R_P_IS_R4P +CHARACTER(*), PARAMETER :: FR_P = FR4P !< OUTPUT FORMAT FOR KIND=R_P REAL. +#else +CHARACTER(*), PARAMETER :: FR_P = FR8P !< OUTPUT FORMAT FOR KIND=R_P REAL. +#endif + +CHARACTER(*), PARAMETER :: FI8P = '(I20)' !< OUTPUT FORMAT FOR KIND=I8P INTEGER. +CHARACTER(*), PARAMETER :: FI8PZP = '(I20.19)' !< OUTPUT FORMAT FOR KIND=I8P INTEGER WITH ZERO PREFIXING. +CHARACTER(*), PARAMETER :: FI4P = '(I11)' !< OUTPUT FORMAT FOR KIND=I4P INTEGER. +CHARACTER(*), PARAMETER :: FI4PZP = '(I11.10)' !< OUTPUT FORMAT FOR KIND=I4P INTEGER WITH ZERO PREFIXING. +CHARACTER(*), PARAMETER :: FI2P = '(I6)' !< OUTPUT FORMAT FOR KIND=I2P INTEGER. +CHARACTER(*), PARAMETER :: FI2PZP = '(I6.5)' !< OUTPUT FORMAT FOR KIND=I2P INTEGER WITH ZERO PREFIXING. +CHARACTER(*), PARAMETER :: FI1P = '(I4)' !< OUTPUT FORMAT FOR KIND=I1P INTEGER. +CHARACTER(*), PARAMETER :: FI1PZP = '(I4.3)' !< OUTPUT FORMAT FOR KIND=I1P INTEGER WITH ZERO PREFIXING. +CHARACTER(*), PARAMETER :: FI_P = FI4P !< OUTPUT FORMAT FOR KIND=I_P INTEGER. +CHARACTER(*), PARAMETER :: FI_PZP = FI4PZP !< OUTPUT FORMAT FOR KIND=I_P INTEGER WITH ZERO PREFIXING. + +! LENGTH (NUMBER OF DIGITS) OF FORMATTED NUMBERS +INTEGER, PARAMETER :: DR16P = 42 !< NUMBER OF DIGITS OF OUTPUT FORMAT FR16P. +INTEGER, PARAMETER :: DR8P = 23 !< NUMBER OF DIGITS OF OUTPUT FORMAT FR8P. +INTEGER, PARAMETER :: DR4P = 13 !< NUMBER OF DIGITS OF OUTPUT FORMAT FR4P. +#if defined _R_P_IS_R16P +INTEGER, PARAMETER :: DR_P = DR16P !< NUMBER OF DIGITS OF OUTPUT FORMAT FR_P. +#elif defined _R_P_IS_R8P +INTEGER, PARAMETER :: DR_P = DR8P !< NUMBER OF DIGITS OF OUTPUT FORMAT FR_P. +#elif defined _R_P_IS_R4P +INTEGER, PARAMETER :: DR_P = DR4P !< NUMBER OF DIGITS OF OUTPUT FORMAT FR_P. +#else +INTEGER, PARAMETER :: DR_P = DR8P !< NUMBER OF DIGITS OF OUTPUT FORMAT FR_P. +#endif + +INTEGER, PARAMETER :: DI8P = 20 !< NUMBER OF DIGITS OF OUTPUT FORMAT I8P. +INTEGER, PARAMETER :: DI4P = 11 !< NUMBER OF DIGITS OF OUTPUT FORMAT I4P. +INTEGER, PARAMETER :: DI2P = 6 !< NUMBER OF DIGITS OF OUTPUT FORMAT I2P. +INTEGER, PARAMETER :: DI1P = 4 !< NUMBER OF DIGITS OF OUTPUT FORMAT I1P. +INTEGER, PARAMETER :: DI_P = DI4P !< NUMBER OF DIGITS OF OUTPUT FORMAT I_P. + +! LIST OF KINDS +INTEGER, PARAMETER :: CHARACTER_KINDS_LIST(1:3) = [ASCII, UCS4, CK] !< LIST OF CHARACTER KINDS. +INTEGER, PARAMETER :: REAL_KINDS_LIST(1:4) = [R16P, R8P, R4P, R_P] !< LIST OF REAL KINDS. +CHARACTER(*), PARAMETER :: REAL_FORMATS_LIST(1:4) = [FR16P, FR8P, FR4P//' ', FR_P] !< LIST OF REAL FORMATS. +INTEGER, PARAMETER :: INTEGER_KINDS_LIST(1:5) = [I8P, I4P, I2P, I1P,I_P] !< LIST OF INTEGER KINDS. +CHARACTER(*), PARAMETER :: INTEGER_FORMATS_LIST(1:5) = [FI8P, FI4P, FI2P//' ', FI1P//' ', FI_P] !< LIST OF INTEGER FORMATS. + +! MINIMUM AND MAXIMUM (REPRESENTABLE) VALUES +REAL(R16P), PARAMETER :: MINR16P = -HUGE(1._R16P) !< MINIMUM VALUE OF KIND=R16P REAL. +REAL(R16P), PARAMETER :: MAXR16P = HUGE(1._R16P) !< MAXIMUM VALUE OF KIND=R16P REAL. +REAL(R8P), PARAMETER :: MINR8P = -HUGE(1._R8P ) !< MINIMUM VALUE OF KIND=R8P REAL. +REAL(R8P), PARAMETER :: MAXR8P = HUGE(1._R8P ) !< MAXIMUM VALUE OF KIND=R8P REAL. +REAL(R4P), PARAMETER :: MINR4P = -HUGE(1._R4P ) !< MINIMUM VALUE OF KIND=R4P REAL. +REAL(R4P), PARAMETER :: MAXR4P = HUGE(1._R4P ) !< MAXIMUM VALUE OF KIND=R4P REAL. +REAL(R_P), PARAMETER :: MINR_P = -HUGE(1._R_P ) !< MINIMUM VALUE OF KIND=R_P REAL. +REAL(R_P), PARAMETER :: MAXR_P = HUGE(1._R_P ) !< MAXIMUM VALUE OF KIND=R_P REAL. +INTEGER(I8P), PARAMETER :: MINI8P = -HUGE(1_I8P) !< MINIMUM VALUE OF KIND=I8P INTEGER. +INTEGER(I4P), PARAMETER :: MINI4P = -HUGE(1_I4P) !< MINIMUM VALUE OF KIND=I4P INTEGER. +INTEGER(I2P), PARAMETER :: MINI2P = -HUGE(1_I2P) !< MINIMUM VALUE OF KIND=I2P INTEGER. +INTEGER(I1P), PARAMETER :: MINI1P = -HUGE(1_I1P) !< MINIMUM VALUE OF KIND=I1P INTEGER. +INTEGER(I_P), PARAMETER :: MINI_P = -HUGE(1_I_P) !< MINIMUM VALUE OF KIND=I_P INTEGER. +INTEGER(I8P), PARAMETER :: MAXI8P = HUGE(1_I8P) !< MAXIMUM VALUE OF KIND=I8P INTEGER. +INTEGER(I4P), PARAMETER :: MAXI4P = HUGE(1_I4P) !< MAXIMUM VALUE OF KIND=I4P INTEGER. +INTEGER(I2P), PARAMETER :: MAXI2P = HUGE(1_I2P) !< MAXIMUM VALUE OF KIND=I2P INTEGER. +INTEGER(I1P), PARAMETER :: MAXI1P = HUGE(1_I1P) !< MAXIMUM VALUE OF KIND=I1P INTEGER. +INTEGER(I_P), PARAMETER :: MAXI_P = HUGE(1_I_P) !< MAXIMUM VALUE OF KIND=I_P INTEGER. + +! REAL SMALLEST (REPRESENTABLE) VALUES +REAL(R16P), PARAMETER :: SMALLR16P = TINY(1._R16P) !< SMALLEST REPRESENTABLE VALUE OF KIND=R16P REAL. +REAL(R8P), PARAMETER :: SMALLR8P = TINY(1._R8P ) !< SMALLEST REPRESENTABLE VALUE OF KIND=R8P REAL. +REAL(R4P), PARAMETER :: SMALLR4P = TINY(1._R4P ) !< SMALLEST REPRESENTABLE VALUE OF KIND=R4P REAL. +REAL(R_P), PARAMETER :: SMALLR_P = TINY(1._R_P ) !< SMALLEST REPRESENTABLE VALUE OF KIND=R_P REAL. + +! SMALLEST REAL REPRESENTABLE DIFFERENCE BY THE RUNNING CALCULATOR +REAL(R16P), PARAMETER :: ZEROR16P = NEAREST(1._R16P, 1._R16P) - & + NEAREST(1._R16P,-1._R16P) !< SMALLEST REPRESENTABLE DIFFERENCE OF KIND=R16P REAL. +REAL(R8P), PARAMETER :: ZEROR8P = NEAREST(1._R8P, 1._R8P) - & + NEAREST(1._R8P,-1._R8P) !< SMALLEST REPRESENTABLE DIFFERENCE OF KIND=R8P REAL. +REAL(R4P), PARAMETER :: ZEROR4P = NEAREST(1._R4P, 1._R4P) - & + NEAREST(1._R4P,-1._R4P) !< SMALLEST REPRESENTABLE DIFFERENCE OF KIND=R4P REAL. +REAL(R_P), PARAMETER :: ZEROR_P = NEAREST(1._R_P, 1._R_P) - & + NEAREST(1._R_P,-1._R_P) !< SMALLEST REPRESENTABLE DIFFERENCE OF KIND=R_P REAL. + +! BITS/BYTES MEMORY REQUIREMENTS (REAL VARIABLES MUST BE COMPUTED AT RUNTIME) +INTEGER(I2P) :: BIR16P !< NUMBER OF BITS OF KIND=R16P REAL. +INTEGER(I1P) :: BIR8P !< NUMBER OF BITS OF KIND=R8P REAL. +INTEGER(I1P) :: BIR4P !< NUMBER OF BITS OF KIND=R4P REAL. +INTEGER(I1P) :: BIR_P !< NUMBER OF BITS OF KIND=R_P REAL. +INTEGER(I2P) :: BYR16P !< NUMBER OF BYTES OF KIND=R16P REAL. +INTEGER(I1P) :: BYR8P !< NUMBER OF BYTES OF KIND=R8P REAL. +INTEGER(I1P) :: BYR4P !< NUMBER OF BYTES OF KIND=R4P REAL. +INTEGER(I1P) :: BYR_P !< NUMBER OF BYTES OF KIND=R_P REAL. +INTEGER(I8P), PARAMETER :: BII8P = BIT_SIZE(MAXI8P) !< NUMBER OF BITS OF KIND=I8P INTEGER. +INTEGER(I4P), PARAMETER :: BII4P = BIT_SIZE(MAXI4P) !< NUMBER OF BITS OF KIND=I4P INTEGER. +INTEGER(I2P), PARAMETER :: BII2P = BIT_SIZE(MAXI2P) !< NUMBER OF BITS OF KIND=I2P INTEGER. +INTEGER(I1P), PARAMETER :: BII1P = BIT_SIZE(MAXI1P) !< NUMBER OF BITS OF KIND=I1P INTEGER. +INTEGER(I_P), PARAMETER :: BII_P = BIT_SIZE(MAXI_P) !< NUMBER OF BITS OF KIND=I_P INTEGER. +INTEGER(I8P), PARAMETER :: BYI8P = BIT_SIZE(MAXI8P)/8_I8P !< NUMBER OF BYTES OF KIND=I8P INTEGER. +INTEGER(I4P), PARAMETER :: BYI4P = BIT_SIZE(MAXI4P)/8_I4P !< NUMBER OF BYTES OF KIND=I4P INTEGER. +INTEGER(I2P), PARAMETER :: BYI2P = BIT_SIZE(MAXI2P)/8_I2P !< NUMBER OF BYTES OF KIND=I2P INTEGER. +INTEGER(I1P), PARAMETER :: BYI1P = BIT_SIZE(MAXI1P)/8_I1P !< NUMBER OF BYTES OF KIND=I1P INTEGER. +INTEGER(I_P), PARAMETER :: BYI_P = BIT_SIZE(MAXI_P)/8_I_P !< NUMBER OF BYTES OF KIND=I_P INTEGER. +ENDMODULE PENF_GLOBAL_PARAMETERS_VARIABLES + + + +!< PENF BIT/BYTE SIZE FUNCTIONS. + +MODULE PENF_B_SIZE +!< PENF BIT/BYTE SIZE FUNCTIONS. +USE PENF_GLOBAL_PARAMETERS_VARIABLES + +IMPLICIT NONE +PRIVATE +SAVE +PUBLIC :: BIT_SIZE, BYTE_SIZE + +INTERFACE BIT_SIZE + !< OVERLOADING OF THE INTRINSIC *BIT_SIZE* FUNCTION FOR COMPUTING THE NUMBER OF BITS OF (ALSO) REAL AND CHARACTER VARIABLES. + MODULE PROCEDURE & + BIT_SIZE_R16P, & + BIT_SIZE_R8P, & + BIT_SIZE_R4P, & + BIT_SIZE_CHR +ENDINTERFACE + +INTERFACE BYTE_SIZE + !< COMPUTE THE NUMBER OF BYTES OF A VARIABLE. + MODULE PROCEDURE & + BYTE_SIZE_I8P, & + BYTE_SIZE_I4P, & + BYTE_SIZE_I2P, & + BYTE_SIZE_I1P, & + BYTE_SIZE_R16P, & + BYTE_SIZE_R8P, & + BYTE_SIZE_R4P, & + BYTE_SIZE_CHR +ENDINTERFACE + +CONTAINS + ELEMENTAL FUNCTION BIT_SIZE_R16P(I) RESULT(BITS) + !< COMPUTE THE NUMBER OF BITS OF A REAL VARIABLE. + !< + !<```FORTRAN + !< USE PENF + !< PRINT FI2P, BIT_SIZE(1._R16P) + !<``` + !=> 128 <<< + REAL(R16P), INTENT(IN) :: I !< REAL VARIABLE WHOSE NUMBER OF BITS MUST BE COMPUTED. + INTEGER(I2P) :: BITS !< NUMBER OF BITS OF R. + INTEGER(I1P) :: MOLD(1) !< "MOLDING" DUMMY VARIABLE FOR BITS COUNTING. + + BITS = SIZE(TRANSFER(I, MOLD), DIM=1, KIND=I2P) * 8_I2P + ENDFUNCTION BIT_SIZE_R16P + + ELEMENTAL FUNCTION BIT_SIZE_R8P(I) RESULT(BITS) + !< COMPUTE THE NUMBER OF BITS OF A REAL VARIABLE. + !< + !<```FORTRAN + !< USE PENF + !< PRINT FI1P, BIT_SIZE(1._R8P) + !<``` + !=> 64 <<< + REAL(R8P), INTENT(IN) :: I !< REAL VARIABLE WHOSE NUMBER OF BITS MUST BE COMPUTED. + INTEGER(I1P) :: BITS !< NUMBER OF BITS OF R. + INTEGER(I1P) :: MOLD(1) !< "MOLDING" DUMMY VARIABLE FOR BITS COUNTING. + + BITS = SIZE(TRANSFER(I, MOLD), DIM=1, KIND=I1P) * 8_I1P + ENDFUNCTION BIT_SIZE_R8P + + ELEMENTAL FUNCTION BIT_SIZE_R4P(I) RESULT(BITS) + !< COMPUTE THE NUMBER OF BITS OF A REAL VARIABLE. + !< + !<```FORTRAN + !< USE PENF + !< PRINT FI1P, BIT_SIZE(1._R4P) + !<``` + !=> 32 <<< + REAL(R4P), INTENT(IN) :: I !< REAL VARIABLE WHOSE NUMBER OF BITS MUST BE COMPUTED. + INTEGER(I1P) :: BITS !< NUMBER OF BITS OF R. + INTEGER(I1P) :: MOLD(1) !< "MOLDING" DUMMY VARIABLE FOR BITS COUNTING. + + BITS = SIZE(TRANSFER(I, MOLD), DIM=1, KIND=I1P) * 8_I1P + ENDFUNCTION BIT_SIZE_R4P + + ELEMENTAL FUNCTION BIT_SIZE_CHR(I) RESULT(BITS) + !< COMPUTE THE NUMBER OF BITS OF A CHARACTER VARIABLE. + !< + !<```FORTRAN + !< USE PENF + !< PRINT FI4P, BIT_SIZE('AB') + !<``` + !=> 16 <<< + CHARACTER(*), INTENT(IN) :: I !< CHARACTER VARIABLE WHOSE NUMBER OF BITS MUST BE COMPUTED. + INTEGER(I4P) :: BITS !< NUMBER OF BITS OF C. + INTEGER(I1P) :: MOLD(1) !< "MOLDING" DUMMY VARIABLE FOR BITS COUNTING. + + BITS = SIZE(TRANSFER(I, MOLD), DIM=1, KIND=I4P) * 8_I4P + ENDFUNCTION BIT_SIZE_CHR + + ELEMENTAL FUNCTION BYTE_SIZE_R16P(I) RESULT(BYTES) + !< COMPUTE THE NUMBER OF BYTES OF A REAL VARIABLE. + !< + !<```FORTRAN + !< USE PENF + !< PRINT FI1P, BYTE_SIZE(1._R16P) + !<``` + !=> 16 <<< + REAL(R16P), INTENT(IN) :: I !< REAL VARIABLE WHOSE NUMBER OF BYTES MUST BE COMPUTED. + INTEGER(I1P) :: BYTES !< NUMBER OF BYTES OF R. + + BYTES = BIT_SIZE(I) / 8_I1P + ENDFUNCTION BYTE_SIZE_R16P + + ELEMENTAL FUNCTION BYTE_SIZE_R8P(I) RESULT(BYTES) + !< COMPUTE THE NUMBER OF BYTES OF A REAL VARIABLE. + !< + !<```FORTRAN + !< USE PENF + !< PRINT FI1P, BYTE_SIZE(1._R8P) + !<``` + !=> 8 <<< + REAL(R8P), INTENT(IN) :: I !< REAL VARIABLE WHOSE NUMBER OF BYTES MUST BE COMPUTED. + INTEGER(I1P) :: BYTES !< NUMBER OF BYTES OF R. + + BYTES = BIT_SIZE(I) / 8_I1P + ENDFUNCTION BYTE_SIZE_R8P + + ELEMENTAL FUNCTION BYTE_SIZE_R4P(I) RESULT(BYTES) + !< COMPUTE THE NUMBER OF BYTES OF A REAL VARIABLE. + !< + !<```FORTRAN + !< USE PENF + !< PRINT FI1P, BYTE_SIZE(1._R4P) + !<``` + !=> 4 <<< + REAL(R4P), INTENT(IN) :: I !< REAL VARIABLE WHOSE NUMBER OF BYTES MUST BE COMPUTED. + INTEGER(I1P) :: BYTES !< NUMBER OF BYTES OF R. + + BYTES = BIT_SIZE(I) / 8_I1P + ENDFUNCTION BYTE_SIZE_R4P + + ELEMENTAL FUNCTION BYTE_SIZE_CHR(I) RESULT(BYTES) + !< COMPUTE THE NUMBER OF BYTES OF A CHARACTER VARIABLE. + !< + !<```FORTRAN + !< USE PENF + !< PRINT FI1P, BYTE_SIZE('AB') + !<``` + !=> 2 <<< + CHARACTER(*), INTENT(IN) :: I !< CHARACTER VARIABLE WHOSE NUMBER OF BYTES MUST BE COMPUTED. + INTEGER(I4P) :: BYTES !< NUMBER OF BYTES OF C. + + BYTES = BIT_SIZE(I) / 8_I4P + ENDFUNCTION BYTE_SIZE_CHR + + ELEMENTAL FUNCTION BYTE_SIZE_I8P(I) RESULT(BYTES) + !< COMPUTE THE NUMBER OF BYTES OF AN INTEGER VARIABLE. + !< + !<```FORTRAN + !< USE PENF + !< PRINT FI1P, BYTE_SIZE(1_I8P) + !<``` + !=> 8 <<< + INTEGER(I8P), INTENT(IN) :: I !< INTEGER VARIABLE WHOSE NUMBER OF BYTES MUST BE COMPUTED. + INTEGER(I1P) :: BYTES !< NUMBER OF BYTES OF I. + + BYTES = BIT_SIZE(I) / 8_I1P + ENDFUNCTION BYTE_SIZE_I8P + + ELEMENTAL FUNCTION BYTE_SIZE_I4P(I) RESULT(BYTES) + !< COMPUTE THE NUMBER OF BYTES OF AN INTEGER VARIABLE. + !< + !<```FORTRAN + !< USE PENF + !< PRINT FI1P, BYTE_SIZE(1_I4P) + !<``` + !=> 4 <<< + INTEGER(I4P), INTENT(IN) :: I !< INTEGER VARIABLE WHOSE NUMBER OF BYTES MUST BE COMPUTED. + INTEGER(I1P) :: BYTES !< NUMBER OF BYTES OF I. + + BYTES = BIT_SIZE(I) / 8_I1P + ENDFUNCTION BYTE_SIZE_I4P + + ELEMENTAL FUNCTION BYTE_SIZE_I2P(I) RESULT(BYTES) + !< COMPUTE THE NUMBER OF BYTES OF AN INTEGER VARIABLE. + !< + !<```FORTRAN + !< USE PENF + !< PRINT FI1P, BYTE_SIZE(1_I2P) + !<``` + !=> 2 <<< + INTEGER(I2P), INTENT(IN) :: I !< INTEGER VARIABLE WHOSE NUMBER OF BYTES MUST BE COMPUTED. + INTEGER(I1P) :: BYTES !< NUMBER OF BYTES OF I. + + BYTES = BIT_SIZE(I) / 8_I1P + ENDFUNCTION BYTE_SIZE_I2P + + ELEMENTAL FUNCTION BYTE_SIZE_I1P(I) RESULT(BYTES) + !< COMPUTE THE NUMBER OF BYTES OF AN INTEGER VARIABLE. + !< + !<```FORTRAN + !< USE PENF + !< PRINT FI1P, BYTE_SIZE(1_I1P) + !<``` + !=> 1 <<< + INTEGER(I1P), INTENT(IN) :: I !< INTEGER VARIABLE WHOSE NUMBER OF BYTES MUST BE COMPUTED. + INTEGER(I1P) :: BYTES !< NUMBER OF BYTES OF I. + + BYTES = BIT_SIZE(I) / 8_I1P + ENDFUNCTION BYTE_SIZE_I1P +ENDMODULE PENF_B_SIZE + + +!< PENF STRING-TO-NUMBER (AND VICEVERSA) FACILITY. + +MODULE PENF_STRINGIFY +!< PENF STRING-TO-NUMBER (AND VICEVERSA) FACILITY. +USE, INTRINSIC :: ISO_FORTRAN_ENV, ONLY : STDERR=>ERROR_UNIT +USE PENF_B_SIZE +USE PENF_GLOBAL_PARAMETERS_VARIABLES + +IMPLICIT NONE +PRIVATE +SAVE +PUBLIC :: STR_ASCII, STR_UCS4 +PUBLIC :: STR, STRZ, CTON +PUBLIC :: BSTR, BCTON + +INTERFACE STR_ASCII + !< CONVERT STRING OF ANY KIND TO ASCII STRING. + MODULE PROCEDURE STR_ASCII_DEFAULT +#if defined _ASCII_SUPPORTED && defined _ASCII_NEQ_DEFAULT + MODULE PROCEDURE STR_ASCII_ASCII +#endif +#ifdef _UCS4_SUPPORTED + MODULE PROCEDURE STR_ASCII_UCS4 +#endif +ENDINTERFACE + +INTERFACE STR_UCS4 + !< CONVERT STRING OF ANY KIND TO UCS4 STRING. + MODULE PROCEDURE STR_UCS4_DEFAULT +#if defined _ASCII_SUPPORTED && defined _ASCII_NEQ_DEFAULT + MODULE PROCEDURE STR_UCS4_ASCII +#endif +#ifdef _UCS4_SUPPORTED + MODULE PROCEDURE STR_UCS4_UCS4 +#endif +ENDINTERFACE + +INTERFACE STR + !< CONVERT NUMBER (REAL AND INTEGER) TO STRING (NUMBER TO STRING TYPE CASTING). + MODULE PROCEDURE & + STRF_R16P,STR_R16P, & + STRF_R8P ,STR_R8P, & + STRF_R4P ,STR_R4P, & + STRF_I8P ,STR_I8P, & + STRF_I4P ,STR_I4P, & + STRF_I2P ,STR_I2P, & + STRF_I1P ,STR_I1P, & + STR_BOL, & + STR_A_R16P, & + STR_A_R8P, & + STR_A_R4P, & + STR_A_I8P, & + STR_A_I4P, & + STR_A_I2P, & + STR_A_I1P +ENDINTERFACE + +INTERFACE STRZ + !< CONVERT INTEGER, TO STRING, PREFIXING WITH THE RIGHT NUMBER OF ZEROS (INTEGER TO STRING TYPE CASTING WITH ZERO PADDING). + MODULE PROCEDURE STRZ_I8P, STRZ_I4P, STRZ_I2P, STRZ_I1P +ENDINTERFACE + +INTERFACE CTON + !< CONVERT STRING TO NUMBER (REAL AND INTEGER, STRING TO NUMBER TYPE CASTING). + MODULE PROCEDURE & + CTOR_R16P, & + CTOR_R8P, & + CTOR_R4P, & + CTOI_I8P, & + CTOI_I4P, & + CTOI_I2P, & + CTOI_I1P +ENDINTERFACE + +INTERFACE BSTR + !< CONVERT NUMBER (REAL AND INTEGER) TO BIT-STRING (NUMBER TO BIT-STRING TYPE CASTING). + MODULE PROCEDURE & + BSTR_R16P, & + BSTR_R8P, & + BSTR_R4P, & + BSTR_I8P, & + BSTR_I4P, & + BSTR_I2P, & + BSTR_I1P +ENDINTERFACE + +INTERFACE BCTON + !< CONVERT BIT-STRING TO NUMBER (REAL AND INTEGER, BIT-STRING TO NUMBER TYPE CASTING). + MODULE PROCEDURE & + BCTOR_R16P, & + BCTOR_R8P, & + BCTOR_R4P, & + BCTOI_I8P, & + BCTOI_I4P, & + BCTOI_I2P, & + BCTOI_I1P +ENDINTERFACE + +CONTAINS + PURE FUNCTION STR_ASCII_DEFAULT(INPUT) RESULT(OUTPUT) + !< CONVERT STRING OF DEFAULT KIND TO ASCII STRING. + !< + !<```FORTRAN + !< USE PENF + !< CHARACTER(LEN=:, KIND=ASCII), ALLOCATABLE :: STRING + !< STRING = STR_ASCII('I WAS DEFAULT KIND, BUT NOW I AM ASCII') + !< PRINT "(A)", STRING + !<``` + !=> I WAS DEFAULT KIND, BUT NOW I AM ASCII <<< + CHARACTER(LEN=*), INTENT(IN) :: INPUT !< INPUT STRING OF DEFAULT KIND. + CHARACTER(LEN=:, KIND=ASCII), ALLOCATABLE :: OUTPUT !< OUTPUT STRING OF ASCII KIND. + + OUTPUT = INPUT + ENDFUNCTION STR_ASCII_DEFAULT + + PURE FUNCTION STR_ASCII_ASCII(INPUT) RESULT(OUTPUT) + !< CONVERT STRING OF ASCII KIND TO ASCII STRING, JUST FOR CONVENIENCE IN SANITIZE STRINGS. + !< + !<```FORTRAN + !< USE PENF + !< CHARACTER(LEN=:, KIND=ASCII), ALLOCATABLE :: STRING + !< STRING = STR_ASCII('I WAS ASCII KIND AND I AM STILL ASCII') + !< PRINT "(A)", STRING + !<``` + !=> I WAS ASCII KIND AND I AM STILL ASCII <<< + CHARACTER(LEN=*, KIND=ASCII), INTENT(IN) :: INPUT !< INPUT STRING OF ASCII KIND. + CHARACTER(LEN=:, KIND=ASCII), ALLOCATABLE :: OUTPUT !< OUTPUT STRING OF ASCII KIND. + + OUTPUT = INPUT + ENDFUNCTION STR_ASCII_ASCII + + PURE FUNCTION STR_ASCII_UCS4(INPUT) RESULT(OUTPUT) + !< CONVERT STRING OF UCS4 KIND TO ASCII STRING. + !< + !<```FORTRAN + !< USE PENF + !< CHARACTER(LEN=:, KIND=ASCII), ALLOCATABLE :: STRING + !< STRING = STR_ASCII(UCS4_'I WAS UCS4 KIND, BUT NOW I AM ASCII') + !< PRINT "(A)", STRING + !<``` + !=> I WAS UCS4 KIND, BUT NOW I AM ASCII <<< + CHARACTER(LEN=*, KIND=UCS4), INTENT(IN) :: INPUT !< INPUT STRING OF UCS4 KIND. + CHARACTER(LEN=:, KIND=ASCII), ALLOCATABLE :: OUTPUT !< OUTPUT STRING OF ASCII KIND. + + OUTPUT = INPUT + ENDFUNCTION STR_ASCII_UCS4 + + PURE FUNCTION STR_UCS4_DEFAULT(INPUT) RESULT(OUTPUT) + !< CONVERT STRING OF DEFAULT KIND TO UCS4 STRING. + !< + !<```FORTRAN + !< USE PENF + !< CHARACTER(LEN=:, KIND=UCS4), ALLOCATABLE :: STRING + !< STRING = STR_ASCII('I WAS DEFAULT KIND, BUT NOW I AM UCS4') + !< PRINT "(A)", STRING + !<``` + !=> I WAS DEFAULT KIND, BUT NOW I AM UCS4 <<< + CHARACTER(LEN=*), INTENT(IN) :: INPUT !< INPUT STRING OF DEFAULT KIND. + CHARACTER(LEN=:, KIND=UCS4), ALLOCATABLE :: OUTPUT !< OUTPUT STRING OF UCS4 KIND. + + OUTPUT = INPUT + ENDFUNCTION STR_UCS4_DEFAULT + + PURE FUNCTION STR_UCS4_ASCII(INPUT) RESULT(OUTPUT) + !< CONVERT STRING OF ASCII KIND TO UCS4 STRING. + !< + !<```FORTRAN + !< USE PENF + !< CHARACTER(LEN=:, KIND=UCS4), ALLOCATABLE :: STRING + !< STRING = STR_ASCII(ASCII_'I WAS ASCII KIND, BUT NOW I AM UCS4') + !< PRINT "(A)", STRING + !<``` + !=> I WAS ASCII KIND, BUT NOW I AM UCS4 <<< + CHARACTER(LEN=*, KIND=ASCII), INTENT(IN) :: INPUT !< INPUT STRING OF ASCII KIND. + CHARACTER(LEN=:, KIND=UCS4), ALLOCATABLE :: OUTPUT !< OUTPUT STRING OF UCS4 KIND. + + OUTPUT = INPUT + ENDFUNCTION STR_UCS4_ASCII + + PURE FUNCTION STR_UCS4_UCS4(INPUT) RESULT(OUTPUT) + !< CONVERT STRING OF UCS4 KIND TO UCS4 STRING, JUST FOR CONVENIENCE IN SANITIZE STRINGS. + !< + !<```FORTRAN + !< USE PENF + !< CHARACTER(LEN=:, KIND=UCS4), ALLOCATABLE :: STRING + !< STRING = STR_ASCII(UCS4_'I WAS UCS4 KIND AND I AM STILL UCS4') + !< PRINT "(A)", STRING + !<``` + !=> I WAS UCS4 KIND AND I AM STILL UCS4 <<< + CHARACTER(LEN=*, KIND=UCS4), INTENT(IN) :: INPUT !< INPUT STRING OF UCS4 KIND. + CHARACTER(LEN=:, KIND=UCS4), ALLOCATABLE :: OUTPUT !< OUTPUT STRING OF UCS4 KIND. + + OUTPUT = INPUT + ENDFUNCTION STR_UCS4_UCS4 + + ELEMENTAL FUNCTION STRF_R16P(FM, N) RESULT(STR) + !< CONVERT REAL TO STRING. + !< + !<```FORTRAN + !< USE PENF + !< PRINT "(A)", STR(FM=FR16P, N=1._R16P) + !<``` + !=> 0.100000000000000000000000000000000E+0001 <<< + CHARACTER(*), INTENT(IN) :: FM !< FORMAT DIFFERENT FROM THE STANDARD FOR THE KIND. + REAL(R16P), INTENT(IN) :: N !< REAL TO BE CONVERTED. + CHARACTER(DR16P) :: STR !< RETURNED STRING CONTAINING INPUT NUMBER. + + WRITE(STR, TRIM(FM)) N + ENDFUNCTION STRF_R16P + + ELEMENTAL FUNCTION STRF_R8P(FM, N) RESULT(STR) + !< CONVERT REAL TO STRING. + !< + !<```FORTRAN + !< USE PENF + !< PRINT "(A)", STR(FM=FR8P, N=1._R8P) + !<``` + !=> 0.100000000000000E+001 <<< + CHARACTER(*), INTENT(IN) :: FM !< FORMAT DIFFERENT FROM THE STANDARD FOR THE KIND. + REAL(R8P), INTENT(IN) :: N !< REAL TO BE CONVERTED. + CHARACTER(DR8P) :: STR !< RETURNED STRING CONTAINING INPUT NUMBER. + + WRITE(STR, TRIM(FM)) N + ENDFUNCTION STRF_R8P + + ELEMENTAL FUNCTION STRF_R4P(FM, N) RESULT(STR) + !< CONVERT REAL TO STRING. + !< + !<```FORTRAN + !< USE PENF + !< PRINT "(A)", STR(FM=FR4P, N=1._R4P) + !<``` + !=> 0.100000E+01 <<< + CHARACTER(*), INTENT(IN) :: FM !< FORMAT DIFFERENT FROM THE STANDARD FOR THE KIND. + REAL(R4P), INTENT(IN) :: N !< REAL TO BE CONVERTED. + CHARACTER(DR4P) :: STR !< RETURNED STRING CONTAINING INPUT NUMBER. + + WRITE(STR, TRIM(FM)) N + ENDFUNCTION STRF_R4P + + ELEMENTAL FUNCTION STRF_I8P(FM, N) RESULT(STR) + !< CONVERT INTEGER TO STRING. + !< + !<```FORTRAN + !< USE PENF + !< PRINT "(A)", STR(FM=FI8P, N=1_I8P) + !<``` + !=> 1 <<< + CHARACTER(*), INTENT(IN) :: FM !< FORMAT DIFFERENT FROM THE STANDARD FOR THE KIND. + INTEGER(I8P), INTENT(IN) :: N !< INTEGER TO BE CONVERTED. + CHARACTER(DI8P) :: STR !< RETURNED STRING CONTAINING INPUT NUMBER. + + WRITE(STR, TRIM(FM)) N + ENDFUNCTION STRF_I8P + + ELEMENTAL FUNCTION STRF_I4P(FM, N) RESULT(STR) + !< CONVERT INTEGER TO STRING. + !< + !<```FORTRAN + !< USE PENF + !< PRINT "(A)", STR(FM=FI4P, N=1_I4P) + !<``` + !=> 1 <<< + CHARACTER(*), INTENT(IN) :: FM !< FORMAT DIFFERENT FROM THE STANDARD FOR THE KIND. + INTEGER(I4P), INTENT(IN) :: N !< INTEGER TO BE CONVERTED. + CHARACTER(DI4P) :: STR !< RETURNED STRING CONTAINING INPUT NUMBER. + + WRITE(STR, TRIM(FM)) N + ENDFUNCTION STRF_I4P + + ELEMENTAL FUNCTION STRF_I2P(FM, N) RESULT(STR) + !< CONVERT INTEGER TO STRING. + !< + !<```FORTRAN + !< USE PENF + !< PRINT "(A)", STR(FM=FI2P, N=1_I2P) + !<``` + !=> 1 <<< + CHARACTER(*), INTENT(IN) :: FM !< FORMAT DIFFERENT FROM THE STANDARD FOR THE KIND. + INTEGER(I2P), INTENT(IN) :: N !< INTEGER TO BE CONVERTED. + CHARACTER(DI2P) :: STR !< RETURNED STRING CONTAINING INPUT NUMBER. + + WRITE(STR, TRIM(FM)) N + ENDFUNCTION STRF_I2P + + ELEMENTAL FUNCTION STRF_I1P(FM, N) RESULT(STR) + !< CONVERT INTEGER TO STRING. + !< + !<```FORTRAN + !< USE PENF + !< PRINT "(A)", STR(FM=FI1P, N=1_I1P) + !<``` + !=> 1 <<< + CHARACTER(*), INTENT(IN) :: FM !< FORMAT DIFFERENT FROM THE STANDARD FOR THE KIND. + INTEGER(I1P), INTENT(IN) :: N !< INTEGER TO BE CONVERTED. + CHARACTER(DI1P) :: STR !< RETURNED STRING CONTAINING INPUT NUMBER. + + WRITE(STR, TRIM(FM)) N + ENDFUNCTION STRF_I1P + + ELEMENTAL FUNCTION STR_R16P(N, NO_SIGN, COMPACT) RESULT(STR) + !< CONVERT REAL TO STRING. + !< + !<```FORTRAN + !< USE PENF + !< PRINT "(A)", STR(N=-1._R16P) + !<``` + !=> -0.100000000000000000000000000000000E+0001 <<< + !< + !<```FORTRAN + !< USE PENF + !< PRINT "(A)", STR(N=-1._R16P, NO_SIGN=.TRUE.) + !<``` + !=> 0.100000000000000000000000000000000E+0001 <<< + !< + !<```FORTRAN + !< USE PENF + !< PRINT "(A)", STR(N=-1._R16P, COMPACT=.TRUE.) + !<``` + !=> -0.1E+1 <<< + REAL(R16P), INTENT(IN) :: N !< REAL TO BE CONVERTED. + LOGICAL, INTENT(IN), OPTIONAL :: NO_SIGN !< FLAG FOR LEAVING OUT THE SIGN. + LOGICAL, INTENT(IN), OPTIONAL :: COMPACT !< FLAG FOR *COMPACTING* STRING ENCODING. + CHARACTER(DR16P) :: STR !< RETURNED STRING CONTAINING INPUT NUMBER. + + WRITE(STR, FR16P) N ! CASTING OF N TO STRING. + IF (N>0._R16P) STR(1:1)='+' ! PREFIXING PLUS IF N>0. + IF (PRESENT(NO_SIGN)) STR=STR(2:) ! LEAVING OUT THE SIGN. + IF (PRESENT(COMPACT)) THEN + IF (COMPACT) CALL COMPACT_REAL_STRING(STRING=STR) + ENDIF + ENDFUNCTION STR_R16P + + ELEMENTAL FUNCTION STR_R8P(N, NO_SIGN, COMPACT) RESULT(STR) + !< CONVERT REAL TO STRING. + !< + !<```FORTRAN + !< USE PENF + !< PRINT "(A)", STR(N=-1._R8P) + !<``` + !=> -0.100000000000000E+001 <<< + !< + !<```FORTRAN + !< USE PENF + !< PRINT "(A)", STR(N=-1._R8P, NO_SIGN=.TRUE.) + !<``` + !=> 0.100000000000000E+001 <<< + !< + !<```FORTRAN + !< USE PENF + !< PRINT "(A)", STR(N=-1._R8P, COMPACT=.TRUE.) + !<``` + !=> -0.1E+1 <<< + REAL(R8P), INTENT(IN) :: N !< REAL TO BE CONVERTED. + LOGICAL, INTENT(IN), OPTIONAL :: NO_SIGN !< FLAG FOR LEAVING OUT THE SIGN. + LOGICAL, INTENT(IN), OPTIONAL :: COMPACT !< FLAG FOR *COMPACTING* STRING ENCODING. + CHARACTER(DR8P) :: STR !< RETURNED STRING CONTAINING INPUT NUMBER. + + WRITE(STR, FR8P) N ! CASTING OF N TO STRING. + IF (N>0._R8P) STR(1:1)='+' ! PREFIXING PLUS IF N>0. + IF (PRESENT(NO_SIGN)) STR=STR(2:) ! LEAVING OUT THE SIGN. + IF (PRESENT(COMPACT)) THEN + IF (COMPACT) CALL COMPACT_REAL_STRING(STRING=STR) + ENDIF + ENDFUNCTION STR_R8P + + ELEMENTAL FUNCTION STR_R4P(N, NO_SIGN, COMPACT) RESULT(STR) + !< CONVERT REAL TO STRING. + !< + !<```FORTRAN + !< USE PENF + !< PRINT "(A)", STR(N=-1._R4P) + !<``` + !=> -0.100000E+01 <<< + !< + !<```FORTRAN + !< USE PENF + !< PRINT "(A)", STR(N=-1._R4P, NO_SIGN=.TRUE.) + !<``` + !=> 0.100000E+01 <<< + !< + !<```FORTRAN + !< USE PENF + !< PRINT "(A)", STR(N=-1._R4P, COMPACT=.TRUE.) + !<``` + !=> -0.1E+1 <<< + REAL(R4P), INTENT(IN) :: N !< REAL TO BE CONVERTED. + LOGICAL, INTENT(IN), OPTIONAL :: NO_SIGN !< FLAG FOR LEAVING OUT THE SIGN. + LOGICAL, INTENT(IN), OPTIONAL :: COMPACT !< FLAG FOR *COMPACTING* STRING ENCODING. + CHARACTER(DR4P) :: STR !< RETURNED STRING CONTAINING INPUT NUMBER. + + WRITE(STR, FR4P) N ! CASTING OF N TO STRING. + IF (N>0._R4P) STR(1:1)='+' ! PREFIXING PLUS IF N>0. + IF (PRESENT(NO_SIGN)) STR=STR(2:) ! LEAVING OUT THE SIGN. + IF (PRESENT(COMPACT)) THEN + IF (COMPACT) CALL COMPACT_REAL_STRING(STRING=STR) + ENDIF + ENDFUNCTION STR_R4P + + ELEMENTAL FUNCTION STR_I8P(N, NO_SIGN) RESULT(STR) + !< CONVERT INTEGER TO STRING. + !< + !<```FORTRAN + !< USE PENF + !< PRINT "(A)", STR(N=-1_I8P) + !<``` + !=> -1 <<< + !< + !<```FORTRAN + !< USE PENF + !< PRINT "(A)", STR(N=-1_I8P, NO_SIGN=.TRUE.) + !<``` + !=> 1 <<< + INTEGER(I8P), INTENT(IN) :: N !< INTEGER TO BE CONVERTED. + LOGICAL, INTENT(IN), OPTIONAL :: NO_SIGN !< FLAG FOR LEAVING OUT THE SIGN. + CHARACTER(DI8P) :: STR !< RETURNED STRING CONTAINING INPUT NUMBER PLUS PADDING ZEROS. + + WRITE(STR, FI8P) N ! CASTING OF N TO STRING. + STR = ADJUSTL(TRIM(STR)) ! REMOVING WHITE SPACES. + IF (N>=0_I8P) STR='+'//TRIM(STR) ! PREFIXING PLUS IF N>0. + IF (PRESENT(NO_SIGN)) STR=STR(2:) ! LEAVING OUT THE SIGN. + ENDFUNCTION STR_I8P + + ELEMENTAL FUNCTION STR_I4P(N, NO_SIGN) RESULT(STR) + !< CONVERTING INTEGER TO STRING. + !< + !<```FORTRAN + !< USE PENF + !< PRINT "(A)", STR(N=-1_I4P) + !<``` + !=> -1 <<< + !< + !<```FORTRAN + !< USE PENF + !< PRINT "(A)", STR(N=-1_I4P, NO_SIGN=.TRUE.) + !<``` + !=> 1 <<< + INTEGER(I4P), INTENT(IN) :: N !< INTEGER TO BE CONVERTED. + LOGICAL, INTENT(IN), OPTIONAL :: NO_SIGN !< FLAG FOR LEAVING OUT THE SIGN. + CHARACTER(DI4P) :: STR !< RETURNED STRING CONTAINING INPUT NUMBER PLUS PADDING ZEROS. + + WRITE(STR, FI4P) N ! CASTING OF N TO STRING. + STR = ADJUSTL(TRIM(STR)) ! REMOVING WHITE SPACES. + IF (N>=0_I4P) STR='+'//TRIM(STR) ! PREFIXING PLUS IF N>0. + IF (PRESENT(NO_SIGN)) STR=STR(2:) ! LEAVING OUT THE SIGN. + ENDFUNCTION STR_I4P + + ELEMENTAL FUNCTION STR_I2P(N, NO_SIGN) RESULT(STR) + !< CONVERT INTEGER TO STRING. + !< + !<```FORTRAN + !< USE PENF + !< PRINT "(A)", STR(N=-1_I2P) + !<``` + !=> -1 <<< + !< + !<```FORTRAN + !< USE PENF + !< PRINT "(A)", STR(N=-1_I2P, NO_SIGN=.TRUE.) + !<``` + !=> 1 <<< + INTEGER(I2P), INTENT(IN) :: N !< INTEGER TO BE CONVERTED. + LOGICAL, INTENT(IN), OPTIONAL :: NO_SIGN !< FLAG FOR LEAVING OUT THE SIGN. + CHARACTER(DI2P) :: STR !< RETURNED STRING CONTAINING INPUT NUMBER PLUS PADDING ZEROS. + + WRITE(STR, FI2P) N ! CASTING OF N TO STRING. + STR = ADJUSTL(TRIM(STR)) ! REMOVING WHITE SPACES. + IF (N>=0_I2P) STR='+'//TRIM(STR) ! PREFIXING PLUS IF N>0. + IF (PRESENT(NO_SIGN)) STR=STR(2:) ! LEAVING OUT THE SIGN. + ENDFUNCTION STR_I2P + + ELEMENTAL FUNCTION STR_I1P(N, NO_SIGN) RESULT(STR) + !< CONVERT INTEGER TO STRING. + !< + !<```FORTRAN + !< USE PENF + !< PRINT "(A)", STR(N=-1_I1P) + !<``` + !=> -1 <<< + !< + !<```FORTRAN + !< USE PENF + !< PRINT "(A)", STR(N=-1_I1P, NO_SIGN=.TRUE.) + !<``` + !=> 1 <<< + INTEGER(I1P), INTENT(IN) :: N !< INTEGER TO BE CONVERTED. + LOGICAL, INTENT(IN), OPTIONAL :: NO_SIGN !< FLAG FOR LEAVING OUT THE SIGN. + CHARACTER(DI1P) :: STR !< RETURNED STRING CONTAINING INPUT NUMBER PLUS PADDING ZEROS. + + WRITE(STR, FI1P) N ! CASTING OF N TO STRING. + STR = ADJUSTL(TRIM(STR)) ! REMOVING WHITE SPACES. + IF (N>=0_I1P) STR='+'//TRIM(STR) ! PREFIXING PLUS IF N>0. + IF (PRESENT(NO_SIGN)) STR=STR(2:) ! LEAVING OUT THE SIGN. + ENDFUNCTION STR_I1P + + ELEMENTAL FUNCTION STR_BOL(N) RESULT(STR) + !< CONVERT LOGICAL TO STRING. + !< + !<```FORTRAN + !< USE PENF + !< PRINT "(A)", STR(N=.TRUE.) + !<``` + !=> T <<< + LOGICAL, INTENT(IN):: N !< LOGICAL TO BE CONVERTED. + CHARACTER(1):: STR !< RETURNED STRING CONTAINING INPUT NUMBER PLUS PADDING ZEROS. + + WRITE(STR, '(L1)') N + ENDFUNCTION STR_BOL + + PURE FUNCTION STR_A_R16P(N, NO_SIGN, SEPARATOR, DELIMITERS, COMPACT) RESULT(STR) + !< CONVERTING REAL ARRAY TO STRING. + !< + !<```FORTRAN + !< USE PENF + !< PRINT "(A)", STR(N=[1._R16P, -2._R16P]) + !<``` + !=> +0.100000000000000000000000000000000E+0001,-0.200000000000000000000000000000000E+0001 <<< + !< + !<```FORTRAN + !< USE PENF + !< PRINT "(A)", STR(N=[1._R16P, 2._R16P], NO_SIGN=.TRUE.) + !<``` + !=> 0.100000000000000000000000000000000E+0001,0.200000000000000000000000000000000E+0001 <<< + !< + !<```FORTRAN + !< USE PENF + !< PRINT "(A)", STR(N=[1._R16P, -2._R16P], SEPARATOR='|') + !<``` + !=> +0.100000000000000000000000000000000E+0001|-0.200000000000000000000000000000000E+0001 <<< + !< + !<```FORTRAN + !< USE PENF + !< PRINT "(A)", STR(N=[1._R16P, -2._R16P], DELIMITERS=['(', ')']) + !<``` + !=> (+0.100000000000000000000000000000000E+0001,-0.200000000000000000000000000000000E+0001) <<< + !< + !<```FORTRAN + !< USE PENF + !< PRINT "(A)", STR(N=[1._R16P, -2._R16P], COMPACT=.TRUE.) + !<``` + !=> +0.1E+1,-0.2E+1 <<< + REAL(R16P), INTENT(IN) :: N(:) !< REAL ARRAY TO BE CONVERTED. + LOGICAL, INTENT(IN), OPTIONAL :: NO_SIGN !< FLAG FOR LEAVING OUT THE SIGN. + CHARACTER(1), INTENT(IN), OPTIONAL :: SEPARATOR !< EVENTUAL SEPARATOR OF ARRAY VALUES. + CHARACTER(*), INTENT(IN), OPTIONAL :: DELIMITERS(1:2) !< EVENTUAL DELIMITERS OF ARRAY VALUES. + LOGICAL, INTENT(IN), OPTIONAL :: COMPACT !< FLAG FOR *COMPACTING* STRING ENCODING. + CHARACTER(LEN=:), ALLOCATABLE :: STR !< RETURNED STRING CONTAINING INPUT NUMBER. + CHARACTER(DR16P) :: STRN !< STRING CONTAINING OF ELEMENT OF INPUT ARRAY NUMBER. + CHARACTER(LEN=1) :: SEP !< ARRAY VALUES SEPARATOR + INTEGER :: I !< COUNTER. + + STR = '' + SEP = ',' + IF(PRESENT(SEPARATOR)) SEP = SEPARATOR + DO I=1,SIZE(N) + STRN = STR_R16P(NO_SIGN=NO_SIGN, COMPACT=COMPACT, N=N(I)) + STR = STR//SEP//TRIM(STRN) + ENDDO + STR = TRIM(STR(2:)) + IF (PRESENT(DELIMITERS)) STR = DELIMITERS(1)//STR//DELIMITERS(2) + ENDFUNCTION STR_A_R16P + + PURE FUNCTION STR_A_R8P(N, NO_SIGN, SEPARATOR, DELIMITERS, COMPACT) RESULT(STR) + !< CONVERT REAL ARRAY TO STRING. + !< + !<```FORTRAN + !< USE PENF + !< PRINT "(A)", STR(N=[1._R8P, -2._R8P]) + !<``` + !=> +0.100000000000000E+001,-0.200000000000000E+001 <<< + !< + !<```FORTRAN + !< USE PENF + !< PRINT "(A)", STR(N=[1._R8P, 2._R8P], NO_SIGN=.TRUE.) + !<``` + !=> 0.100000000000000E+001,0.200000000000000E+001 <<< + !< + !<```FORTRAN + !< USE PENF + !< PRINT "(A)", STR(N=[1._R8P, -2._R8P], SEPARATOR='|') + !<``` + !=> +0.100000000000000E+001|-0.200000000000000E+001 <<< + !< + !<```FORTRAN + !< USE PENF + !< PRINT "(A)", STR(N=[1._R8P, -2._R8P], DELIMITERS=['(', ')']) + !<``` + !=> (+0.100000000000000E+001,-0.200000000000000E+001) <<< + !< + !<```FORTRAN + !< USE PENF + !< PRINT "(A)", STR(N=[1._R8P, -2._R8P], COMPACT=.TRUE.) + !<``` + !=> +0.1E+1,-0.2E+1 <<< + REAL(R8P), INTENT(IN) :: N(:) !< REAL ARRAY TO BE CONVERTED. + LOGICAL, INTENT(IN), OPTIONAL :: NO_SIGN !< FLAG FOR LEAVING OUT THE SIGN. + CHARACTER(1), INTENT(IN), OPTIONAL :: SEPARATOR !< EVENTUAL SEPARATOR OF ARRAY VALUES. + CHARACTER(*), INTENT(IN), OPTIONAL :: DELIMITERS(1:2) !< EVENTUAL DELIMITERS OF ARRAY VALUES. + LOGICAL, INTENT(IN), OPTIONAL :: COMPACT !< FLAG FOR *COMPACTING* STRING ENCODING. + CHARACTER(LEN=:), ALLOCATABLE :: STR !< RETURNED STRING CONTAINING INPUT NUMBER. + CHARACTER(DR8P) :: STRN !< STRING CONTAINING OF ELEMENT OF INPUT ARRAY NUMBER. + CHARACTER(LEN=1) :: SEP !< ARRAY VALUES SEPARATOR + INTEGER :: I !< COUNTER. + + STR = '' + SEP = ',' + IF(PRESENT(SEPARATOR)) SEP = SEPARATOR + DO I=1,SIZE(N) + STRN = STR_R8P(NO_SIGN=NO_SIGN, COMPACT=COMPACT, N=N(I)) + STR = STR//SEP//TRIM(STRN) + ENDDO + STR = TRIM(STR(2:)) + IF (PRESENT(DELIMITERS)) STR = DELIMITERS(1)//STR//DELIMITERS(2) + ENDFUNCTION STR_A_R8P + + PURE FUNCTION STR_A_R4P(N, NO_SIGN, SEPARATOR, DELIMITERS, COMPACT) RESULT(STR) + !< CONVERT REAL ARRAY TO STRING. + !< + !<```FORTRAN + !< USE PENF + !< PRINT "(A)", STR(N=[1._R4P, -2._R4P]) + !<``` + !=> +0.100000E+01,-0.200000E+01 <<< + !< + !<```FORTRAN + !< USE PENF + !< PRINT "(A)", STR(N=[1._R4P, 2._R4P], NO_SIGN=.TRUE.) + !<``` + !=> 0.100000E+01,0.200000E+01 <<< + !< + !<```FORTRAN + !< USE PENF + !< PRINT "(A)", STR(N=[1._R4P, -2._R4P], SEPARATOR='|') + !<``` + !=> +0.100000E+01|-0.200000E+01 <<< + !< + !<```FORTRAN + !< USE PENF + !< PRINT "(A)", STR(N=[1._R4P, -2._R4P], DELIMITERS=['(', ')']) + !<``` + !=> (+0.100000E+01,-0.200000E+01) <<< + !< + !<```FORTRAN + !< USE PENF + !< PRINT "(A)", STR(N=[1._R4P, -2._R4P], COMPACT=.TRUE.) + !<``` + !=> +0.1E+1,-0.2E+1 <<< + REAL(R4P), INTENT(IN) :: N(:) !< REAL ARRAY TO BE CONVERTED. + LOGICAL, INTENT(IN), OPTIONAL :: NO_SIGN !< FLAG FOR LEAVING OUT THE SIGN. + CHARACTER(1), INTENT(IN), OPTIONAL :: SEPARATOR !< EVENTUAL SEPARATOR OF ARRAY VALUES. + CHARACTER(*), INTENT(IN), OPTIONAL :: DELIMITERS(1:2) !< EVENTUAL DELIMITERS OF ARRAY VALUES. + LOGICAL, INTENT(IN), OPTIONAL :: COMPACT !< FLAG FOR *COMPACTING* STRING ENCODING. + CHARACTER(LEN=:), ALLOCATABLE :: STR !< RETURNED STRING CONTAINING INPUT NUMBER. + CHARACTER(DR4P) :: STRN !< STRING CONTAINING OF ELEMENT OF INPUT ARRAY NUMBER. + CHARACTER(LEN=1) :: SEP !< ARRAY VALUES SEPARATOR + INTEGER :: I !< COUNTER. + + STR = '' + SEP = ',' + IF(PRESENT(SEPARATOR)) SEP = SEPARATOR + DO I=1,SIZE(N) + STRN = STR_R4P(NO_SIGN=NO_SIGN, COMPACT=COMPACT, N=N(I)) + STR = STR//SEP//TRIM(STRN) + ENDDO + STR = TRIM(STR(2:)) + IF (PRESENT(DELIMITERS)) STR = DELIMITERS(1)//STR//DELIMITERS(2) + ENDFUNCTION STR_A_R4P + + PURE FUNCTION STR_A_I8P(N, NO_SIGN, SEPARATOR, DELIMITERS) RESULT(STR) + !< CONVERT INTEGER ARRAY TO STRING. + !< + !<```FORTRAN + !< USE PENF + !< PRINT "(A)", STR(N=[1_I8P, -2_I8P]) + !<``` + !=> +1,-2 <<< + !< + !<```FORTRAN + !< USE PENF + !< PRINT "(A)", STR(N=[1_I8P, 2_I8P], NO_SIGN=.TRUE.) + !<``` + !=> 1,2 <<< + !< + !<```FORTRAN + !< USE PENF + !< PRINT "(A)", STR(N=[1_I8P, -2_I8P], SEPARATOR='|') + !<``` + !=> +1|-2 <<< + !< + !<```FORTRAN + !< USE PENF + !< PRINT "(A)", STR(N=[1_I8P, -2_I8P], DELIMITERS=['(', ')']) + !<``` + !=> (+1,-2) <<< + INTEGER(I8P), INTENT(IN) :: N(:) !< INTEGER ARRAY TO BE CONVERTED. + LOGICAL, INTENT(IN), OPTIONAL :: NO_SIGN !< FLAG FOR LEAVING OUT THE SIGN. + CHARACTER(1), INTENT(IN), OPTIONAL :: SEPARATOR !< EVENTUAL SEPARATOR OF ARRAY VALUES. + CHARACTER(*), INTENT(IN), OPTIONAL :: DELIMITERS(1:2) !< EVENTUAL DELIMITERS OF ARRAY VALUES. + CHARACTER(LEN=:), ALLOCATABLE :: STR !< RETURNED STRING CONTAINING INPUT NUMBER. + CHARACTER(DI8P) :: STRN !< STRING CONTAINING OF ELEMENT OF INPUT ARRAY NUMBER. + CHARACTER(LEN=1) :: SEP !< ARRAY VALUES SEPARATOR + INTEGER :: I !< COUNTER. + + STR = '' + SEP = ',' + IF(PRESENT(SEPARATOR)) SEP = SEPARATOR + IF (PRESENT(NO_SIGN)) THEN + DO I=1,SIZE(N) + STRN = STR_I8P(NO_SIGN=NO_SIGN, N=N(I)) + STR = STR//SEP//TRIM(STRN) + ENDDO + ELSE + DO I=1,SIZE(N) + STRN = STR_I8P(N=N(I)) + STR = STR//SEP//TRIM(STRN) + ENDDO + ENDIF + STR = TRIM(STR(2:)) + IF (PRESENT(DELIMITERS)) STR = DELIMITERS(1)//STR//DELIMITERS(2) + ENDFUNCTION STR_A_I8P + + PURE FUNCTION STR_A_I4P(N, NO_SIGN, SEPARATOR, DELIMITERS) RESULT(STR) + !< CONVERT INTEGER ARRAY TO STRING. + !< + !<```FORTRAN + !< USE PENF + !< PRINT "(A)", STR(N=[1_I4P, -2_I4P]) + !<``` + !=> +1,-2 <<< + !< + !<```FORTRAN + !< USE PENF + !< PRINT "(A)", STR(N=[1_I4P, 2_I4P], NO_SIGN=.TRUE.) + !<``` + !=> 1,2 <<< + !< + !<```FORTRAN + !< USE PENF + !< PRINT "(A)", STR(N=[1_I4P, -2_I4P], SEPARATOR='|') + !<``` + !=> +1|-2 <<< + !< + !<```FORTRAN + !< USE PENF + !< PRINT "(A)", STR(N=[1_I4P, -2_I4P], DELIMITERS=['(', ')']) + !<``` + !=> (+1,-2) <<< + INTEGER(I4P), INTENT(IN) :: N(:) !< INTEGER ARRAY TO BE CONVERTED. + LOGICAL, INTENT(IN), OPTIONAL :: NO_SIGN !< FLAG FOR LEAVING OUT THE SIGN. + CHARACTER(1), INTENT(IN), OPTIONAL :: SEPARATOR !< EVENTUAL SEPARATOR OF ARRAY VALUES. + CHARACTER(*), INTENT(IN), OPTIONAL :: DELIMITERS(1:2) !< EVENTUAL DELIMITERS OF ARRAY VALUES. + CHARACTER(LEN=:), ALLOCATABLE :: STR !< RETURNED STRING CONTAINING INPUT NUMBER. + CHARACTER(DI4P) :: STRN !< STRING CONTAINING OF ELEMENT OF INPUT ARRAY NUMBER. + CHARACTER(LEN=1) :: SEP !< ARRAY VALUES SEPARATOR + INTEGER :: I !< COUNTER. + + STR = '' + SEP = ',' + IF(PRESENT(SEPARATOR)) SEP = SEPARATOR + IF (PRESENT(NO_SIGN)) THEN + DO I=1,SIZE(N) + STRN = STR_I4P(NO_SIGN=NO_SIGN, N=N(I)) + STR = STR//SEP//TRIM(STRN) + ENDDO + ELSE + DO I=1,SIZE(N) + STRN = STR_I4P(N=N(I)) + STR = STR//SEP//TRIM(STRN) + ENDDO + ENDIF + STR = TRIM(STR(2:)) + IF (PRESENT(DELIMITERS)) STR = DELIMITERS(1)//STR//DELIMITERS(2) + ENDFUNCTION STR_A_I4P + + PURE FUNCTION STR_A_I2P(N, NO_SIGN, SEPARATOR, DELIMITERS) RESULT(STR) + !< CONVERT INTEGER ARRAY TO STRING. + !< + !<```FORTRAN + !< USE PENF + !< PRINT "(A)", STR(N=[1_I2P, -2_I2P]) + !<``` + !=> +1,-2 <<< + !< + !<```FORTRAN + !< USE PENF + !< PRINT "(A)", STR(N=[1_I2P, 2_I2P], NO_SIGN=.TRUE.) + !<``` + !=> 1,2 <<< + !< + !<```FORTRAN + !< USE PENF + !< PRINT "(A)", STR(N=[1_I2P, -2_I2P], SEPARATOR='|') + !<``` + !=> +1|-2 <<< + !< + !<```FORTRAN + !< USE PENF + !< PRINT "(A)", STR(N=[1_I2P, -2_I2P], DELIMITERS=['(', ')']) + !<``` + !=> (+1,-2) <<< + INTEGER(I2P), INTENT(IN) :: N(:) !< INTEGER ARRAY TO BE CONVERTED. + LOGICAL, INTENT(IN), OPTIONAL :: NO_SIGN !< FLAG FOR LEAVING OUT THE SIGN. + CHARACTER(1), INTENT(IN), OPTIONAL :: SEPARATOR !< EVENTUAL SEPARATOR OF ARRAY VALUES. + CHARACTER(*), INTENT(IN), OPTIONAL :: DELIMITERS(1:2) !< EVENTUAL DELIMITERS OF ARRAY VALUES. + CHARACTER(LEN=:), ALLOCATABLE :: STR !< RETURNED STRING CONTAINING INPUT NUMBER. + CHARACTER(DI2P) :: STRN !< STRING CONTAINING OF ELEMENT OF INPUT ARRAY NUMBER. + CHARACTER(LEN=1) :: SEP !< ARRAY VALUES SEPARATOR + INTEGER :: I !< COUNTER. + + STR = '' + SEP = ',' + IF(PRESENT(SEPARATOR)) SEP = SEPARATOR + IF (PRESENT(NO_SIGN)) THEN + DO I=1,SIZE(N) + STRN = STR_I2P(NO_SIGN=NO_SIGN, N=N(I)) + STR = STR//SEP//TRIM(STRN) + ENDDO + ELSE + DO I=1,SIZE(N) + STRN = STR_I2P(N=N(I)) + STR = STR//SEP//TRIM(STRN) + ENDDO + ENDIF + STR = TRIM(STR(2:)) + IF (PRESENT(DELIMITERS)) STR = DELIMITERS(1)//STR//DELIMITERS(2) + ENDFUNCTION STR_A_I2P + + PURE FUNCTION STR_A_I1P(N, NO_SIGN, SEPARATOR, DELIMITERS) RESULT(STR) + !< CONVERT INTEGER ARRAY TO STRING. + !< + !<```FORTRAN + !< USE PENF + !< PRINT "(A)", STR(N=[1_I1P, -2_I1P]) + !<``` + !=> +1,-2 <<< + !< + !<```FORTRAN + !< USE PENF + !< PRINT "(A)", STR(N=[1_I1P, 2_I1P], NO_SIGN=.TRUE.) + !<``` + !=> 1,2 <<< + !< + !<```FORTRAN + !< USE PENF + !< PRINT "(A)", STR(N=[1_I1P, -2_I1P], SEPARATOR='|') + !<``` + !=> +1|-2 <<< + !< + !<```FORTRAN + !< USE PENF + !< PRINT "(A)", STR(N=[1_I1P, -2_I1P], DELIMITERS=['(', ')']) + !<``` + !=> (+1,-2) <<< + INTEGER(I1P), INTENT(IN) :: N(:) !< INTEGER ARRAY TO BE CONVERTED. + LOGICAL, INTENT(IN), OPTIONAL :: NO_SIGN !< FLAG FOR LEAVING OUT THE SIGN. + CHARACTER(1), INTENT(IN), OPTIONAL :: SEPARATOR !< EVENTUAL SEPARATOR OF ARRAY VALUES. + CHARACTER(*), INTENT(IN), OPTIONAL :: DELIMITERS(1:2) !< EVENTUAL DELIMITERS OF ARRAY VALUES. + CHARACTER(LEN=:), ALLOCATABLE :: STR !< RETURNED STRING CONTAINING INPUT NUMBER. + CHARACTER(DI1P) :: STRN !< STRING CONTAINING OF ELEMENT OF INPUT ARRAY NUMBER. + CHARACTER(LEN=1) :: SEP !< ARRAY VALUES SEPARATOR + INTEGER :: I !< COUNTER. + + STR = '' + SEP = ',' + IF(PRESENT(SEPARATOR)) SEP = SEPARATOR + IF (PRESENT(NO_SIGN)) THEN + DO I=1,SIZE(N) + STRN = STR_I1P(NO_SIGN=NO_SIGN, N=N(I)) + STR = STR//SEP//TRIM(STRN) + ENDDO + ELSE + DO I=1,SIZE(N) + STRN = STR_I1P(N=N(I)) + STR = STR//SEP//TRIM(STRN) + ENDDO + ENDIF + STR = TRIM(STR(2:)) + IF (PRESENT(DELIMITERS)) STR = DELIMITERS(1)//STR//DELIMITERS(2) + ENDFUNCTION STR_A_I1P + + PURE SUBROUTINE COMPACT_REAL_STRING(STRING) + !< AUTHOR: IZAAK BEEKMAN + !< DATE: 02/24/2015 + !< + !< COMPACT A STRING REPRESENTING A REAL NUMBER, SO THAT THE SAME VALUE IS DISPLAYED WITH FEWER CHARACTERS. + !< + !< @NOTE NO NEED TO ADD DOCTEST: THIS IS TESTED BY A LOT OF DOCTESTS OF OTHER TBPS. + CHARACTER(LEN=*),INTENT(INOUT) :: STRING !< STRING REPRESENTATION OF A REAL NUMBER. + CHARACTER(LEN=LEN(STRING)) :: SIGNIFICAND !< SIGNIFICAND CHARACTERS. + CHARACTER(LEN=LEN(STRING)) :: EXPNT !< EXPONENT CHARACTERS. + CHARACTER(LEN=2) :: SEPARATOR !< SEPARATOR CHARACTERS. + INTEGER(I4P) :: EXP_START !< START POSITION OF EXPONENT. + INTEGER(I4P) :: DECIMAL_POS !< DECIMAL POSITIONS. + INTEGER(I4P) :: SIG_TRIM !< SIGNATURE TRIM. + INTEGER(I4P) :: EXP_TRIM !< EXPONENT TRIM. + INTEGER(I4P) :: I !< COUNTER + + STRING = ADJUSTL(STRING) + EXP_START = SCAN(STRING, 'EEDD') + IF (EXP_START == 0) EXP_START = SCAN(STRING, '-+', BACK=.TRUE.) + DECIMAL_POS = SCAN(STRING, '.') + IF (EXP_START /= 0) SEPARATOR = STRING(EXP_START:EXP_START) + IF ( EXP_START < DECIMAL_POS ) THEN ! POSSIBLY SIGNED, EXPONENT-LESS FLOAT + SIGNIFICAND = STRING + SIG_TRIM = LEN(TRIM(SIGNIFICAND)) + DO I = LEN(TRIM(SIGNIFICAND)), DECIMAL_POS+2, -1 ! LOOK FROM RIGHT TO LEFT AT 0S, BUT SAVE ONE AFTER THE DECIMAL PLACE + IF (SIGNIFICAND(I:I) == '0') THEN + SIG_TRIM = I-1 + ELSE + EXIT + ENDIF + ENDDO + STRING = TRIM(SIGNIFICAND(1:SIG_TRIM)) + ELSEIF (EXP_START > DECIMAL_POS) THEN ! FLOAT HAS EXPONENT + SIGNIFICAND = STRING(1:EXP_START-1) + SIG_TRIM = LEN(TRIM(SIGNIFICAND)) + DO I = LEN(TRIM(SIGNIFICAND)),DECIMAL_POS+2,-1 ! LOOK FROM RIGHT TO LEFT AT 0S + IF (SIGNIFICAND(I:I) == '0') THEN + SIG_TRIM = I-1 + ELSE + EXIT + ENDIF + ENDDO + EXPNT = ADJUSTL(STRING(EXP_START+1:)) + IF (EXPNT(1:1) == '+' .OR. EXPNT(1:1) == '-') THEN + SEPARATOR = TRIM(ADJUSTL(SEPARATOR))//EXPNT(1:1) + EXP_START = EXP_START + 1 + EXPNT = ADJUSTL(STRING(EXP_START+1:)) + ENDIF + EXP_TRIM = 1 + DO I = 1,(LEN(TRIM(EXPNT))-1) ! LOOK AT EXPONENT LEADING ZEROS SAVING LAST + IF (EXPNT(I:I) == '0') THEN + EXP_TRIM = I+1 + ELSE + EXIT + ENDIF + ENDDO + STRING = TRIM(ADJUSTL(SIGNIFICAND(1:SIG_TRIM)))// & + TRIM(ADJUSTL(SEPARATOR))// & + TRIM(ADJUSTL(EXPNT(EXP_TRIM:))) + !ELSE ! MAL-FORMED REAL, BUT THIS CODE SHOULD BE UNREACHABLE + ENDIF + ENDSUBROUTINE COMPACT_REAL_STRING + + ELEMENTAL FUNCTION STRZ_I8P(N, NZ_PAD) RESULT(STR) + !< CONVERTING INTEGER TO STRING, PREFIXING WITH THE RIGHT NUMBER OF ZEROS. + !< + !<```FORTRAN + !< USE PENF + !< PRINT "(A)", STRZ(N=1_I8P) + !<``` + !=> 0000000000000000001 <<< + !< + !<```FORTRAN + !< USE PENF + !< PRINT "(A)", STRZ(N=1_I8P, NZ_PAD=5) + !<``` + !=> 00001 <<< + INTEGER(I8P), INTENT(IN) :: N !< INTEGER TO BE CONVERTED. + INTEGER(I4P), INTENT(IN), OPTIONAL :: NZ_PAD !< NUMBER OF ZEROS PADDING. + CHARACTER(DI8P) :: STR !< RETURNED STRING CONTAINING INPUT NUMBER PLUS PADDING ZEROS. + + WRITE(STR,FI8PZP) N ! CASTING OF N TO STRING. + STR=STR(2:) ! LEAVING OUT THE SIGN. + IF (PRESENT(NZ_PAD)) STR=STR(DI8P-NZ_PAD:DI8P-1) ! LEAVING OUT THE EXTRA ZEROS PADDING + ENDFUNCTION STRZ_I8P + + ELEMENTAL FUNCTION STRZ_I4P(N, NZ_PAD) RESULT(STR) + !< CONVERT INTEGER TO STRING, PREFIXING WITH THE RIGHT NUMBER OF ZEROS. + !< + !<```FORTRAN + !< USE PENF + !< PRINT "(A)", STRZ(N=1_I4P) + !<``` + !=> 0000000001 <<< + !< + !<```FORTRAN + !< USE PENF + !< PRINT "(A)", STRZ(N=1_I4P, NZ_PAD=5) + !<``` + !=> 00001 <<< + INTEGER(I4P), INTENT(IN) :: N !< INTEGER TO BE CONVERTED. + INTEGER(I4P), INTENT(IN), OPTIONAL :: NZ_PAD !< NUMBER OF ZEROS PADDING. + CHARACTER(DI4P) :: STR !< RETURNED STRING CONTAINING INPUT NUMBER PLUS PADDING ZEROS. + + WRITE(STR,FI4PZP) N ! CASTING OF N TO STRING. + STR=STR(2:) ! LEAVING OUT THE SIGN. + IF (PRESENT(NZ_PAD)) STR=STR(DI4P-NZ_PAD:DI4P-1) ! LEAVING OUT THE EXTRA ZEROS PADDING + ENDFUNCTION STRZ_I4P + + ELEMENTAL FUNCTION STRZ_I2P(N, NZ_PAD) RESULT(STR) + !< CONVERT INTEGER TO STRING, PREFIXING WITH THE RIGHT NUMBER OF ZEROS. + !< + !<```FORTRAN + !< USE PENF + !< PRINT "(A)", STRZ(N=1_I2P) + !<``` + !=> 00001 <<< + !< + !<```FORTRAN + !< USE PENF + !< PRINT "(A)", STRZ(N=1_I2P, NZ_PAD=3) + !<``` + !=> 001 <<< + INTEGER(I2P), INTENT(IN) :: N !< INTEGER TO BE CONVERTED. + INTEGER(I4P), INTENT(IN), OPTIONAL :: NZ_PAD !< NUMBER OF ZEROS PADDING. + CHARACTER(DI2P) :: STR !< RETURNED STRING CONTAINING INPUT NUMBER PLUS PADDING ZEROS. + + WRITE(STR,FI2PZP) N ! CASTING OF N TO STRING. + STR=STR(2:) ! LEAVING OUT THE SIGN. + IF (PRESENT(NZ_PAD)) STR=STR(DI2P-NZ_PAD:DI2P-1) ! LEAVING OUT THE EXTRA ZEROS PADDING + ENDFUNCTION STRZ_I2P + + ELEMENTAL FUNCTION STRZ_I1P(N, NZ_PAD) RESULT(STR) + !< CONVERT INTEGER TO STRING, PREFIXING WITH THE RIGHT NUMBER OF ZEROS. + !< + !<```FORTRAN + !< USE PENF + !< PRINT "(A)", STRZ(N=1_I1P) + !<``` + !=> 001 <<< + !< + !<```FORTRAN + !< USE PENF + !< PRINT "(A)", STRZ(N=1_I1P, NZ_PAD=3) + !<``` + !=> 001 <<< + INTEGER(I1P), INTENT(IN) :: N !< INTEGER TO BE CONVERTED. + INTEGER(I4P), INTENT(IN), OPTIONAL :: NZ_PAD !< NUMBER OF ZEROS PADDING. + CHARACTER(DI1P) :: STR !< RETURNED STRING CONTAINING INPUT NUMBER PLUS PADDING ZEROS. + + WRITE(STR,FI1PZP) N ! CASTING OF N TO STRING. + STR=STR(2:) ! LEAVING OUT THE SIGN. + IF (PRESENT(NZ_PAD)) STR=STR(DI1P-NZ_PAD:DI1P-1) ! LEAVING OUT THE EXTRA ZEROS PADDING + ENDFUNCTION STRZ_I1P + + FUNCTION CTOR_R16P(STR, KND, PREF, ERROR) RESULT(N) + !< CONVERT STRING TO REAL. + !< + !<```FORTRAN + !< USE PENF + !< PRINT FR16P, CTON(STR='-1.0', KND=1._R16P) + !<``` + !=> -0.100000000000000000000000000000000E+0001 <<< + CHARACTER(*), INTENT(IN) :: STR !< STRING CONTAINING INPUT NUMBER. + REAL(R16P), INTENT(IN) :: KND !< NUMBER KIND. + CHARACTER(*), OPTIONAL, INTENT(IN) :: PREF !< PREFIXING STRING. + INTEGER(I4P), OPTIONAL, INTENT(OUT) :: ERROR !< ERROR TRAPPING FLAG: 0 NO ERRORS, >0 ERROR OCCURS. + REAL(R16P) :: N !< NUMBER RETURNED. + INTEGER(I4P) :: ERR !< ERROR TRAPPING FLAG: 0 NO ERRORS, >0 ERROR OCCURS. + CHARACTER(LEN=:), ALLOCATABLE :: PREFD !< PREFIXING STRING. + + READ(STR, *, IOSTAT=ERR) N ! CASTING OF STR TO N. + IF (ERR/=0) THEN + PREFD = '' ; IF (PRESENT(PREF)) PREFD = PREF + WRITE(STDERR, '(A,I1,A)') PREFD//' ERROR: CONVERSION OF STRING "'//STR//'" TO REAL FAILED! REAL(', KIND(KND), ')' + ENDIF + IF (PRESENT(ERROR)) ERROR = ERR + ENDFUNCTION CTOR_R16P + + FUNCTION CTOR_R8P(STR, KND, PREF, ERROR) RESULT(N) + !< CONVERT STRING TO REAL. + !< + !<```FORTRAN + !< USE PENF + !< PRINT FR8P, CTON(STR='-1.0', KND=1._R8P) + !<``` + !=> -0.100000000000000E+001 <<< + CHARACTER(*), INTENT(IN) :: STR !< STRING CONTAINING INPUT NUMBER. + REAL(R8P), INTENT(IN) :: KND !< NUMBER KIND. + CHARACTER(*), OPTIONAL, INTENT(IN) :: PREF !< PREFIXING STRING. + INTEGER(I4P), OPTIONAL, INTENT(OUT) :: ERROR !< ERROR TRAPPING FLAG: 0 NO ERRORS, >0 ERROR OCCURS. + REAL(R8P) :: N !< NUMBER RETURNED. + INTEGER(I4P) :: ERR !< ERROR TRAPPING FLAG: 0 NO ERRORS, >0 ERROR OCCURS. + CHARACTER(LEN=:), ALLOCATABLE :: PREFD !< PREFIXING STRING. + + READ(STR, *, IOSTAT=ERR) N ! CASTING OF STR TO N. + IF (ERR/=0) THEN + PREFD = '' ; IF (PRESENT(PREF)) PREFD = PREF + WRITE(STDERR, '(A,I1,A)') PREFD//' ERROR: CONVERSION OF STRING "'//STR//'" TO REAL FAILED! REAL(', KIND(KND), ')' + ENDIF + IF (PRESENT(ERROR)) ERROR = ERR + ENDFUNCTION CTOR_R8P + + FUNCTION CTOR_R4P(STR, KND, PREF, ERROR) RESULT(N) + !< CONVERT STRING TO REAL. + !< + !<```FORTRAN + !< USE PENF + !< PRINT FR4P, CTON(STR='-1.0', KND=1._R4P) + !<``` + !=> -0.100000E+01 <<< + CHARACTER(*), INTENT(IN) :: STR !< STRING CONTAINING INPUT NUMBER. + REAL(R4P), INTENT(IN) :: KND !< NUMBER KIND. + CHARACTER(*), OPTIONAL, INTENT(IN) :: PREF !< PREFIXING STRING. + INTEGER(I4P), OPTIONAL, INTENT(OUT) :: ERROR !< ERROR TRAPPING FLAG: 0 NO ERRORS, >0 ERROR OCCURS. + REAL(R4P) :: N !< NUMBER RETURNED. + INTEGER(I4P) :: ERR !< ERROR TRAPPING FLAG: 0 NO ERRORS, >0 ERROR OCCURS. + CHARACTER(LEN=:), ALLOCATABLE :: PREFD !< PREFIXING STRING. + + READ(STR, *, IOSTAT=ERR) N ! CASTING OF STR TO N. + IF (ERR/=0) THEN + PREFD = '' ; IF (PRESENT(PREF)) PREFD = PREF + WRITE(STDERR, '(A,I1,A)') PREFD//' ERROR: CONVERSION OF STRING "'//STR//'" TO REAL FAILED! REAL(', KIND(KND), ')' + ENDIF + IF (PRESENT(ERROR)) ERROR = ERR + ENDFUNCTION CTOR_R4P + + FUNCTION CTOI_I8P(STR, KND, PREF, ERROR) RESULT(N) + !< CONVERT STRING TO INTEGER. + !< + !<```FORTRAN + !< USE PENF + !< PRINT FI8P, CTON(STR='-1', KND=1_I8P) + !<``` + !=> -1 <<< + CHARACTER(*), INTENT(IN) :: STR !< STRING CONTAINING INPUT NUMBER. + INTEGER(I8P), INTENT(IN) :: KND !< NUMBER KIND. + CHARACTER(*), OPTIONAL, INTENT(IN) :: PREF !< PREFIXING STRING. + INTEGER(I4P), OPTIONAL, INTENT(OUT) :: ERROR !< ERROR TRAPPING FLAG: 0 NO ERRORS, >0 ERROR OCCURS. + INTEGER(I8P) :: N !< NUMBER RETURNED. + INTEGER(I4P) :: ERR !< ERROR TRAPPING FLAG: 0 NO ERRORS, >0 ERROR OCCURS. + CHARACTER(LEN=:), ALLOCATABLE :: PREFD !< PREFIXING STRING. + + READ(STR, *, IOSTAT=ERR) N ! CASTING OF STR TO N. + IF (ERR/=0) THEN + PREFD = '' ; IF (PRESENT(PREF)) PREFD = PREF + WRITE(STDERR, '(A,I1,A)') PREFD//' ERROR: CONVERSION OF STRING "'//STR//'" TO INTEGER FAILED! INTEGER(', KIND(KND), ')' + ENDIF + IF (PRESENT(ERROR)) ERROR = ERR + ENDFUNCTION CTOI_I8P + + FUNCTION CTOI_I4P(STR, KND, PREF, ERROR) RESULT(N) + !< CONVERT STRING TO INTEGER. + !< + !<```FORTRAN + !< USE PENF + !< PRINT FI4P, CTON(STR='-1', KND=1_I4P) + !<``` + !=> -1 <<< + CHARACTER(*), INTENT(IN) :: STR !< STRING CONTAINING INPUT NUMBER. + INTEGER(I4P), INTENT(IN) :: KND !< NUMBER KIND. + CHARACTER(*), OPTIONAL, INTENT(IN) :: PREF !< PREFIXING STRING. + INTEGER(I4P), OPTIONAL, INTENT(OUT) :: ERROR !< ERROR TRAPPING FLAG: 0 NO ERRORS, >0 ERROR OCCURS. + INTEGER(I4P) :: N !< NUMBER RETURNED. + INTEGER(I4P) :: ERR !< ERROR TRAPPING FLAG: 0 NO ERRORS, >0 ERROR OCCURS. + CHARACTER(LEN=:), ALLOCATABLE :: PREFD !< PREFIXING STRING. + + READ(STR, *, IOSTAT=ERR) N ! CASTING OF STR TO N. + IF (ERR/=0) THEN + PREFD = '' ; IF (PRESENT(PREF)) PREFD = PREF + WRITE(STDERR, '(A,I1,A)') PREFD//' ERROR: CONVERSION OF STRING "'//STR//'" TO INTEGER FAILED! INTEGER(', KIND(KND), ')' + ENDIF + IF (PRESENT(ERROR)) ERROR = ERR + ENDFUNCTION CTOI_I4P + + FUNCTION CTOI_I2P(STR, KND, PREF, ERROR) RESULT(N) + !< CONVERT STRING TO INTEGER. + !< + !<```FORTRAN + !< USE PENF + !< PRINT FI2P, CTON(STR='-1', KND=1_I2P) + !<``` + !=> -1 <<< + CHARACTER(*), INTENT(IN) :: STR !< STRING CONTAINING INPUT NUMBER. + INTEGER(I2P), INTENT(IN) :: KND !< NUMBER KIND. + CHARACTER(*), OPTIONAL, INTENT(IN) :: PREF !< PREFIXING STRING. + INTEGER(I4P), OPTIONAL, INTENT(OUT) :: ERROR !< ERROR TRAPPING FLAG: 0 NO ERRORS, >0 ERROR OCCURS. + INTEGER(I2P) :: N !< NUMBER RETURNED. + INTEGER(I4P) :: ERR !< ERROR TRAPPING FLAG: 0 NO ERRORS, >0 ERROR OCCURS. + CHARACTER(LEN=:), ALLOCATABLE :: PREFD !< PREFIXING STRING. + + READ(STR, *, IOSTAT=ERR) N ! CASTING OF STR TO N. + IF (ERR/=0) THEN + PREFD = '' ; IF (PRESENT(PREF)) PREFD = PREF + WRITE(STDERR, '(A,I1,A)') PREFD//' ERROR: CONVERSION OF STRING "'//STR//'" TO INTEGER FAILED! INTEGER(', KIND(KND), ')' + ENDIF + IF (PRESENT(ERROR)) ERROR = ERR + ENDFUNCTION CTOI_I2P + + FUNCTION CTOI_I1P(STR, KND, PREF, ERROR) RESULT(N) + !< CONVERT STRING TO INTEGER. + !< + !<```FORTRAN + !< USE PENF + !< PRINT FI1P, CTON(STR='-1', KND=1_I1P) + !<``` + !=> -1 <<< + CHARACTER(*), INTENT(IN) :: STR !< STRING CONTAINING INPUT NUMBER. + INTEGER(I1P), INTENT(IN) :: KND !< NUMBER KIND. + CHARACTER(*), OPTIONAL, INTENT(IN) :: PREF !< PREFIXING STRING. + INTEGER(I4P), OPTIONAL, INTENT(OUT) :: ERROR !< ERROR TRAPPING FLAG: 0 NO ERRORS, >0 ERROR OCCURS. + INTEGER(I1P) :: N !< NUMBER RETURNED. + INTEGER(I4P) :: ERR !< ERROR TRAPPING FLAG: 0 NO ERRORS, >0 ERROR OCCURS. + CHARACTER(LEN=:), ALLOCATABLE :: PREFD !< PREFIXING STRING. + + READ(STR, *, IOSTAT=ERR) N ! CASTING OF STR TO N. + IF (ERR/=0) THEN + PREFD = '' ; IF (PRESENT(PREF)) PREFD = PREF + WRITE(STDERR, '(A,I1,A)') PREFD//' ERROR: CONVERSION OF STRING "'//STR//'" TO INTEGER FAILED! INTEGER(', KIND(KND), ')' + ENDIF + IF (PRESENT(ERROR)) ERROR = ERR + ENDFUNCTION CTOI_I1P + + ELEMENTAL FUNCTION BSTR_R16P(N) RESULT(BSTR) + !< CONVERT REAL TO STRING OF BITS. + !< + !< @NOTE IT IS ASSUMED THAT R16P IS REPRESENTED BY MEANS OF 128 BITS, BUT THIS IS NOT ENSURED IN ALL ARCHITECTURES. + !< + !<```FORTRAN + !< USE PENF + !< CHARACTER(128) :: B + !< B = BSTR(N=1._R16P) + !< PRINT "(A)", B(17:) + !<``` + !=> 0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001111111100111111 <<< + REAL(R16P), INTENT(IN) :: N !< REAL TO BE CONVERTED. + CHARACTER(128) :: BSTR !< RETURNED BIT-STRING CONTAINING INPUT NUMBER. + INTEGER(I1P) :: BUFFER(16) !< TRANSFER BUFFER. + + BUFFER = TRANSFER(N, BUFFER) + WRITE(BSTR, '(16B8.8)') BUFFER + ENDFUNCTION BSTR_R16P + + ELEMENTAL FUNCTION BSTR_R8P(N) RESULT(BSTR) + !< CONVERT REAL TO STRING OF BITS. + !< + !< @NOTE IT IS ASSUMED THAT R8P IS REPRESENTED BY MEANS OF 64 BITS, BUT THIS IS NOT ENSURED IN ALL ARCHITECTURES. + !< + !<```FORTRAN + !< USE PENF + !< PRINT "(A)", BSTR(N=1._R8P) + !<``` + !=> 0000000000000000000000000000000000000000000000001111000000111111 <<< + REAL(R8P), INTENT(IN) :: N !< REAL TO BE CONVERTED. + CHARACTER(64) :: BSTR !< RETURNED BIT-STRING CONTAINING INPUT NUMBER. + INTEGER(I1P) :: BUFFER(8) !< TRANSFER BUFFER. + + BUFFER = TRANSFER(N, BUFFER) + WRITE(BSTR, '(8B8.8)') BUFFER + ENDFUNCTION BSTR_R8P + + ELEMENTAL FUNCTION BSTR_R4P(N) RESULT(BSTR) + !< CONVERT REAL TO STRING OF BITS. + !< + !< @NOTE IT IS ASSUMED THAT R4P IS REPRESENTED BY MEANS OF 32 BITS, BUT THIS IS NOT ENSURED IN ALL ARCHITECTURES. + !< + !<```FORTRAN + !< USE PENF + !< PRINT "(A)", BSTR(N=1._R4P) + !<``` + !=> 00000000000000001000000000111111 <<< + REAL(R4P), INTENT(IN) :: N !< REAL TO BE CONVERTED. + CHARACTER(32) :: BSTR !< RETURNED BIT-STRING CONTAINING INPUT NUMBER. + INTEGER(I1P) :: BUFFER(4) !< TRANSFER BUFFER. + + BUFFER = TRANSFER(N, BUFFER) + WRITE(BSTR, '(4B8.8)') BUFFER + ENDFUNCTION BSTR_R4P + + ELEMENTAL FUNCTION BSTR_I8P(N) RESULT(BSTR) + !< CONVERT INTEGER TO STRING OF BITS. + !< + !< @NOTE IT IS ASSUMED THAT I8P IS REPRESENTED BY MEANS OF 64 BITS, BUT THIS IS NOT ENSURED IN ALL ARCHITECTURES. + !< + !<```FORTRAN + !< USE PENF + !< PRINT "(A)", BSTR(N=1_I8P) + !<``` + !=> 0000000000000000000000000000000000000000000000000000000000000001 <<< + INTEGER(I8P), INTENT(IN) :: N !< REAL TO BE CONVERTED. + CHARACTER(64) :: BSTR !< RETURNED BIT-STRING CONTAINING INPUT NUMBER. + + WRITE(BSTR, '(B64.64)') N + ENDFUNCTION BSTR_I8P + + ELEMENTAL FUNCTION BSTR_I4P(N) RESULT(BSTR) + !< CONVERT INTEGER TO STRING OF BITS. + !< + !< @NOTE IT IS ASSUMED THAT I4P IS REPRESENTED BY MEANS OF 32 BITS, BUT THIS IS NOT ENSURED IN ALL ARCHITECTURES. + !< + !<```FORTRAN + !< USE PENF + !< PRINT "(A)", BSTR(N=1_I4P) + !<``` + !=> 00000000000000000000000000000001 <<< + INTEGER(I4P), INTENT(IN) :: N !< REAL TO BE CONVERTED. + CHARACTER(32) :: BSTR !< RETURNED BIT-STRING CONTAINING INPUT NUMBER. + + WRITE(BSTR, '(B32.32)') N + ENDFUNCTION BSTR_I4P + + ELEMENTAL FUNCTION BSTR_I2P(N) RESULT(BSTR) + !< CONVERT INTEGER TO STRING OF BITS. + !< + !< @NOTE IT IS ASSUMED THAT I2P IS REPRESENTED BY MEANS OF 16 BITS, BUT THIS IS NOT ENSURED IN ALL ARCHITECTURES. + !< + !<```FORTRAN + !< USE PENF + !< PRINT "(A)", BSTR(N=1_I2P) + !<``` + !=> 0000000000000001 <<< + INTEGER(I2P), INTENT(IN) :: N !< REAL TO BE CONVERTED. + CHARACTER(16) :: BSTR !< RETURNED BIT-STRING CONTAINING INPUT NUMBER. + + WRITE(BSTR, '(B16.16)') N + ENDFUNCTION BSTR_I2P + + ELEMENTAL FUNCTION BSTR_I1P(N) RESULT(BSTR) + !< CONVERT INTEGER TO STRING OF BITS. + !< + !< @NOTE IT IS ASSUMED THAT I1P IS REPRESENTED BY MEANS OF 8 BITS, BUT THIS IS NOT ENSURED IN ALL ARCHITECTURES. + !< + !<```FORTRAN + !< USE PENF + !< PRINT "(A)", BSTR(N=1_I1P) + !<``` + !=> 00000001 <<< + INTEGER(I1P), INTENT(IN) :: N !< REAL TO BE CONVERTED. + CHARACTER(8) :: BSTR !< RETURNED BIT-STRING CONTAINING INPUT NUMBER. + + WRITE(BSTR, '(B8.8)') N + ENDFUNCTION BSTR_I1P + + ELEMENTAL FUNCTION BCTOR_R16P(BSTR, KND) RESULT(N) + !< CONVERT BIT-STRING TO REAL. + !< + !<```FORTRAN + !< USE PENF + !< PRINT FR16P, BCTON('00000000000000000000000000000000000000000000000000000000000000000000000000000'//& + !< '000000000000000000000000000000000001111111100111111', KND=1._R16P) + !<``` + !=> 0.100000000000000000000000000000000E+0001 <<< + CHARACTER(*), INTENT(IN) :: BSTR !< STRING CONTAINING INPUT NUMBER. + REAL(R16P), INTENT(IN) :: KND !< NUMBER KIND. + REAL(R16P) :: N !< NUMBER RETURNED. + INTEGER(I1P) :: BUFFER(16) !< TRANSFER BUFFER. + + READ(BSTR, '(16B8.8)') BUFFER + N = TRANSFER(BUFFER, N) + ENDFUNCTION BCTOR_R16P + + ELEMENTAL FUNCTION BCTOR_R8P(BSTR, KND) RESULT(N) + !< CONVERT BIT-STRING TO REAL. + !< + !<```FORTRAN + !< USE PENF + !< PRINT FR8P, BCTON('0000000000000000000000000000000000000000000000001111000000111111', KND=1._R8P) + !<``` + !=> 0.100000000000000E+001 <<< + CHARACTER(*), INTENT(IN) :: BSTR !< STRING CONTAINING INPUT NUMBER. + REAL(R8P), INTENT(IN) :: KND !< NUMBER KIND. + REAL(R8P) :: N !< NUMBER RETURNED. + INTEGER(I1P) :: BUFFER(8) !< TRANSFER BUFFER. + + READ(BSTR, '(8B8.8)') BUFFER + N = TRANSFER(BUFFER, N) + ENDFUNCTION BCTOR_R8P + + ELEMENTAL FUNCTION BCTOR_R4P(BSTR, KND) RESULT(N) + !< CONVERT BIT-STRING TO REAL. + !< + !<```FORTRAN + !< USE PENF + !< PRINT FR4P, BCTON('00000000000000001000000000111111', KND=1._R4P) + !<``` + !=> 0.100000E+01 <<< + CHARACTER(*), INTENT(IN) :: BSTR !< STRING CONTAINING INPUT NUMBER. + REAL(R4P), INTENT(IN) :: KND !< NUMBER KIND. + REAL(R4P) :: N !< NUMBER RETURNED. + INTEGER(I1P) :: BUFFER(4) !< TRANSFER BUFFER. + + READ(BSTR, '(4B8.8)') BUFFER + N = TRANSFER(BUFFER, N) + ENDFUNCTION BCTOR_R4P + + ELEMENTAL FUNCTION BCTOI_I8P(BSTR, KND) RESULT(N) + !< CONVERT BIT-STRING TO INTEGER. + !< + !<```FORTRAN + !< USE PENF + !< PRINT FI8P, BCTON('0000000000000000000000000000000000000000000000000000000000000001', KND=1_I8P) + !<``` + !=> 1 <<< + CHARACTER(*), INTENT(IN) :: BSTR !< STRING CONTAINING INPUT NUMBER. + INTEGER(I8P), INTENT(IN) :: KND !< NUMBER KIND. + INTEGER(I8P) :: N !< NUMBER RETURNED. + + READ(BSTR,'(B'//TRIM(STR(BIT_SIZE(KND), .TRUE.))//'.'//TRIM(STR(BIT_SIZE(KND), .TRUE.))//')') N + ENDFUNCTION BCTOI_I8P + + ELEMENTAL FUNCTION BCTOI_I4P(BSTR, KND) RESULT(N) + !< CONVERT BIT-STRING TO INTEGER. + !< + !<```FORTRAN + !< USE PENF + !< PRINT FI4P, BCTON('00000000000000000000000000000001', KND=1_I4P) + !<``` + !=> 1 <<< + CHARACTER(*), INTENT(IN) :: BSTR !< STRING CONTAINING INPUT NUMBER. + INTEGER(I4P), INTENT(IN) :: KND !< NUMBER KIND. + INTEGER(I4P) :: N !< NUMBER RETURNED. + + READ(BSTR,'(B'//TRIM(STR(BIT_SIZE(KND), .TRUE.))//'.'//TRIM(STR(BIT_SIZE(KND), .TRUE.))//')') N + ENDFUNCTION BCTOI_I4P + + ELEMENTAL FUNCTION BCTOI_I2P(BSTR, KND) RESULT(N) + !< CONVERT BIT-STRING TO INTEGER. + !< + !<```FORTRAN + !< USE PENF + !< PRINT FI2P, BCTON('0000000000000001', KND=1_I2P) + !<``` + !=> 1 <<< + CHARACTER(*), INTENT(IN) :: BSTR !< STRING CONTAINING INPUT NUMBER. + INTEGER(I2P), INTENT(IN) :: KND !< NUMBER KIND. + INTEGER(I2P) :: N !< NUMBER RETURNED. + + READ(BSTR,'(B'//TRIM(STR(BIT_SIZE(KND), .TRUE.))//'.'//TRIM(STR(BIT_SIZE(KND), .TRUE.))//')') N + ENDFUNCTION BCTOI_I2P + + ELEMENTAL FUNCTION BCTOI_I1P(BSTR, KND) RESULT(N) + !< CONVERT BIT-STRING TO INTEGER. + !< + !<```FORTRAN + !< USE PENF + !< PRINT FI1P, BCTON('00000001', KND=1_I1P) + !<``` + !=> 1 <<< + CHARACTER(*), INTENT(IN) :: BSTR !< STRING CONTAINING INPUT NUMBER. + INTEGER(I1P), INTENT(IN) :: KND !< NUMBER KIND. + INTEGER(I1P) :: N !< NUMBER RETURNED. + + READ(BSTR,'(B'//TRIM(STR(BIT_SIZE(KND), .TRUE.))//'.'//TRIM(STR(BIT_SIZE(KND), .TRUE.))//')') N + ENDFUNCTION BCTOI_I1P +ENDMODULE PENF_STRINGIFY + + +!< PORTABILITY ENVIRONMENT FOR FORTRAN POOR PEOPLE. + +MODULE PENF +!< PORTABILITY ENVIRONMENT FOR FORTRAN POOR PEOPLE. +USE PENF_GLOBAL_PARAMETERS_VARIABLES +#ifdef __INTEL_COMPILER +USE PENF_B_SIZE +#else +USE PENF_B_SIZE, ONLY : BIT_SIZE, BYTE_SIZE +#endif +USE PENF_STRINGIFY, ONLY : STR_ASCII, STR_UCS4, STR, STRZ, CTON, BSTR, BCTON + +IMPLICIT NONE +PRIVATE +SAVE +! GLOBAL PARAMETERS AND VARIABLES +PUBLIC :: ENDIANL, ENDIANB, ENDIAN, IS_INITIALIZED +PUBLIC :: ASCII, UCS4, CK +PUBLIC :: R16P, FR16P, DR16P, MINR16P, MAXR16P, BIR16P, BYR16P, SMALLR16P, ZEROR16P +PUBLIC :: R8P, FR8P, DR8P, MINR8P, MAXR8P, BIR8P, BYR8P, SMALLR8P, ZEROR8P +PUBLIC :: R4P, FR4P, DR4P, MINR4P, MAXR4P, BIR4P, BYR4P, SMALLR4P, ZEROR4P +PUBLIC :: R_P, FR_P, DR_P, MINR_P, MAXR_P, BIR_P, BYR_P, SMALLR_P, ZEROR_P +PUBLIC :: I8P, FI8P, DI8P, MINI8P, MAXI8P, BII8P, BYI8P +PUBLIC :: I4P, FI4P, DI4P, MINI4P, MAXI4P, BII4P, BYI4P +PUBLIC :: I2P, FI2P, DI2P, MINI2P, MAXI2P, BII2P, BYI2P +PUBLIC :: I1P, FI1P, DI1P, MINI1P, MAXI1P, BII1P, BYI1P +PUBLIC :: I_P, FI_P, DI_P, MINI_P, MAXI_P, BII_P, BYI_P +PUBLIC :: CHARACTER_KINDS_LIST, REAL_KINDS_LIST, REAL_FORMATS_LIST +PUBLIC :: INTEGER_KINDS_LIST, INTEGER_FORMATS_LIST +! BIT/BYTE SIZE FUNCTIONS +PUBLIC :: BIT_SIZE, BYTE_SIZE +! STRINGIFY FACILITY +PUBLIC :: STR_ASCII, STR_UCS4 +PUBLIC :: STR, STRZ, CTON +PUBLIC :: BSTR, BCTON +! MISCELLANEA FACILITY +PUBLIC :: CHECK_ENDIAN +PUBLIC :: DIGIT +PUBLIC :: PENF_INIT +PUBLIC :: PENF_PRINT + +INTEGER, PROTECTED :: ENDIAN = ENDIANL !< BIT ORDERING: LITTLE ENDIAN (ENDIANL), OR BIG ENDIAN (ENDIANB). +LOGICAL, PROTECTED :: IS_INITIALIZED = .FALSE. !< CHECK THE INITIALIZATION OF SOME VARIABLES THAT MUST BE INITIALIZED. + +#ifdef __GFORTRAN__ +! WORK-AROUND FOR STRANGE GFORTRAN BUG... +INTERFACE BIT_SIZE + !< OVERLOADING OF THE INTRINSIC *BIT_SIZE* FUNCTION FOR COMPUTING THE NUMBER OF BITS OF (ALSO) REAL AND CHARACTER VARIABLES. +ENDINTERFACE +#endif + +INTERFACE DIGIT + !< COMPUTE THE NUMBER OF DIGITS IN DECIMAL BASE OF THE INPUT INTEGER. + MODULE PROCEDURE DIGIT_I8, DIGIT_I4, DIGIT_I2, DIGIT_I1 +ENDINTERFACE + +CONTAINS + ! PUBLIC PROCEDURES + SUBROUTINE CHECK_ENDIAN() + !< CHECK THE TYPE OF BIT ORDERING (BIG OR LITTLE ENDIAN) OF THE RUNNING ARCHITECTURE. + !< + !> @NOTE THE RESULT IS STORED INTO THE *ENDIAN* GLOBAL VARIABLE. + !< + !<```FORTRAN + !< USE PENF + !< CALL CHECK_ENDIAN + !< PRINT *, ENDIAN + !<``` + !=> 1 <<< + IF (IS_LITTLE_ENDIAN()) THEN + ENDIAN = ENDIANL + ELSE + ENDIAN = ENDIANB + ENDIF + CONTAINS + PURE FUNCTION IS_LITTLE_ENDIAN() RESULT(IS_LITTLE) + !< CHECK IF THE TYPE OF THE BIT ORDERING OF THE RUNNING ARCHITECTURE IS LITTLE ENDIAN. + LOGICAL :: IS_LITTLE !< LOGICAL OUTPUT: TRUE IS THE RUNNING ARCHITECTURE USES LITTLE ENDIAN ORDERING, FALSE OTHERWISE. + INTEGER(I1P) :: INT1(1:4) !< ONE BYTE INTEGER ARRAY FOR CASTING 4 BYTES INTEGER. + + INT1 = TRANSFER(1_I4P, INT1) + IS_LITTLE = (INT1(1)==1_I1P) + ENDFUNCTION IS_LITTLE_ENDIAN + ENDSUBROUTINE CHECK_ENDIAN + + SUBROUTINE PENF_INIT() + !< INITIALIZE PENF'S VARIABLES THAT ARE NOT INITIALIZED INTO THE DEFINITION SPECIFICATION. + !< + !<```FORTRAN + !< USE PENF + !< CALL PENF_INIT + !< PRINT FI1P, BYR4P + !<``` + !=> 4 <<< + + CALL CHECK_ENDIAN + BIR16P = BIT_SIZE(MAXR16P) ; BYR16P = BIR16P / 8_I2P + BIR8P = BIT_SIZE(MAXR8P) ; BYR8P = BIR8P / 8_I1P + BIR4P = BIT_SIZE(MAXR4P) ; BYR4P = BIR4P / 8_I1P + BIR_P = BIT_SIZE(MAXR_P) ; BYR_P = BIR_P / 8_I1P + IS_INITIALIZED = .TRUE. + ENDSUBROUTINE PENF_INIT + + SUBROUTINE PENF_PRINT(UNIT, PREF, IOSTAT, IOMSG) + !< PRINT TO THE SPECIFIED UNIT THE PENF'S ENVIRONMENT DATA. + !< + !<```FORTRAN + !< USE PENF + !< INTEGER :: U + !< OPEN(NEWUNIT=U, STATUS='SCRATCH') + !< CALL PENF_PRINT(U) + !< CLOSE(U) + !< PRINT "(A)", 'DONE' + !<``` + !=> DONE <<< + INTEGER(I4P), INTENT(IN) :: UNIT !< LOGIC UNIT. + CHARACTER(*), INTENT(IN), OPTIONAL :: PREF !< PREFIXING STRING. + INTEGER(I4P), INTENT(OUT), OPTIONAL :: IOSTAT !< IO ERROR. + CHARACTER(*), INTENT(OUT), OPTIONAL :: IOMSG !< IO ERROR MESSAGE. + CHARACTER(LEN=:), ALLOCATABLE :: PREFD !< PREFIXING STRING. + INTEGER(I4P) :: IOSTATD !< IO ERROR. + CHARACTER(500) :: IOMSGD !< TEMPORARY VARIABLE FOR IO ERROR MESSAGE. + + IF (.NOT.IS_INITIALIZED) CALL PENF_INIT + PREFD = '' ; IF (PRESENT(PREF)) PREFD = PREF + IF (ENDIAN==ENDIANL) THEN + WRITE(UNIT=UNIT,FMT='(A)',IOSTAT=IOSTATD,IOMSG=IOMSGD)PREFD//'THIS ARCHITECTURE HAS LITTLE ENDIAN BIT ORDERING' + ELSE + WRITE(UNIT=UNIT,FMT='(A)',IOSTAT=IOSTATD,IOMSG=IOMSGD)PREFD//'THIS ARCHITECTURE HAS BIG ENDIAN BIT ORDERING' + ENDIF + WRITE(UNIT=UNIT,FMT='(A)',IOSTAT=IOSTATD,IOMSG=IOMSGD) PREFD//'CHARACTER KIND:' + WRITE(UNIT=UNIT,FMT='(A)',IOSTAT=IOSTATD,IOMSG=IOMSGD) PREFD//' ASCII: '//STR(N=ASCII) + WRITE(UNIT=UNIT,FMT='(A)',IOSTAT=IOSTATD,IOMSG=IOMSGD) PREFD//' UCS4: '//STR(N=UCS4) + WRITE(UNIT=UNIT,FMT='(A)',IOSTAT=IOSTATD,IOMSG=IOMSGD) PREFD//' CK: '//STR(N=CK) + WRITE(UNIT=UNIT,FMT='(A)',IOSTAT=IOSTATD,IOMSG=IOMSGD) PREFD//'REALS KIND, FORMAT AND CHARACTERS NUMBER:' + WRITE(UNIT=UNIT,FMT='(A)',IOSTAT=IOSTATD,IOMSG=IOMSGD) PREFD//' R16P: '//STR(N=R16P)//','//FR16P//','//STR(N=DR16P) + WRITE(UNIT=UNIT,FMT='(A)',IOSTAT=IOSTATD,IOMSG=IOMSGD) PREFD//' R8P: '//STR(N=R8P )//','//FR8P //','//STR(N=DR8P ) + WRITE(UNIT=UNIT,FMT='(A)',IOSTAT=IOSTATD,IOMSG=IOMSGD) PREFD//' R4P: '//STR(N=R4P )//','//FR4P //','//STR(N=DR4P ) + WRITE(UNIT=UNIT,FMT='(A)',IOSTAT=IOSTATD,IOMSG=IOMSGD) PREFD//' R_P: '//STR(N=R_P )//','//FR_P //','//STR(N=DR_P ) + WRITE(UNIT=UNIT,FMT='(A)',IOSTAT=IOSTATD,IOMSG=IOMSGD) PREFD//'IntEGERS KIND, FORMAT AND CHARACTERS NUMBER:' + WRITE(UNIT=UNIT,FMT='(A)',IOSTAT=IOSTATD,IOMSG=IOMSGD) PREFD//' I8P: '//STR(N=I8P)//','//FI8P //','//STR(N=DI8P) + WRITE(UNIT=UNIT,FMT='(A)',IOSTAT=IOSTATD,IOMSG=IOMSGD) PREFD//' I4P: '//STR(N=I4P)//','//FI4P //','//STR(N=DI4P) + WRITE(UNIT=UNIT,FMT='(A)',IOSTAT=IOSTATD,IOMSG=IOMSGD) PREFD//' I2P: '//STR(N=I2P)//','//FI2P //','//STR(N=DI2P) + WRITE(UNIT=UNIT,FMT='(A)',IOSTAT=IOSTATD,IOMSG=IOMSGD) PREFD//' I1P: '//STR(N=I1P)//','//FI1P //','//STR(N=DI1P) + WRITE(UNIT=UNIT,FMT='(A)',IOSTAT=IOSTATD,IOMSG=IOMSGD) PREFD//'REALS MINIMUM AND MAXIMUM VALUES:' + WRITE(UNIT=UNIT,FMT='(A)',IOSTAT=IOSTATD,IOMSG=IOMSGD) PREFD//' R16P: '//STR(N=MINR16P)//','//STR(N=MAXR16P) + WRITE(UNIT=UNIT,FMT='(A)',IOSTAT=IOSTATD,IOMSG=IOMSGD) PREFD//' R8P: '//STR(N=MINR8P )//','//STR(N=MAXR8P ) + WRITE(UNIT=UNIT,FMT='(A)',IOSTAT=IOSTATD,IOMSG=IOMSGD) PREFD//' R4P: '//STR(N=MINR4P )//','//STR(N=MAXR4P ) + WRITE(UNIT=UNIT,FMT='(A)',IOSTAT=IOSTATD,IOMSG=IOMSGD) PREFD//' R_P: '//STR(N=MINR_P )//','//STR(N=MAXR_P ) + WRITE(UNIT=UNIT,FMT='(A)',IOSTAT=IOSTATD,IOMSG=IOMSGD) PREFD//'IntEGERGS MINIMUM AND MAXIMUM VALUES:' + WRITE(UNIT=UNIT,FMT='(A)',IOSTAT=IOSTATD,IOMSG=IOMSGD) PREFD//' I8P: '//STR(N=MINI8P )//','//STR(N=MAXI8P) + WRITE(UNIT=UNIT,FMT='(A)',IOSTAT=IOSTATD,IOMSG=IOMSGD) PREFD//' I4P: '//STR(N=MINI4P )//','//STR(N=MAXI4P) + WRITE(UNIT=UNIT,FMT='(A)',IOSTAT=IOSTATD,IOMSG=IOMSGD) PREFD//' I2P: '//STR(N=MINI2P )//','//STR(N=MAXI2P) + WRITE(UNIT=UNIT,FMT='(A)',IOSTAT=IOSTATD,IOMSG=IOMSGD) PREFD//' I1P: '//STR(N=MINI1P )//','//STR(N=MAXI1P) + WRITE(UNIT=UNIT,FMT='(A)',IOSTAT=IOSTATD,IOMSG=IOMSGD) PREFD//'REALS BITS/BYTES SIZES:' + WRITE(UNIT=UNIT,FMT='(A)',IOSTAT=IOSTATD,IOMSG=IOMSGD) PREFD//' R16P: '//STR(N=BIR16P)//'/'//STR(N=BYR16P) + WRITE(UNIT=UNIT,FMT='(A)',IOSTAT=IOSTATD,IOMSG=IOMSGD) PREFD//' R8P: '//STR(N=BIR8P )//'/'//STR(N=BYR8P ) + WRITE(UNIT=UNIT,FMT='(A)',IOSTAT=IOSTATD,IOMSG=IOMSGD) PREFD//' R4P: '//STR(N=BIR4P )//'/'//STR(N=BYR4P ) + WRITE(UNIT=UNIT,FMT='(A)',IOSTAT=IOSTATD,IOMSG=IOMSGD) PREFD//' R_P: '//STR(N=BIR_P )//'/'//STR(N=BYR_P ) + WRITE(UNIT=UNIT,FMT='(A)',IOSTAT=IOSTATD,IOMSG=IOMSGD) PREFD//'IntEGERS BITS/BYTES SIZES:' + WRITE(UNIT=UNIT,FMT='(A)',IOSTAT=IOSTATD,IOMSG=IOMSGD) PREFD//' I8P: '//STR(N=BII8P)//'/'//STR(N=BYI8P) + WRITE(UNIT=UNIT,FMT='(A)',IOSTAT=IOSTATD,IOMSG=IOMSGD) PREFD//' I4P: '//STR(N=BII4P)//'/'//STR(N=BYI4P) + WRITE(UNIT=UNIT,FMT='(A)',IOSTAT=IOSTATD,IOMSG=IOMSGD) PREFD//' I2P: '//STR(N=BII2P)//'/'//STR(N=BYI2P) + WRITE(UNIT=UNIT,FMT='(A)',IOSTAT=IOSTATD,IOMSG=IOMSGD) PREFD//' I1P: '//STR(N=BII1P)//'/'//STR(N=BYI1P) + WRITE(UNIT=UNIT,FMT='(A)',IOSTAT=IOSTATD,IOMSG=IOMSGD) PREFD//'SMALLEST REALS' + WRITE(UNIT=UNIT,FMT='(A)',IOSTAT=IOSTATD,IOMSG=IOMSGD) PREFD//' SMALLR16P: '//STR(SMALLR16P, .TRUE.) + WRITE(UNIT=UNIT,FMT='(A)',IOSTAT=IOSTATD,IOMSG=IOMSGD) PREFD//' SMALLR8P: '//STR(SMALLR8P, .TRUE.) + WRITE(UNIT=UNIT,FMT='(A)',IOSTAT=IOSTATD,IOMSG=IOMSGD) PREFD//' SMALLR4P: '//STR(SMALLR4P, .TRUE.) + WRITE(UNIT=UNIT,FMT='(A)',IOSTAT=IOSTATD,IOMSG=IOMSGD) PREFD//' SMALLR_P: '//STR(SMALLR_P, .TRUE.) + WRITE(UNIT=UNIT,FMT='(A)',IOSTAT=IOSTATD,IOMSG=IOMSGD) PREFD//'MACHINE ZERO' + WRITE(UNIT=UNIT,FMT='(A)',IOSTAT=IOSTATD,IOMSG=IOMSGD) PREFD//' ZEROR16P: '//STR(ZEROR16P, .TRUE.) + WRITE(UNIT=UNIT,FMT='(A)',IOSTAT=IOSTATD,IOMSG=IOMSGD) PREFD//' ZEROR8P: '//STR(ZEROR8P, .TRUE.) + WRITE(UNIT=UNIT,FMT='(A)',IOSTAT=IOSTATD,IOMSG=IOMSGD) PREFD//' ZEROR4P: '//STR(ZEROR4P, .TRUE.) + WRITE(UNIT=UNIT,FMT='(A)',IOSTAT=IOSTATD,IOMSG=IOMSGD) PREFD//' ZEROR_P: '//STR(ZEROR_P, .TRUE.) + IF (PRESENT(IOSTAT)) IOSTAT = IOSTATD + IF (PRESENT(IOMSG)) IOMSG = IOMSGD + ENDSUBROUTINE PENF_PRINT + + ! PRIVATE PROCEDURES + ELEMENTAL FUNCTION DIGIT_I8(N) RESULT(DIGIT) + !< COMPUTE THE NUMBER OF DIGITS IN DECIMAL BASE OF THE INPUT INTEGER. + !< + !<```FORTRAN + !< USE PENF + !< PRINT FI4P, DIGIT(100_I8P) + !<``` + !=> 3 <<< + INTEGER(I8P), INTENT(IN) :: N !< INPUT INTEGER. + CHARACTER(DI8P) :: STR !< RETURNED STRING CONTAINING INPUT NUMBER PLUS PADDING ZEROS. + INTEGER(I4P) :: DIGIT !< NUMBER OF DIGITS. + + WRITE(STR, FI8P) ABS(N) ! CASTING OF N TO STRING. + DIGIT = LEN_TRIM(ADJUSTL(STR)) ! CALCULATING THE DIGITS NUMBER OF N. + ENDFUNCTION DIGIT_I8 + + ELEMENTAL FUNCTION DIGIT_I4(N) RESULT(DIGIT) + !< COMPUTE THE NUMBER OF DIGITS IN DECIMAL BASE OF THE INPUT INTEGER. + !< + !<```FORTRAN + !< USE PENF + !< PRINT FI4P, DIGIT(100_I4P) + !<``` + !=> 3 <<< + INTEGER(I4P), INTENT(IN) :: N !< INPUT INTEGER. + CHARACTER(DI4P) :: STR !< RETURNED STRING CONTAINING INPUT NUMBER PLUS PADDING ZEROS. + INTEGER(I4P) :: DIGIT !< NUMBER OF DIGITS. + + WRITE(STR, FI4P) ABS(N) ! CASTING OF N TO STRING. + DIGIT = LEN_TRIM(ADJUSTL(STR)) ! CALCULATING THE DIGITS NUMBER OF N. + ENDFUNCTION DIGIT_I4 + + ELEMENTAL FUNCTION DIGIT_I2(N) RESULT(DIGIT) + !< COMPUTE THE NUMBER OF DIGITS IN DECIMAL BASE OF THE INPUT INTEGER. + !< + !<```FORTRAN + !< USE PENF + !< PRINT FI4P, DIGIT(100_I2P) + !<``` + !=> 3 <<< + INTEGER(I2P), INTENT(IN) :: N !< INPUT INTEGER. + CHARACTER(DI2P) :: STR !< RETURNED STRING CONTAINING INPUT NUMBER PLUS PADDING ZEROS. + INTEGER(I4P) :: DIGIT !< NUMBER OF DIGITS. + + WRITE(STR, FI2P) ABS(N) ! CASTING OF N TO STRING. + DIGIT = LEN_TRIM(ADJUSTL(STR)) ! CALCULATING THE DIGITS NUMBER OF N. + ENDFUNCTION DIGIT_I2 + + ELEMENTAL FUNCTION DIGIT_I1(N) RESULT(DIGIT) + !< COMPUTE THE NUMBER OF DIGITS IN DECIMAL BASE OF THE INPUT INTEGER. + !< + !<```FORTRAN + !< USE PENF + !< PRINT FI4P, DIGIT(100_I1P) + !<``` + !=> 3 <<< + INTEGER(I1P), INTENT(IN) :: N !< INPUT INTEGER. + CHARACTER(DI1P) :: STR !< RETURNED STRING CONTAINING INPUT NUMBER PLUS PADDING ZEROS. + INTEGER(I4P) :: DIGIT !< NUMBER OF DIGITS. + + WRITE(STR, FI1P) ABS(N) ! CASTING OF N TO STRING. + DIGIT = LEN_TRIM(ADJUSTL(STR)) ! CALCULATING THE DIGITS NUMBER OF N. + ENDFUNCTION DIGIT_I1 +ENDMODULE PENF + + + + + + + +!< KISS LIBRARY FOR PACKING HETEROGENEOUS DATA INTO SINGLE (HOMOGENEOUS) PACKED ONE. +! +MODULE BEFOR64_PACK_DATA_M +!< KISS LIBRARY FOR PACKING HETEROGENEOUS DATA INTO SINGLE (HOMOGENEOUS) PACKED ONE. +USE PENF + +IMPLICIT NONE +PRIVATE +PUBLIC :: PACK_DATA + +INTERFACE PACK_DATA + !< PACK DIFFERENT KINDS OF DATA INTO SINGLE I1P ARRAY. + !< + !< THIS IS USEFUL FOR ENCODING DIFFERENT (HETEROGENEOUS) KINDS VARIABLES INTO A SINGLE (HOMOGENEOUS) STREAM OF BITS. + !< @NOTE THIS PROCEDURE EXPLOITS THE `TRANSFER` BUILTIN FUNCTION, THAT FROM THE STANDARD (2003+) IS DEFINED AS + !< `TRANSFER(SOURCE, MOLD [, SIZE])`. DATA OBJECT HAVING A PHYSICAL REPRESENTATION IDENTICAL TO THAT OF `SOURCE` BUT WITH THE TYPE + !< AND TYPE PARAMETERS OF `MOLD`. THE RESULT IS OF THE SAME TYPE AND TYPE PARAMETERS AS `MOLD`. + !< IF `MOLD` IS AN ARRAY AND `SIZE` IS ABSENT, THE RESULT IS AN ARRAY AND OF RANK ONE. ITS SIZE IS AS SMALL AS POSSIBLE SUCH + !< THAT ITS PHYSICAL REPRESENTATION IS NOT SHORTER THAN THAT OF `SOURCE`. + !< + !< PRESENTLY, THE FOLLOWING COMBINATIONS ARE AVAILABLE: + !< + !<* [ ] ARRAYS-ARRAYS: + !< * [X] REAL(ANY)-REAL(ANY); + !< * [X] REAL(ANY)-INTEGER(ANY); + !< * [X] INTEGER(ANY)-INTEGER(ANY); + !< * [X] INTEGER(ANY)-REAL(ANY); + !< * [ ] REAL(ANY)-CHARACTER; + !< * [ ] CHARACTER-REAL(ANY); + !< * [ ] INTEGER(ANY)-CHARACTER; + !< * [ ] CHARACTER-INTEGER(ANY); + !<* [ ] SCALARS-SCALARS: + !< * [ ] REAL(ANY)-REAL(ANY); + !< * [ ] REAL(ANY)-INTEGER(ANY); + !< * [ ] INTEGER(ANY)-INTEGER(ANY); + !< * [ ] INTEGER(ANY)-REAL(ANY); + !< * [ ] REAL(ANY)-CHARACTER; + !< * [ ] CHARACTER-REAL(ANY); + !< * [ ] INTEGER(ANY)-CHARACTER; + !< * [ ] CHARACTER-INTEGER(ANY); + !< + !<### EXAMPLES OF USAGE + !< + !<#### PACKING TWO REAL ARRAYS, ONE WITH KIND R8P AND ONE WITH R4P + !<```ORTRAN + !<REAL(R8P):: ARRAY_R8(1:12) + !<REAL(R4P):: ARRAY_R4(-1:5) + !<INTEGER(I1P), ALLOCATABLE:: RPACK + !<... + !<CALL PACK_DATA(A1=ARRAY_R8,A2=ARRAY_R4,PACKED=RPACK) + !<``` + !<#### PACKING TWO ARRAYS, ONE REAL WITH KIND R4P AND ONE INTEGER WITH I4P + !<```ORTRAN + !<REAL(R4P):: ARRAY_R4(2) + !<INTEGER(I4P):: ARRAY_I4(0:2) + !<INTEGER(I1P), ALLOCATABLE:: RPACK + !<... + !<CALL PACK_DATA(A1=ARRAY_R4,A2=ARRAY_I4,PACKED=RPACK) + !<``` + MODULE PROCEDURE PACK_DATA_R8_R4, PACK_DATA_R8_I8, PACK_DATA_R8_I4, PACK_DATA_R8_I2, PACK_DATA_R8_I1, & + PACK_DATA_R4_R8, PACK_DATA_R4_I8, PACK_DATA_R4_I4, PACK_DATA_R4_I2, PACK_DATA_R4_I1, & + PACK_DATA_I8_R8, PACK_DATA_I8_R4, PACK_DATA_I8_I4, PACK_DATA_I8_I2, PACK_DATA_I8_I1, & + PACK_DATA_I4_R8, PACK_DATA_I4_R4, PACK_DATA_I4_I8, PACK_DATA_I4_I2, PACK_DATA_I4_I1, & + PACK_DATA_I2_R8, PACK_DATA_I2_R4, PACK_DATA_I2_I8, PACK_DATA_I2_I4, PACK_DATA_I2_I1, & + PACK_DATA_I1_R8, PACK_DATA_I1_R4, PACK_DATA_I1_I8, PACK_DATA_I1_I4, PACK_DATA_I1_I2 +ENDINTERFACE + +CONTAINS + PURE SUBROUTINE PACK_DATA_R8_R4(A1, A2, PACKED) + !< PACK DIFFERENT KINDS OF DATA INTO SINGLE I1P ARRAY. + !< + !<```FORTRAN + !< USE BEFOR64 + !< USE PENF + !< REAL(R8P) :: A1(1) + !< REAL(R4P) :: A2(1) + !< INTEGER(I1P), ALLOCATABLE :: PACK(:) + !< A1(1) = 0 + !< A2(1) = 1 + !< CALL PACK_DATA(A1=A1, A2=A2, PACKED=PACK) + !< PRINT *, PACK(SIZE(PACK, DIM=1)) + !<``` + !=> 63 <<< + REAL(R8P), INTENT(IN) :: A1(1:) !< FIRS DATA STREAM. + REAL(R4P), INTENT(IN) :: A2(1:) !< SECOND DATA STREAM. + INTEGER(I1P), ALLOCATABLE, INTENT(INOUT) :: PACKED(:) !< PACKED DATA INTO I1P ARRAY. + INTEGER(I1P), ALLOCATABLE :: P1(:) !< TEMPORARY PACKED DATA OF FIRST STREAM. + INTEGER(I1P), ALLOCATABLE :: P2(:) !< TEMPORARY PACKED DATA OF SECOND STREAM. + + P1 = TRANSFER(A1,P1) + P2 = TRANSFER(A2,P2) + PACKED = [P1,P2] + ENDSUBROUTINE PACK_DATA_R8_R4 + + PURE SUBROUTINE PACK_DATA_R8_I8(A1, A2, PACKED) + !< PACK DIFFERENT KINDS OF DATA INTO SINGLE I1P ARRAY. + !< + !<```FORTRAN + !< USE BEFOR64 + !< USE PENF + !< REAL(R8P) :: A1(1) + !< INTEGER(I8P) :: A2(1) + !< INTEGER(I1P), ALLOCATABLE :: PACK(:) + !< A1(1) = 0 + !< A2(1) = 1 + !< CALL PACK_DATA(A1=A1, A2=A2, PACKED=PACK) + !< PRINT *, PACK(9) + !<``` + !=> 1 <<< + REAL(R8P), INTENT(IN) :: A1(1:) !< FIRST DATA STREAM. + INTEGER(I8P), INTENT(IN) :: A2(1:) !< SECOND DATA STREAM. + INTEGER(I1P), ALLOCATABLE, INTENT(INOUT) :: PACKED(:) !< PACKED DATA INTO I1P ARRAY. + INTEGER(I1P), ALLOCATABLE :: P1(:) !< TEMPORARY PACKED DATA OF FIRST STREAM. + INTEGER(I1P), ALLOCATABLE :: P2(:) !< TEMPORARY PACKED DATA OF SECOND STREAM. + + P1 = TRANSFER(A1,P1) + P2 = TRANSFER(A2,P2) + PACKED = [P1,P2] + ENDSUBROUTINE PACK_DATA_R8_I8 + + PURE SUBROUTINE PACK_DATA_R8_I4(A1, A2, PACKED) + !< PACK DIFFERENT KINDS OF DATA INTO SINGLE I1P ARRAY. + !< + !<```FORTRAN + !< USE BEFOR64 + !< USE PENF + !< REAL(R8P) :: A1(1) + !< INTEGER(I4P) :: A2(1) + !< INTEGER(I1P), ALLOCATABLE :: PACK(:) + !< A1(1) = 0 + !< A2(1) = 1 + !< CALL PACK_DATA(A1=A1, A2=A2, PACKED=PACK) + !< PRINT *, PACK(9) + !<``` + !=> 1 <<< + REAL(R8P), INTENT(IN) :: A1(1:) !< FIRST DATA STREAM. + INTEGER(I4P), INTENT(IN) :: A2(1:) !< SECOND DATA STREAM. + INTEGER(I1P), ALLOCATABLE, INTENT(INOUT) :: PACKED(:) !< PACKED DATA INTO I1P ARRAY. + INTEGER(I1P), ALLOCATABLE :: P1(:) !< TEMPORARY PACKED DATA OF FIRST STREAM. + INTEGER(I1P), ALLOCATABLE :: P2(:) !< TEMPORARY PACKED DATA OF SECOND STREAM. + + P1 = TRANSFER(A1,P1) + P2 = TRANSFER(A2,P2) + PACKED = [P1,P2] + ENDSUBROUTINE PACK_DATA_R8_I4 + + PURE SUBROUTINE PACK_DATA_R8_I2(A1, A2, PACKED) + !< PACK DIFFERENT KINDS OF DATA INTO SINGLE I1P ARRAY. + !< + !<```FORTRAN + !< USE BEFOR64 + !< USE PENF + !< REAL(R8P) :: A1(1) + !< INTEGER(I2P) :: A2(1) + !< INTEGER(I1P), ALLOCATABLE :: PACK(:) + !< A1(1) = 0 + !< A2(1) = 1 + !< CALL PACK_DATA(A1=A1, A2=A2, PACKED=PACK) + !< PRINT *, PACK(9) + !<``` + !=> 1 <<< + REAL(R8P), INTENT(IN) :: A1(1:) !< FIRST DATA STREAM. + INTEGER(I2P), INTENT(IN) :: A2(1:) !< SECOND DATA STREAM. + INTEGER(I1P), ALLOCATABLE, INTENT(INOUT) :: PACKED(:) !< PACKED DATA INTO I1P ARRAY. + INTEGER(I1P), ALLOCATABLE :: P1(:) !< TEMPORARY PACKED DATA OF FIRST STREAM. + INTEGER(I1P), ALLOCATABLE :: P2(:) !< TEMPORARY PACKED DATA OF SECOND STREAM. + + P1 = TRANSFER(A1,P1) + P2 = TRANSFER(A2,P2) + PACKED = [P1,P2] + ENDSUBROUTINE PACK_DATA_R8_I2 + + PURE SUBROUTINE PACK_DATA_R8_I1(A1, A2, PACKED) + !< PACK DIFFERENT KINDS OF DATA INTO SINGLE I1P ARRAY. + !< + !<```FORTRAN + !< USE BEFOR64 + !< USE PENF + !< REAL(R8P) :: A1(1) + !< INTEGER(I1P) :: A2(1) + !< INTEGER(I1P), ALLOCATABLE :: PACK(:) + !< A1(1) = 0 + !< A2(1) = 1 + !< CALL PACK_DATA(A1=A1, A2=A2, PACKED=PACK) + !< PRINT *, PACK(9) + !<``` + !=> 1 <<< + REAL(R8P), INTENT(IN) :: A1(1:) !< FIRST DATA STREAM. + INTEGER(I1P), INTENT(IN) :: A2(1:) !< SECOND DATA STREAM. + INTEGER(I1P), ALLOCATABLE, INTENT(INOUT) :: PACKED(:) !< PACKED DATA INTO I1P ARRAY. + INTEGER(I1P), ALLOCATABLE :: P1(:) !< TEMPORARY PACKED DATA OF FIRST STREAM. + INTEGER(I1P), ALLOCATABLE :: P2(:) !< TEMPORARY PACKED DATA OF SECOND STREAM. + + P1 = TRANSFER(A1,P1) + P2 = TRANSFER(A2,P2) + PACKED = [P1,P2] + ENDSUBROUTINE PACK_DATA_R8_I1 + + PURE SUBROUTINE PACK_DATA_R4_R8(A1, A2, PACKED) + !< PACK DIFFERENT KINDS OF DATA INTO SINGLE I1P ARRAY. + !< + !<```FORTRAN + !< USE BEFOR64 + !< USE PENF + !< REAL(R4P) :: A1(1) + !< REAL(R8P) :: A2(1) + !< INTEGER(I1P), ALLOCATABLE :: PACK(:) + !< A1(1) = 0 + !< A2(1) = 1 + !< CALL PACK_DATA(A1=A1, A2=A2, PACKED=PACK) + !< PRINT *, PACK(SIZE(PACK, DIM=1)) + !<``` + !=> 63 <<< + REAL(R4P), INTENT(IN) :: A1(1:) !< FIRS DATA STREAM. + REAL(R8P), INTENT(IN) :: A2(1:) !< SECOND DATA STREAM. + INTEGER(I1P), ALLOCATABLE, INTENT(INOUT) :: PACKED(:) !< PACKED DATA INTO I1P ARRAY. + INTEGER(I1P), ALLOCATABLE :: P1(:) !< TEMPORARY PACKED DATA OF FIRST STREAM. + INTEGER(I1P), ALLOCATABLE :: P2(:) !< TEMPORARY PACKED DATA OF SECOND STREAM. + + P1 = TRANSFER(A1,P1) + P2 = TRANSFER(A2,P2) + PACKED = [P1,P2] + ENDSUBROUTINE PACK_DATA_R4_R8 + + PURE SUBROUTINE PACK_DATA_R4_I8(A1, A2, PACKED) + !< PACK DIFFERENT KINDS OF DATA INTO SINGLE I1P ARRAY. + !< + !<```FORTRAN + !< USE BEFOR64 + !< USE PENF + !< REAL(R4P) :: A1(1) + !< INTEGER(I8P) :: A2(1) + !< INTEGER(I1P), ALLOCATABLE :: PACK(:) + !< A1(1) = 0 + !< A2(1) = 1 + !< CALL PACK_DATA(A1=A1, A2=A2, PACKED=PACK) + !< PRINT *, PACK(5) + !<``` + !=> 1 <<< + REAL(R4P), INTENT(IN) :: A1(1:) !< FIRST DATA STREAM. + INTEGER(I8P), INTENT(IN) :: A2(1:) !< SECOND DATA STREAM. + INTEGER(I1P), ALLOCATABLE, INTENT(INOUT) :: PACKED(:) !< PACKED DATA INTO I1P ARRAY. + INTEGER(I1P), ALLOCATABLE :: P1(:) !< TEMPORARY PACKED DATA OF FIRST STREAM. + INTEGER(I1P), ALLOCATABLE :: P2(:) !< TEMPORARY PACKED DATA OF SECOND STREAM. + + P1 = TRANSFER(A1,P1) + P2 = TRANSFER(A2,P2) + PACKED = [P1,P2] + ENDSUBROUTINE PACK_DATA_R4_I8 + + PURE SUBROUTINE PACK_DATA_R4_I4(A1, A2, PACKED) + !< PACK DIFFERENT KINDS OF DATA INTO SINGLE I1P ARRAY. + !< + !<```FORTRAN + !< USE BEFOR64 + !< USE PENF + !< REAL(R4P) :: A1(1) + !< INTEGER(I4P) :: A2(1) + !< INTEGER(I1P), ALLOCATABLE :: PACK(:) + !< A1(1) = 0 + !< A2(1) = 1 + !< CALL PACK_DATA(A1=A1, A2=A2, PACKED=PACK) + !< PRINT *, PACK(5) + !<``` + !=> 1 <<< + REAL(R4P), INTENT(IN) :: A1(1:) !< FIRST DATA STREAM. + INTEGER(I4P), INTENT(IN) :: A2(1:) !< SECOND DATA STREAM. + INTEGER(I1P), ALLOCATABLE, INTENT(INOUT) :: PACKED(:) !< PACKED DATA INTO I1P ARRAY. + INTEGER(I1P), ALLOCATABLE :: P1(:) !< TEMPORARY PACKED DATA OF FIRST STREAM. + INTEGER(I1P), ALLOCATABLE :: P2(:) !< TEMPORARY PACKED DATA OF SECOND STREAM. + + P1 = TRANSFER(A1,P1) + P2 = TRANSFER(A2,P2) + PACKED = [P1,P2] + ENDSUBROUTINE PACK_DATA_R4_I4 + + PURE SUBROUTINE PACK_DATA_R4_I2(A1, A2, PACKED) + !< PACK DIFFERENT KINDS OF DATA INTO SINGLE I1P ARRAY. + !< + !<```FORTRAN + !< USE BEFOR64 + !< USE PENF + !< REAL(R4P) :: A1(1) + !< INTEGER(I2P) :: A2(1) + !< INTEGER(I1P), ALLOCATABLE :: PACK(:) + !< A1(1) = 0 + !< A2(1) = 1 + !< CALL PACK_DATA(A1=A1, A2=A2, PACKED=PACK) + !< PRINT *, PACK(5) + !<``` + !=> 1 <<< + REAL(R4P), INTENT(IN) :: A1(1:) !< FIRST DATA STREAM. + INTEGER(I2P), INTENT(IN) :: A2(1:) !< SECOND DATA STREAM. + INTEGER(I1P), ALLOCATABLE, INTENT(INOUT) :: PACKED(:) !< PACKED DATA INTO I1P ARRAY. + INTEGER(I1P), ALLOCATABLE :: P1(:) !< TEMPORARY PACKED DATA OF FIRST STREAM. + INTEGER(I1P), ALLOCATABLE :: P2(:) !< TEMPORARY PACKED DATA OF SECOND STREAM. + + P1 = TRANSFER(A1,P1) + P2 = TRANSFER(A2,P2) + PACKED = [P1,P2] + ENDSUBROUTINE PACK_DATA_R4_I2 + + PURE SUBROUTINE PACK_DATA_R4_I1(A1, A2, PACKED) + !< PACK DIFFERENT KINDS OF DATA INTO SINGLE I1P ARRAY. + !< + !<```FORTRAN + !< USE BEFOR64 + !< USE PENF + !< REAL(R4P) :: A1(1) + !< INTEGER(I1P) :: A2(1) + !< INTEGER(I1P), ALLOCATABLE :: PACK(:) + !< A1(1) = 0 + !< A2(1) = 1 + !< CALL PACK_DATA(A1=A1, A2=A2, PACKED=PACK) + !< PRINT *, PACK(5) + !<``` + !=> 1 <<< + REAL(R4P), INTENT(IN) :: A1(1:) !< FIRST DATA STREAM. + INTEGER(I1P), INTENT(IN) :: A2(1:) !< SECOND DATA STREAM. + INTEGER(I1P), ALLOCATABLE, INTENT(INOUT) :: PACKED(:) !< PACKED DATA INTO I1P ARRAY. + INTEGER(I1P), ALLOCATABLE :: P1(:) !< TEMPORARY PACKED DATA OF FIRST STREAM. + INTEGER(I1P), ALLOCATABLE :: P2(:) !< TEMPORARY PACKED DATA OF SECOND STREAM. + + P1 = TRANSFER(A1,P1) + P2 = TRANSFER(A2,P2) + PACKED = [P1,P2] + ENDSUBROUTINE PACK_DATA_R4_I1 + + PURE SUBROUTINE PACK_DATA_I8_R8(A1, A2, PACKED) + !< PACK DIFFERENT KINDS OF DATA INTO SINGLE I1P ARRAY. + !< + !<```FORTRAN + !< USE BEFOR64 + !< USE PENF + !< INTEGER(I8P) :: A1(1) + !< REAL(R8P) :: A2(1) + !< INTEGER(I1P), ALLOCATABLE :: PACK(:) + !< A1(1) = 0 + !< A2(1) = 1 + !< CALL PACK_DATA(A1=A1, A2=A2, PACKED=PACK) + !< PRINT *, PACK(SIZE(PACK, DIM=1)) + !<``` + !=> 63 <<< + INTEGER(I8P), INTENT(IN) :: A1(1:) !< FIRST DATA STREAM. + REAL(R8P), INTENT(IN) :: A2(1:) !< SECOND DATA STREAM. + INTEGER(I1P), ALLOCATABLE, INTENT(INOUT) :: PACKED(:) !< PACKED DATA INTO I1P ARRAY. + INTEGER(I1P), ALLOCATABLE :: P1(:) !< TEMPORARY PACKED DATA OF FIRST STREAM. + INTEGER(I1P), ALLOCATABLE :: P2(:) !< TEMPORARY PACKED DATA OF SECOND STREAM. + + P1 = TRANSFER(A1,P1) + P2 = TRANSFER(A2,P2) + PACKED = [P1,P2] + ENDSUBROUTINE PACK_DATA_I8_R8 + + PURE SUBROUTINE PACK_DATA_I8_R4(A1, A2, PACKED) + !< PACK DIFFERENT KINDS OF DATA INTO SINGLE I1P ARRAY. + !< + !<```FORTRAN + !< USE BEFOR64 + !< USE PENF + !< INTEGER(I8P) :: A1(1) + !< REAL(R4P) :: A2(1) + !< INTEGER(I1P), ALLOCATABLE :: PACK(:) + !< A1(1) = 0 + !< A2(1) = 1 + !< CALL PACK_DATA(A1=A1, A2=A2, PACKED=PACK) + !< PRINT *, PACK(SIZE(PACK, DIM=1)) + !<``` + !=> 63 <<< + INTEGER(I8P), INTENT(IN) :: A1(1:) !< FIRST DATA STREAM. + REAL(R4P), INTENT(IN) :: A2(1:) !< SECOND DATA STREAM. + INTEGER(I1P), ALLOCATABLE, INTENT(INOUT) :: PACKED(:) !< PACKED DATA INTO I1P ARRAY. + INTEGER(I1P), ALLOCATABLE :: P1(:) !< TEMPORARY PACKED DATA OF FIRST STREAM. + INTEGER(I1P), ALLOCATABLE :: P2(:) !< TEMPORARY PACKED DATA OF SECOND STREAM. + + P1 = TRANSFER(A1,P1) + P2 = TRANSFER(A2,P2) + PACKED = [P1,P2] + ENDSUBROUTINE PACK_DATA_I8_R4 + + PURE SUBROUTINE PACK_DATA_I8_I4(A1, A2, PACKED) + !< PACK DIFFERENT KINDS OF DATA INTO SINGLE I1P ARRAY. + !< + !<```FORTRAN + !< USE BEFOR64 + !< USE PENF + !< INTEGER(I8P) :: A1(1) + !< INTEGER(I4P) :: A2(1) + !< INTEGER(I1P), ALLOCATABLE :: PACK(:) + !< A1(1) = 0 + !< A2(1) = 1 + !< CALL PACK_DATA(A1=A1, A2=A2, PACKED=PACK) + !< PRINT *, PACK(9) + !<``` + !=> 1 <<< + INTEGER(I8P), INTENT(IN) :: A1(1:) !< FIRST DATA STREAM. + INTEGER(I4P), INTENT(IN) :: A2(1:) !< SECOND DATA STREAM. + INTEGER(I1P), ALLOCATABLE, INTENT(INOUT) :: PACKED(:) !< PACKED DATA INTO I1P ARRAY. + INTEGER(I1P), ALLOCATABLE :: P1(:) !< TEMPORARY PACKED DATA OF FIRST STREAM. + INTEGER(I1P), ALLOCATABLE :: P2(:) !< TEMPORARY PACKED DATA OF SECOND STREAM. + + P1 = TRANSFER(A1,P1) + P2 = TRANSFER(A2,P2) + PACKED = [P1,P2] + ENDSUBROUTINE PACK_DATA_I8_I4 + + PURE SUBROUTINE PACK_DATA_I8_I2(A1, A2, PACKED) + !< PACK DIFFERENT KINDS OF DATA INTO SINGLE I1P ARRAY. + !< + !<```FORTRAN + !< USE BEFOR64 + !< USE PENF + !< INTEGER(I8P) :: A1(1) + !< INTEGER(I2P) :: A2(1) + !< INTEGER(I1P), ALLOCATABLE :: PACK(:) + !< A1(1) = 0 + !< A2(1) = 1 + !< CALL PACK_DATA(A1=A1, A2=A2, PACKED=PACK) + !< PRINT *, PACK(9) + !<``` + !=> 1 <<< + INTEGER(I8P), INTENT(IN) :: A1(1:) !< FIRST DATA STREAM. + INTEGER(I2P), INTENT(IN) :: A2(1:) !< SECOND DATA STREAM. + INTEGER(I1P), ALLOCATABLE, INTENT(INOUT) :: PACKED(:) !< PACKED DATA INTO I1P ARRAY. + INTEGER(I1P), ALLOCATABLE :: P1(:) !< TEMPORARY PACKED DATA OF FIRST STREAM. + INTEGER(I1P), ALLOCATABLE :: P2(:) !< TEMPORARY PACKED DATA OF SECOND STREAM. + + P1 = TRANSFER(A1,P1) + P2 = TRANSFER(A2,P2) + PACKED = [P1,P2] + ENDSUBROUTINE PACK_DATA_I8_I2 + + PURE SUBROUTINE PACK_DATA_I8_I1(A1, A2, PACKED) + !< PACK DIFFERENT KINDS OF DATA INTO SINGLE I1P ARRAY. + !< + !<```FORTRAN + !< USE BEFOR64 + !< USE PENF + !< INTEGER(I8P) :: A1(1) + !< INTEGER(I1P) :: A2(1) + !< INTEGER(I1P), ALLOCATABLE :: PACK(:) + !< A1(1) = 0 + !< A2(1) = 1 + !< CALL PACK_DATA(A1=A1, A2=A2, PACKED=PACK) + !< PRINT *, PACK(9) + !<``` + !=> 1 <<< + INTEGER(I8P), INTENT(IN) :: A1(1:) !< FIRST DATA STREAM. + INTEGER(I1P), INTENT(IN) :: A2(1:) !< SECOND DATA STREAM. + INTEGER(I1P), ALLOCATABLE, INTENT(INOUT) :: PACKED(:) !< PACKED DATA INTO I1P ARRAY. + INTEGER(I1P), ALLOCATABLE :: P1(:) !< TEMPORARY PACKED DATA OF FIRST STREAM. + INTEGER(I1P), ALLOCATABLE :: P2(:) !< TEMPORARY PACKED DATA OF SECOND STREAM. + + P1 = TRANSFER(A1,P1) + P2 = TRANSFER(A2,P2) + PACKED = [P1,P2] + ENDSUBROUTINE PACK_DATA_I8_I1 + + PURE SUBROUTINE PACK_DATA_I4_R8(A1, A2, PACKED) + !< PACK DIFFERENT KINDS OF DATA INTO SINGLE I1P ARRAY. + !< + !<```FORTRAN + !< USE BEFOR64 + !< USE PENF + !< INTEGER(I4P) :: A1(1) + !< REAL(R8P) :: A2(1) + !< INTEGER(I1P), ALLOCATABLE :: PACK(:) + !< A1(1) = 0 + !< A2(1) = 1 + !< CALL PACK_DATA(A1=A1, A2=A2, PACKED=PACK) + !< PRINT *, PACK(SIZE(PACK, DIM=1)) + !<``` + !=> 63 <<< + INTEGER(I4P), INTENT(IN) :: A1(1:) !< FIRST DATA STREAM. + REAL(R8P), INTENT(IN) :: A2(1:) !< SECOND DATA STREAM. + INTEGER(I1P), ALLOCATABLE, INTENT(INOUT) :: PACKED(:) !< PACKED DATA INTO I1P ARRAY. + INTEGER(I1P), ALLOCATABLE :: P1(:) !< TEMPORARY PACKED DATA OF FIRST STREAM. + INTEGER(I1P), ALLOCATABLE :: P2(:) !< TEMPORARY PACKED DATA OF SECOND STREAM. + + P1 = TRANSFER(A1,P1) + P2 = TRANSFER(A2,P2) + PACKED = [P1,P2] + ENDSUBROUTINE PACK_DATA_I4_R8 + + PURE SUBROUTINE PACK_DATA_I4_R4(A1, A2, PACKED) + !< PACK DIFFERENT KINDS OF DATA INTO SINGLE I1P ARRAY. + !< + !<```FORTRAN + !< USE BEFOR64 + !< USE PENF + !< INTEGER(I4P) :: A1(1) + !< REAL(R4P) :: A2(1) + !< INTEGER(I1P), ALLOCATABLE :: PACK(:) + !< A1(1) = 0 + !< A2(1) = 1 + !< CALL PACK_DATA(A1=A1, A2=A2, PACKED=PACK) + !< PRINT *, PACK(SIZE(PACK, DIM=1)) + !<``` + !=> 63 <<< + INTEGER(I4P), INTENT(IN) :: A1(1:) !< FIRST DATA STREAM. + REAL(R4P), INTENT(IN) :: A2(1:) !< SECOND DATA STREAM. + INTEGER(I1P), ALLOCATABLE, INTENT(INOUT) :: PACKED(:) !< PACKED DATA INTO I1P ARRAY. + INTEGER(I1P), ALLOCATABLE :: P1(:) !< TEMPORARY PACKED DATA OF FIRST STREAM. + INTEGER(I1P), ALLOCATABLE :: P2(:) !< TEMPORARY PACKED DATA OF SECOND STREAM. + + P1 = TRANSFER(A1,P1) + P2 = TRANSFER(A2,P2) + PACKED = [P1,P2] + ENDSUBROUTINE PACK_DATA_I4_R4 + + PURE SUBROUTINE PACK_DATA_I4_I8(A1, A2, PACKED) + !< PACK DIFFERENT KINDS OF DATA INTO SINGLE I1P ARRAY. + !< + !<```FORTRAN + !< USE BEFOR64 + !< USE PENF + !< INTEGER(I4P) :: A1(1) + !< INTEGER(I8P) :: A2(1) + !< INTEGER(I1P), ALLOCATABLE :: PACK(:) + !< A1(1) = 0 + !< A2(1) = 1 + !< CALL PACK_DATA(A1=A1, A2=A2, PACKED=PACK) + !< PRINT *, PACK(5) + !<``` + !=> 1 <<< + INTEGER(I4P), INTENT(IN) :: A1(1:) !< FIRST DATA STREAM. + INTEGER(I8P), INTENT(IN) :: A2(1:) !< SECOND DATA STREAM. + INTEGER(I1P), ALLOCATABLE, INTENT(INOUT) :: PACKED(:) !< PACKED DATA INTO I1P ARRAY. + INTEGER(I1P), ALLOCATABLE :: P1(:) !< TEMPORARY PACKED DATA OF FIRST STREAM. + INTEGER(I1P), ALLOCATABLE :: P2(:) !< TEMPORARY PACKED DATA OF SECOND STREAM. + + P1 = TRANSFER(A1,P1) + P2 = TRANSFER(A2,P2) + PACKED = [P1,P2] + ENDSUBROUTINE PACK_DATA_I4_I8 + + PURE SUBROUTINE PACK_DATA_I4_I2(A1, A2, PACKED) + !< PACK DIFFERENT KINDS OF DATA INTO SINGLE I1P ARRAY. + !< + !<```FORTRAN + !< USE BEFOR64 + !< USE PENF + !< INTEGER(I4P) :: A1(1) + !< INTEGER(I2P) :: A2(1) + !< INTEGER(I1P), ALLOCATABLE :: PACK(:) + !< A1(1) = 0 + !< A2(1) = 1 + !< CALL PACK_DATA(A1=A1, A2=A2, PACKED=PACK) + !< PRINT *, PACK(5) + !<``` + !=> 1 <<< + INTEGER(I4P), INTENT(IN) :: A1(1:) !< FIRST DATA STREAM. + INTEGER(I2P), INTENT(IN) :: A2(1:) !< SECOND DATA STREAM. + INTEGER(I1P), ALLOCATABLE, INTENT(INOUT) :: PACKED(:) !< PACKED DATA INTO I1P ARRAY. + INTEGER(I1P), ALLOCATABLE :: P1(:) !< TEMPORARY PACKED DATA OF FIRST STREAM. + INTEGER(I1P), ALLOCATABLE :: P2(:) !< TEMPORARY PACKED DATA OF SECOND STREAM. + + P1 = TRANSFER(A1,P1) + P2 = TRANSFER(A2,P2) + PACKED = [P1,P2] + ENDSUBROUTINE PACK_DATA_I4_I2 + + PURE SUBROUTINE PACK_DATA_I4_I1(A1, A2, PACKED) + !< PACK DIFFERENT KINDS OF DATA INTO SINGLE I1P ARRAY. + !< + !<```FORTRAN + !< USE BEFOR64 + !< USE PENF + !< INTEGER(I4P) :: A1(1) + !< INTEGER(I1P) :: A2(1) + !< INTEGER(I1P), ALLOCATABLE :: PACK(:) + !< A1(1) = 0 + !< A2(1) = 1 + !< CALL PACK_DATA(A1=A1, A2=A2, PACKED=PACK) + !< PRINT *, PACK(5) + !<``` + !=> 1 <<< + INTEGER(I4P), INTENT(IN) :: A1(1:) !< FIRST DATA STREAM. + INTEGER(I1P), INTENT(IN) :: A2(1:) !< SECOND DATA STREAM. + INTEGER(I1P), ALLOCATABLE, INTENT(INOUT) :: PACKED(:) !< PACKED DATA INTO I1P ARRAY. + INTEGER(I1P), ALLOCATABLE :: P1(:) !< TEMPORARY PACKED DATA OF FIRST STREAM. + INTEGER(I1P), ALLOCATABLE :: P2(:) !< TEMPORARY PACKED DATA OF SECOND STREAM. + + P1 = TRANSFER(A1,P1) + P2 = TRANSFER(A2,P2) + PACKED = [P1,P2] + ENDSUBROUTINE PACK_DATA_I4_I1 + + PURE SUBROUTINE PACK_DATA_I2_R8(A1, A2, PACKED) + !< PACK DIFFERENT KINDS OF DATA INTO SINGLE I1P ARRAY. + !< + !<```FORTRAN + !< USE BEFOR64 + !< USE PENF + !< INTEGER(I2P) :: A1(1) + !< REAL(R8P) :: A2(1) + !< INTEGER(I1P), ALLOCATABLE :: PACK(:) + !< A1(1) = 0 + !< A2(1) = 1 + !< CALL PACK_DATA(A1=A1, A2=A2, PACKED=PACK) + !< PRINT *, PACK(SIZE(PACK, DIM=1)) + !<``` + !=> 63 <<< + INTEGER(I2P), INTENT(IN) :: A1(1:) !< FIRST DATA STREAM. + REAL(R8P), INTENT(IN) :: A2(1:) !< SECOND DATA STREAM. + INTEGER(I1P), ALLOCATABLE, INTENT(INOUT) :: PACKED(:) !< PACKED DATA INTO I1P ARRAY. + INTEGER(I1P), ALLOCATABLE :: P1(:) !< TEMPORARY PACKED DATA OF FIRST STREAM. + INTEGER(I1P), ALLOCATABLE :: P2(:) !< TEMPORARY PACKED DATA OF SECOND STREAM. + + P1 = TRANSFER(A1,P1) + P2 = TRANSFER(A2,P2) + PACKED = [P1,P2] + ENDSUBROUTINE PACK_DATA_I2_R8 + + PURE SUBROUTINE PACK_DATA_I2_R4(A1, A2, PACKED) + !< PACK DIFFERENT KINDS OF DATA INTO SINGLE I1P ARRAY. + !< + !<```FORTRAN + !< USE BEFOR64 + !< USE PENF + !< INTEGER(I2P) :: A1(1) + !< REAL(R4P) :: A2(1) + !< INTEGER(I1P), ALLOCATABLE :: PACK(:) + !< A1(1) = 0 + !< A2(1) = 1 + !< CALL PACK_DATA(A1=A1, A2=A2, PACKED=PACK) + !< PRINT *, PACK(SIZE(PACK, DIM=1)) + !<``` + !=> 63 <<< + INTEGER(I2P), INTENT(IN) :: A1(1:) !< FIRST DATA STREAM. + REAL(R4P), INTENT(IN) :: A2(1:) !< SECOND DATA STREAM. + INTEGER(I1P), ALLOCATABLE, INTENT(INOUT) :: PACKED(:) !< PACKED DATA INTO I1P ARRAY. + INTEGER(I1P), ALLOCATABLE :: P1(:) !< TEMPORARY PACKED DATA OF FIRST STREAM. + INTEGER(I1P), ALLOCATABLE :: P2(:) !< TEMPORARY PACKED DATA OF SECOND STREAM. + + P1 = TRANSFER(A1,P1) + P2 = TRANSFER(A2,P2) + PACKED = [P1,P2] + ENDSUBROUTINE PACK_DATA_I2_R4 + + PURE SUBROUTINE PACK_DATA_I2_I8(A1, A2, PACKED) + !< PACK DIFFERENT KINDS OF DATA INTO SINGLE I1P ARRAY. + !< + !<```FORTRAN + !< USE BEFOR64 + !< USE PENF + !< INTEGER(I2P) :: A1(1) + !< INTEGER(I8P) :: A2(1) + !< INTEGER(I1P), ALLOCATABLE :: PACK(:) + !< A1(1) = 0 + !< A2(1) = 1 + !< CALL PACK_DATA(A1=A1, A2=A2, PACKED=PACK) + !< PRINT *, PACK(3) + !<``` + !=> 1 <<< + INTEGER(I2P), INTENT(IN) :: A1(1:) !< FIRST DATA STREAM. + INTEGER(I8P), INTENT(IN) :: A2(1:) !< SECOND DATA STREAM. + INTEGER(I1P), ALLOCATABLE, INTENT(INOUT) :: PACKED(:) !< PACKED DATA INTO I1P ARRAY. + INTEGER(I1P), ALLOCATABLE :: P1(:) !< TEMPORARY PACKED DATA OF FIRST STREAM. + INTEGER(I1P), ALLOCATABLE :: P2(:) !< TEMPORARY PACKED DATA OF SECOND STREAM. + + P1 = TRANSFER(A1,P1) + P2 = TRANSFER(A2,P2) + PACKED = [P1,P2] + ENDSUBROUTINE PACK_DATA_I2_I8 + + PURE SUBROUTINE PACK_DATA_I2_I4(A1, A2, PACKED) + !< PACK DIFFERENT KINDS OF DATA INTO SINGLE I1P ARRAY. + !< + !<```FORTRAN + !< USE BEFOR64 + !< USE PENF + !< INTEGER(I2P) :: A1(1) + !< INTEGER(I4P) :: A2(1) + !< INTEGER(I1P), ALLOCATABLE :: PACK(:) + !< A1(1) = 0 + !< A2(1) = 1 + !< CALL PACK_DATA(A1=A1, A2=A2, PACKED=PACK) + !< PRINT *, PACK(3) + !<``` + !=> 1 <<< + INTEGER(I2P), INTENT(IN) :: A1(1:) !< FIRST DATA STREAM. + INTEGER(I4P), INTENT(IN) :: A2(1:) !< SECOND DATA STREAM. + INTEGER(I1P), ALLOCATABLE, INTENT(INOUT) :: PACKED(:) !< PACKED DATA INTO I1P ARRAY. + INTEGER(I1P), ALLOCATABLE :: P1(:) !< TEMPORARY PACKED DATA OF FIRST STREAM. + INTEGER(I1P), ALLOCATABLE :: P2(:) !< TEMPORARY PACKED DATA OF SECOND STREAM. + + P1 = TRANSFER(A1,P1) + P2 = TRANSFER(A2,P2) + PACKED = [P1,P2] + ENDSUBROUTINE PACK_DATA_I2_I4 + + PURE SUBROUTINE PACK_DATA_I2_I1(A1, A2, PACKED) + !< PACK DIFFERENT KINDS OF DATA INTO SINGLE I1P ARRAY. + !< + !<```FORTRAN + !< USE BEFOR64 + !< USE PENF + !< INTEGER(I2P) :: A1(1) + !< INTEGER(I1P) :: A2(1) + !< INTEGER(I1P), ALLOCATABLE :: PACK(:) + !< A1(1) = 0 + !< A2(1) = 1 + !< CALL PACK_DATA(A1=A1, A2=A2, PACKED=PACK) + !< PRINT *, PACK(3) + !<``` + !=> 1 <<< + INTEGER(I2P), INTENT(IN) :: A1(1:) !< FIRST DATA STREAM. + INTEGER(I1P), INTENT(IN) :: A2(1:) !< SECOND DATA STREAM. + INTEGER(I1P), ALLOCATABLE, INTENT(INOUT) :: PACKED(:) !< PACKED DATA INTO I1P ARRAY. + INTEGER(I1P), ALLOCATABLE :: P1(:) !< TEMPORARY PACKED DATA OF FIRST STREAM. + INTEGER(I1P), ALLOCATABLE :: P2(:) !< TEMPORARY PACKED DATA OF SECOND STREAM. + + P1 = TRANSFER(A1,P1) + P2 = TRANSFER(A2,P2) + PACKED = [P1,P2] + ENDSUBROUTINE PACK_DATA_I2_I1 + + PURE SUBROUTINE PACK_DATA_I1_R8(A1, A2, PACKED) + !< PACK DIFFERENT KINDS OF DATA INTO SINGLE I1P ARRAY. + !< + !<```FORTRAN + !< USE BEFOR64 + !< USE PENF + !< INTEGER(I1P) :: A1(1) + !< REAL(R8P) :: A2(1) + !< INTEGER(I1P), ALLOCATABLE :: PACK(:) + !< A1(1) = 0 + !< A2(1) = 1 + !< CALL PACK_DATA(A1=A1, A2=A2, PACKED=PACK) + !< PRINT *, PACK(SIZE(PACK, DIM=1)) + !<``` + !=> 63 <<< + INTEGER(I1P), INTENT(IN) :: A1(1:) !< FIRST DATA STREAM. + REAL(R8P), INTENT(IN) :: A2(1:) !< SECOND DATA STREAM. + INTEGER(I1P), ALLOCATABLE, INTENT(INOUT) :: PACKED(:) !< PACKED DATA INTO I1P ARRAY. + INTEGER(I1P), ALLOCATABLE :: P1(:) !< TEMPORARY PACKED DATA OF FIRST STREAM. + INTEGER(I1P), ALLOCATABLE :: P2(:) !< TEMPORARY PACKED DATA OF SECOND STREAM. + + P1 = TRANSFER(A1,P1) + P2 = TRANSFER(A2,P2) + PACKED = [P1,P2] + ENDSUBROUTINE PACK_DATA_I1_R8 + + PURE SUBROUTINE PACK_DATA_I1_R4(A1, A2, PACKED) + !< PACK DIFFERENT KINDS OF DATA INTO SINGLE I1P ARRAY. + !< + !<```FORTRAN + !< USE BEFOR64 + !< USE PENF + !< INTEGER(I1P) :: A1(1) + !< REAL(R4P) :: A2(1) + !< INTEGER(I1P), ALLOCATABLE :: PACK(:) + !< A1(1) = 0 + !< A2(1) = 1 + !< CALL PACK_DATA(A1=A1, A2=A2, PACKED=PACK) + !< PRINT *, PACK(SIZE(PACK, DIM=1)) + !<``` + !=> 63 <<< + INTEGER(I1P), INTENT(IN) :: A1(1:) !< FIRST DATA STREAM. + REAL(R4P), INTENT(IN) :: A2(1:) !< SECOND DATA STREAM. + INTEGER(I1P), ALLOCATABLE, INTENT(INOUT) :: PACKED(:) !< PACKED DATA INTO I1P ARRAY. + INTEGER(I1P), ALLOCATABLE :: P1(:) !< TEMPORARY PACKED DATA OF FIRST STREAM. + INTEGER(I1P), ALLOCATABLE :: P2(:) !< TEMPORARY PACKED DATA OF SECOND STREAM. + + P1 = TRANSFER(A1,P1) + P2 = TRANSFER(A2,P2) + PACKED = [P1,P2] + ENDSUBROUTINE PACK_DATA_I1_R4 + + PURE SUBROUTINE PACK_DATA_I1_I8(A1, A2, PACKED) + !< PACK DIFFERENT KINDS OF DATA INTO SINGLE I1P ARRAY. + !< + !<```FORTRAN + !< USE BEFOR64 + !< USE PENF + !< INTEGER(I1P) :: A1(1) + !< INTEGER(I8P) :: A2(1) + !< INTEGER(I1P), ALLOCATABLE :: PACK(:) + !< A1(1) = 0 + !< A2(1) = 1 + !< CALL PACK_DATA(A1=A1, A2=A2, PACKED=PACK) + !< PRINT *, PACK(2) + !<``` + !=> 1 <<< + INTEGER(I1P), INTENT(IN) :: A1(1:) !< FIRST DATA STREAM. + INTEGER(I8P), INTENT(IN) :: A2(1:) !< SECOND DATA STREAM. + INTEGER(I1P), ALLOCATABLE, INTENT(INOUT) :: PACKED(:) !< PACKED DATA INTO I1P ARRAY. + INTEGER(I1P), ALLOCATABLE :: P1(:) !< TEMPORARY PACKED DATA OF FIRST STREAM. + INTEGER(I1P), ALLOCATABLE :: P2(:) !< TEMPORARY PACKED DATA OF SECOND STREAM. + + P1 = TRANSFER(A1,P1) + P2 = TRANSFER(A2,P2) + PACKED = [P1,P2] + ENDSUBROUTINE PACK_DATA_I1_I8 + + PURE SUBROUTINE PACK_DATA_I1_I4(A1, A2, PACKED) + !< PACK DIFFERENT KINDS OF DATA INTO SINGLE I1P ARRAY. + !< + !<```FORTRAN + !< USE BEFOR64 + !< USE PENF + !< INTEGER(I1P) :: A1(1) + !< INTEGER(I4P) :: A2(1) + !< INTEGER(I1P), ALLOCATABLE :: PACK(:) + !< A1(1) = 0 + !< A2(1) = 1 + !< CALL PACK_DATA(A1=A1, A2=A2, PACKED=PACK) + !< PRINT *, PACK(2) + !<``` + !=> 1 <<< + INTEGER(I1P), INTENT(IN) :: A1(1:) !< FIRST DATA STREAM. + INTEGER(I4P), INTENT(IN) :: A2(1:) !< SECOND DATA STREAM. + INTEGER(I1P), ALLOCATABLE, INTENT(INOUT) :: PACKED(:) !< PACKED DATA INTO I1P ARRAY. + INTEGER(I1P), ALLOCATABLE :: P1(:) !< TEMPORARY PACKED DATA OF FIRST STREAM. + INTEGER(I1P), ALLOCATABLE :: P2(:) !< TEMPORARY PACKED DATA OF SECOND STREAM. + + P1 = TRANSFER(A1,P1) + P2 = TRANSFER(A2,P2) + PACKED = [P1,P2] + ENDSUBROUTINE PACK_DATA_I1_I4 + + PURE SUBROUTINE PACK_DATA_I1_I2(A1, A2, PACKED) + !< PACK DIFFERENT KINDS OF DATA INTO SINGLE I1P ARRAY. + !< + !<```FORTRAN + !< USE BEFOR64 + !< USE PENF + !< INTEGER(I1P) :: A1(1) + !< INTEGER(I2P) :: A2(1) + !< INTEGER(I1P), ALLOCATABLE :: PACK(:) + !< A1(1) = 0 + !< A2(1) = 1 + !< CALL PACK_DATA(A1=A1, A2=A2, PACKED=PACK) + !< PRINT *, PACK(2) + !<``` + !=> 1 <<< + INTEGER(I1P), INTENT(IN) :: A1(1:) !< FIRST DATA STREAM. + INTEGER(I2P), INTENT(IN) :: A2(1:) !< SECOND DATA STREAM. + INTEGER(I1P), ALLOCATABLE, INTENT(INOUT) :: PACKED(:) !< PACKED DATA INTO I1P ARRAY. + INTEGER(I1P), ALLOCATABLE :: P1(:) !< TEMPORARY PACKED DATA OF FIRST STREAM. + INTEGER(I1P), ALLOCATABLE :: P2(:) !< TEMPORARY PACKED DATA OF SECOND STREAM. + + P1 = TRANSFER(A1,P1) + P2 = TRANSFER(A2,P2) + PACKED = [P1,P2] + ENDSUBROUTINE PACK_DATA_I1_I2 +ENDMODULE BEFOR64_PACK_DATA_M + + + +!< BEFOR64, BASE64 ENCODING/DECODING LIBRARY FOR FORTRAN POOR PEOPLE. + +MODULE BEFOR64 +!< BEFOR64, BASE64 ENCODING/DECODING LIBRARY FOR FORTRAN POOR PEOPLE. +USE PENF +USE BEFOR64_PACK_DATA_M + +IMPLICIT NONE +PRIVATE +PUBLIC :: IS_B64_INITIALIZED, B64_INIT +PUBLIC :: B64_ENCODE, B64_ENCODE_UP +PUBLIC :: B64_DECODE, B64_DECODE_UP +PUBLIC :: PACK_DATA + +LOGICAL :: IS_B64_INITIALIZED=.FALSE. !< FLAG FOR CHECKING THE INITIALIZATION OF THE LIBRARY. +CHARACTER(64) :: BASE64="ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789+/" !< BASE64 ALPHABET. + +INTERFACE B64_ENCODE + !< ENCODE NUMBERS (INTEGER AND REAL) TO BASE64. + !< + !< THIS IS AN INTERFACE FOR ENCODING INTEGER AND REAL NUMBERS OF ANY KINDS INTO A BASE64 STRING. THIS INTERFACE CAN ENCODE BOTH + !< SCALAR AND ARRAY. + !< + !< @WARNING THE ENCODED STRING IS RETURNED AS VARYING LENGTH CHARACTER STRING, `CHARACTER(LEN=:), ALLOCATABLE:: STRING`, THUS THE + !< COMPILER MUST SUPPORT SUCH A FORTRAN (2003) FEATURE. + !< + !< @NOTE BEFORE START TO ENCODE ANYTHING THE LIBRARY MUST BE INITIALIZED. THE PROCEDURE `B64_INIT` MUST BE CALLED AT FIRST. THE + !< GLOBAL VARIABLE `IS_B64_INITIALIZED` CAN BE USED TO CHECK THE STATUS OF THE INITIALIZATION. + !< + !<### USAGE + !< FOR A PRACTICAL EXAMPLE SEE THE `AUTOTEST` PROCEDURE. + !< + !<#### SCALAR ENCODING + !<```ORTRAN + !<CHARACTER(LEN=:), ALLOCATABLE:: CODE64 ! BASE64 ENCODED STRING + !<... + !<CALL B64_ENCODE(N=12._R8P,CODE=CODE64) + !<``` + !< + !<#### ARRAY ENCODING + !<```ORTRAN + !<CHARACTER(LEN=:), ALLOCATABLE:: CODE64 ! BASE64 ENCODED STRING + !<... + !<CALL B64_ENCODE(N=[12_I4P,1_I4P],CODE=CODE64) + !<``` + !< + !< @NOTE IF YOU WANT TO ENCODE HETEROGENOUS DATA (E.G. INTEGER AND REAL NUMBERS), YOU MUST USE THE AUXILIARY `PACK_DATA` + !< PROCEDURE. + !< + !< @WARNING THE ENCODING OF ARRAY OF STRINGS IS ADMITTED ONLY IF EACH STRING OF THE ARRAY HAS THE SAME LENGTH. + MODULE PROCEDURE & +#if defined _R16P + B64_ENCODE_R16, B64_ENCODE_R16_A, & +#endif + B64_ENCODE_R8, B64_ENCODE_R8_A, & + B64_ENCODE_R4, B64_ENCODE_R4_A, & + B64_ENCODE_I8, B64_ENCODE_I8_A, & + B64_ENCODE_I4, B64_ENCODE_I4_A, & + B64_ENCODE_I2, B64_ENCODE_I2_A, & + B64_ENCODE_I1, B64_ENCODE_I1_A, & + B64_ENCODE_STRING, B64_ENCODE_STRING_A +ENDINTERFACE + +INTERFACE B64_ENCODE_UP + !< ENCODE UNLIMITED POLYMORPHIC VARIABLE TO BASE64. + !< + !< THIS IS AN INTERFACE FOR ENCODING BOTH SCALAR AND ARRAY. + !< + !< @WARNING THE ENCODED STRING IS RETURNED AS VARYING LENGTH CHARACTER STRING, `CHARACTER(LEN=:), ALLOCATABLE:: STRING`, THUS THE + !< COMPILER MUST SUPPORT SUCH A FORTRAN (2003) FEATURE. + !< + !< @NOTE BEFORE START TO ENCODE ANYTHING THE LIBRARY MUST BE INITIALIZED. THE PROCEDURE `B64_INIT` MUST BE CALLED AT FIRST. THE + !< GLOBAL VARIABLE `IS_B64_INITIALIZED` CAN BE USED TO CHECK THE STATUS OF THE INITIALIZATION. + !< + !<### USAGE + !< FOR A PRACTICAL EXAMPLE SEE THE `AUTOTEST` PROCEDURE. + !< + !<#### SCALAR ENCODING + !<```ORTRAN + !<CHARACTER(LEN=:), ALLOCATABLE:: CODE64 ! BASE64 ENCODED STRING + !<... + !<CALL B64_ENCODE_UP(UP=12._R8P,CODE=CODE64) + !<``` + !< + !<#### ARRAY ENCODING + !<```ORTRAN + !<CHARACTER(LEN=:), ALLOCATABLE:: CODE64 ! BASE64 ENCODED STRING + !<... + !<CALL B64_ENCODE_UP(UP=[12_I4P,1_I4P],CODE=CODE64) + !<``` + !< + !< @NOTE IF YOU WANT TO ENCODE HETEROGENOUS DATA (E.G. INTEGER AND REAL NUMBERS), YOU MUST USE THE AUXILIARY `PACK_DATA` + !< PROCEDURE. + !< + !< @WARNING THE ENCODING OF ARRAY OF STRINGS IS ADMITTED ONLY IF EACH STRING OF THE ARRAY HAS THE SAME LENGTH. + MODULE PROCEDURE B64_ENCODE_UP, B64_ENCODE_UP_A +ENDINTERFACE + +INTERFACE B64_DECODE + !< DECODE NUMBERS (INTEGER AND REAL) FROM BASE64. + !< + !< THIS IS AN INTERFACE FOR DECODING INTEGER AND REAL NUMBERS OF ANY KINDS FROM A BASE64 STRING. THIS INTERFACE CAN DECODE BOTH + !< SCALAR AND ARRAY. + !< + !< @NOTE BEFORE START TO DECODE ANYTHING THE LIBRARY MUST BE INITIALIZED. THE PROCEDURE `B64_INIT` MUST BE CALLED AT FIRST. THE + !< GLOBAL VARIABLE `IS_B64_INITIALIZED` CAN BE USED TO CHECK THE STATUS OF THE INITIALIZATION. + !< + !<### USAGE + !< FOR A PRACTICAL EXAMPLE SEE THE `AUTOTEST` PROCEDURE. + !< + !<#### SCALAR DECODING + !<```ORTRAN + !<REAL(R8P):: DECODED ! SCALAR TO BE DECODED + !<... + !<CALL B64_DECODE(CODE='AAAAAAAA8D8=',N=DECODED) + !<``` + !< + !<#### ARRAY DECODING + !<```ORTRAN + !<INTEGER(I8P):: DECODED(1:4) ! ARRAY TO BE DECODED + !<... + !<CALL B64_DECODE(CODE='FWAAAAAAAABEAQAAAAAAABBWHAEAAAAAAGAAAAAAAAA=',N=DECODED) + !<``` + !< + !< @NOTE IF YOU WANT TO DECODE HETEROGENOUS DATA (E.G. INTEGER AND REAL NUMBERS), YOU MUST USE THE AUXILIARY `PACK_DATA` + !< PROCEDURE. + !< + !< @WARNING THE DECODING OF ARRAY OF STRINGS IS ADMITTED ONLY IF EACH STRING OF THE ARRAY HAS THE SAME LENGTH. + MODULE PROCEDURE & +#if defined _R16P + B64_DECODE_R16, B64_DECODE_R16_A, & +#endif + B64_DECODE_R8, B64_DECODE_R8_A, & + B64_DECODE_R4, B64_DECODE_R4_A, & + B64_DECODE_I8, B64_DECODE_I8_A, & + B64_DECODE_I4, B64_DECODE_I4_A, & + B64_DECODE_I2, B64_DECODE_I2_A, & + B64_DECODE_I1, B64_DECODE_I1_A, & + B64_DECODE_STRING, B64_DECODE_STRING_A +ENDINTERFACE + +INTERFACE B64_DECODE_UP + !< DECODE UNLIMITED POLYMORPHIC VARIABLE FROM BASE64. + !< + !< THIS IS AN INTERFACE FOR DECODING BOTH SCALAR AND ARRAY. + !< + !< @NOTE BEFORE START TO DECODE ANYTHING THE LIBRARY MUST BE INITIALIZED. THE PROCEDURE `B64_INIT` MUST BE CALLED AT FIRST. THE + !< GLOBAL VARIABLE `IS_B64_INITIALIZED` CAN BE USED TO CHECK THE STATUS OF THE INITIALIZATION. + !< + !<### USAGE + !< FOR A PRACTICAL EXAMPLE SEE THE `AUTOTEST` PROCEDURE. + !< + !<#### SCALAR DECODING + !<```ORTRAN + !<REAL(R8P):: DECODED ! SCALAR TO BE DECODED + !<... + !<CALL B64_DECODE_UP(CODE='AAAAAAAA8D8=',UP=DECODED) + !<``` + !< + !<#### ARRAY DECODING + !<```ORTRAN + !<INTEGER(I8P):: DECODED(1:4) ! ARRAY TO BE DECODED + !<... + !<CALL B64_DECODE_UP(CODE='FWAAAAAAAABEAQAAAAAAABBWHAEAAAAAAGAAAAAAAAA=',UP=DECODED) + !<``` + !< + !< @NOTE IF YOU WANT TO DECODE HETEROGENOUS DATA (E.G. INTEGER AND REAL NUMBERS), YOU MUST USE THE AUXILIARY `PACK_DATA` + !< PROCEDURE. + !< + !< @WARNING THE DECODING OF ARRAY OF STRINGS IS ADMITTED ONLY IF EACH STRING OF THE ARRAY HAS THE SAME LENGTH. + MODULE PROCEDURE B64_DECODE_UP, B64_DECODE_UP_A +ENDINTERFACE + +CONTAINS + SUBROUTINE B64_INIT() + !< INITIALIZE THE BEFOR64 LIBRARY. + !< + !< @NOTE THIS PROCEDURE **MUST** BE CALLED BEFORE ENCODING/DECODING ANYTHING! + !< + !<```FORTRAN + !< USE BEFOR64 + !< CALL B64_INIT + !< PRINT "(L1)", IS_B64_INITIALIZED + !<``` + !=> T <<< + + IF (.NOT.IS_INITIALIZED) CALL PENF_INIT + IS_B64_INITIALIZED = .TRUE. + ENDSUBROUTINE B64_INIT + + PURE SUBROUTINE ENCODE_BITS(BITS, PADD, CODE) + !< ENCODE A BITS STREAM (MUST BE MULTIPLE OF 24 BITS) INTO BASE64 CHARCATERS CODE (OF LENGTH MULTIPLE OF 4). + !< + !< THE BITS STREAM ARE ENCODED IN CHUNKS OF 24 BITS AS THE FOLLOWING EXAMPLE (IN LITTLE ENDIAN ORDER) + !<``` + !< +--FIRST OCTET--+-SECOND OCTET--+--THIRD OCTET--+ + !< |7 6 5 4 3 2 1 0|7 6 5 4 3 2 1 0|7 6 5 4 3 2 1 0| + !< +-----------+---+-------+-------+---+-----------+ + !< |5 4 3 2 1 0|5 4 3 2 1 0|5 4 3 2 1 0|5 4 3 2 1 0| + !< +--1.INDEX--+--2.INDEX--+--3.INDEX--+--4.INDEX--+ + !<``` + !< @NOTE THE 4 INDEXES ARE STORED INTO 4 ELEMENTS 8 BITS ARRAY, THUS 2 BITS OF EACH ARRAY ELEMENT ARE NOT USED. + !< + !< @NOTE THE NUMBER OF PADDINGS MUST BE COMPUTED OUTSIDE THIS PROCEDURE, INTO THE CALLING SCOPE. + !< + !< @WARNING THIS PROCEDURE IS THE BACKEND OF ENCODING, THUS IT MUST BE NEVER CALLED OUTSIDE THE MODULE. + INTEGER(I1P), INTENT(IN) :: BITS(1:) !< BITS TO BE ENCODED. + INTEGER(I4P), INTENT(IN) :: PADD !< NUMBER OF PADDING CHARACTERS ('='). + CHARACTER(*), INTENT(OUT) :: CODE !< CHARACTERS CODE. + INTEGER(I1P) :: SIXB(1:4) !< 6 BITS SLICES (STORED INTO 8 BITS INTEGER) OF 24 BITS INPUT. + INTEGER(I8P) :: C !< COUNTER. + INTEGER(I8P) :: E !< COUNTER. + INTEGER(I8P) :: NB !< LENGTH OF BITS ARRAY. + + NB=SIZE(BITS,DIM=1,KIND=I8P) + C = 1_I8P + DO E=1_I8P,NB,3_I8P ! LOOP OVER ARRAY ELEMENTS: 3 BYTES (24 BITS) SCANNING + SIXB = 0_I1P + CALL MVBITS(BITS(E ),2,6,SIXB(1),0) + CALL MVBITS(BITS(E ),0,2,SIXB(2),4) + IF (E+1<=NB) THEN + CALL MVBITS(BITS(E+1),4,4,SIXB(2),0) + CALL MVBITS(BITS(E+1),0,4,SIXB(3),2) + ENDIF + IF (E+2<=NB) THEN + CALL MVBITS(BITS(E+2),6,2,SIXB(3),0) + CALL MVBITS(BITS(E+2),0,6,SIXB(4),0) + ENDIF + SIXB = SIXB + 1_I1P + CODE(C :C ) = BASE64(SIXB(1):SIXB(1)) + CODE(C+1:C+1) = BASE64(SIXB(2):SIXB(2)) + CODE(C+2:C+2) = BASE64(SIXB(3):SIXB(3)) + CODE(C+3:C+3) = BASE64(SIXB(4):SIXB(4)) + C = C + 4_I8P + ENDDO + IF (PADD>0) CODE(LEN(CODE)-PADD+1:)=REPEAT('=',PADD) + ENDSUBROUTINE ENCODE_BITS + + PURE SUBROUTINE DECODE_BITS(CODE, BITS) + !< DECODE A BASE64 STRING INTO A SEQUENCE OF BITS STREAM. + !< + !< THE BASE64 STRING MUST BE PARSED WITH A STRIKE OF 4 CHARACTERS AND CONVERTED INTO A 3 BYTES STREAM. CONSIDERING THE BASE64 CODE + !< `QUJD` THE DECODING PROCESS MUST DO + !<``` + !< +-B64 CHAR--+-B64 CHAR--+-B64 CHAR--+-B64 CHAR--+ + !< | Q | U | J | D | + !< +-B64 INDEX-+-B64 INDEX-+-B64 INDEX-+-B64 INDEX-+ + !< ! 16 | 20 | 9 | 3 | + !< +-6 BITS----+-6 BITS----+-6 BITS----+-6 BITS----+ + !< |0 1 0 0 0 0|0 1 0 1 0 0|0 0 1 0 0 1|0 0 0 0 1 1| + !< +-----------+---+-------+-------+---+-----------+ + !< |0 1 0 0 0 0 0 1|0 1 0 0 0 0 1 0|0 1 0 0 0 0 1 1| + !< +-----8 BITS----+-----8 BITS----+-----8 BITS----+ + !<``` + !< @NOTE THE BITS PATTERN IS RETURNED AS A 1-BYTE ELEMENT ARRAY, THE DIMENSION OF WITCH MUST BE COMPUTED OUTSIDE THIS PROCEDURE. + !< + !< @WARNING THIS PROCEDURE IS THE BACKEND OF DECODING, THUS IT MUST BE NEVER CALLED OUTSIDE THE MODULE. + CHARACTER(*), INTENT(IN) :: CODE !< CHARACTERS CODE. + INTEGER(I1P), INTENT(OUT) :: BITS(1:) !< BITS DECODED. + INTEGER(I1P) :: SIXB(1:4) !< 6 BITS SLICES (STORED INTO 8 BITS INTEGER) OF 24 BITS INPUT. + INTEGER(I8P) :: C !< COUNTER. + INTEGER(I8P) :: E !< COUNTER. + INTEGER(I8P) :: NB !< LENGTH OF BITS ARRAY. + + NB=SIZE(BITS,DIM=1,KIND=I8P) + E = 1_I8P + DO C=1_I8P,LEN(CODE),4_I8P ! LOOP OVER CODE CHARACTERS: 3 BYTES (24 BITS) SCANNING + SIXB = 0_I1P + SIXB(1) = INDEX(BASE64,CODE(C :C )) - 1 + SIXB(2) = INDEX(BASE64,CODE(C+1:C+1)) - 1 + SIXB(3) = INDEX(BASE64,CODE(C+2:C+2)) - 1 + SIXB(4) = INDEX(BASE64,CODE(C+3:C+3)) - 1 + CALL MVBITS(SIXB(1),0,6,BITS(E ),2) ; CALL MVBITS(SIXB(2),4,2,BITS(E ),0) + IF (E+1<=NB) THEN + CALL MVBITS(SIXB(2),0,4,BITS(E+1),4) ; CALL MVBITS(SIXB(3),2,4,BITS(E+1),0) + ENDIF + IF (E+2<=NB) THEN + CALL MVBITS(SIXB(3),0,2,BITS(E+2),6) ; CALL MVBITS(SIXB(4),0,6,BITS(E+2),0) + ENDIF + E = E + 3_I8P + ENDDO + ENDSUBROUTINE DECODE_BITS + + SUBROUTINE B64_ENCODE_UP(UP, CODE) + !< ENCODE AN UNLIMITED POLYMORPHIC SCALAR TO BASE64. + !< + !<```FORTRAN + !< USE BEFOR64 + !< USE PENF + !< CHARACTER(LEN=:), ALLOCATABLE :: CODE64 + !< CALL B64_ENCODE_UP(UP=1._R8P, CODE=CODE64) + !< PRINT "(A)", CODE64 + !<``` + !=> AAAAAAAA8D8= <<< + CLASS(*), INTENT(IN) :: UP !< UNLIMITED POLYMORPHIC VARIABLE TO BE ENCODED. + CHARACTER(LEN=:), ALLOCATABLE, INTENT(OUT) :: CODE !< ENCODED SCALAR. + + SELECT TYPE(UP) + TYPE IS(REAL(R8P)) + CALL B64_ENCODE_R8(N=UP,CODE=CODE) + TYPE IS(REAL(R4P)) + CALL B64_ENCODE_R4(N=UP,CODE=CODE) + TYPE IS(INTEGER(I8P)) + CALL B64_ENCODE_I8(N=UP,CODE=CODE) + TYPE IS(INTEGER(I4P)) + CALL B64_ENCODE_I4(N=UP,CODE=CODE) + TYPE IS(INTEGER(I2P)) + CALL B64_ENCODE_I2(N=UP,CODE=CODE) + TYPE IS(INTEGER(I1P)) + CALL B64_ENCODE_I1(N=UP,CODE=CODE) + TYPE IS(CHARACTER(*)) + CALL B64_ENCODE_STRING(S=UP,CODE=CODE) + ENDSELECT + ENDSUBROUTINE B64_ENCODE_UP + + PURE SUBROUTINE B64_ENCODE_UP_A(UP, CODE) + !< ENCODE AN UNLIMITED POLYMORPHIC ARRAY TO BASE64. + !< + !<```FORTRAN + !< USE BEFOR64 + !< USE PENF + !< CHARACTER(LEN=:), ALLOCATABLE :: CODE64 + !< CALL B64_ENCODE_UP(UP=[0._R4P,-32.12_R4P], CODE=CODE64) + !< PRINT "(A)", CODE64 + !<``` + !=> AAAAAOF6AMI= <<< + CLASS(*), INTENT(IN) :: UP(1:) !< UNLIMITED POLYMORPHIC VARIABLE TO BE ENCODED. + CHARACTER(LEN=:), ALLOCATABLE, INTENT(OUT) :: CODE !< ENCODED ARRAY. + + SELECT TYPE(UP) + TYPE IS(REAL(R8P)) + CALL B64_ENCODE_R8_A(N=UP,CODE=CODE) + TYPE IS(REAL(R4P)) + CALL B64_ENCODE_R4_A(N=UP,CODE=CODE) + TYPE IS(INTEGER(I8P)) + CALL B64_ENCODE_I8_A(N=UP,CODE=CODE) + TYPE IS(INTEGER(I4P)) + CALL B64_ENCODE_I4_A(N=UP,CODE=CODE) + TYPE IS(INTEGER(I2P)) + CALL B64_ENCODE_I2_A(N=UP,CODE=CODE) + TYPE IS(INTEGER(I1P)) + CALL B64_ENCODE_I1_A(N=UP,CODE=CODE) + TYPE IS(CHARACTER(*)) + CALL B64_ENCODE_STRING_A(S=UP,CODE=CODE) + ENDSELECT + ENDSUBROUTINE B64_ENCODE_UP_A + + SUBROUTINE B64_DECODE_UP(CODE, UP) + !< DECODE AN UNLIMITED POLYMORPHIC SCALAR FROM BASE64. + !< + !<```FORTRAN + !< USE BEFOR64 + !< USE PENF + !< INTEGER(I4P) :: SCALAR_I4 + !< CALL B64_DECODE_UP(CODE='5WCAAA==',UP=SCALAR_I4) + !< PRINT "(L1)", SCALAR_I4==2023_I4P + !<``` + !=> T <<< + CHARACTER(*), INTENT(IN) :: CODE !< ENCODED SCALAR. + CLASS(*), INTENT(OUT) :: UP !< UNLIMITED POLYMORPHIC VARIABLE TO BE DECODED. + + SELECT TYPE(UP) + TYPE IS(REAL(R8P)) + CALL B64_DECODE_R8(CODE=CODE,N=UP) + TYPE IS(REAL(R4P)) + CALL B64_DECODE_R4(CODE=CODE,N=UP) + TYPE IS(INTEGER(I8P)) + CALL B64_DECODE_I8(CODE=CODE,N=UP) + TYPE IS(INTEGER(I4P)) + CALL B64_DECODE_I4(CODE=CODE,N=UP) + TYPE IS(INTEGER(I2P)) + CALL B64_DECODE_I2(CODE=CODE,N=UP) + TYPE IS(INTEGER(I1P)) + CALL B64_DECODE_I1(CODE=CODE,N=UP) + TYPE IS(CHARACTER(*)) + CALL B64_DECODE_STRING(CODE=CODE,S=UP) + ENDSELECT + ENDSUBROUTINE B64_DECODE_UP + + SUBROUTINE B64_DECODE_UP_A(CODE, UP) + !< DECODE AN UNLIMITED POLYMORPHIC ARRAY FROM BASE64. + !< + !<```FORTRAN + !< USE BEFOR64 + !< USE PENF + !< INTEGER(I8P) :: ARRAY_I8(1:4) + !< CALL B64_DECODE_UP(CODE='FWAAAAAAAABEAQAAAAAAABBWHAEAAAAAAGAAAAAAAAA=', UP=ARRAY_I8) + !< PRINT "(L1)", STR(N=ARRAY_I8)==STR(N=[23_I8P,324_I8P,25456656_I8P,2_I8P]) + !<``` + !=> T <<< + CHARACTER(*), INTENT(IN) :: CODE !< ENCODED ARRAY. + CLASS(*), INTENT(OUT) :: UP(1:) !< UNLIMITED POLYMORPHIC VARIABLE TO BE DECODED. + + SELECT TYPE(UP) + TYPE IS(REAL(R8P)) + CALL B64_DECODE_R8_A(CODE=CODE,N=UP) + TYPE IS(REAL(R4P)) + CALL B64_DECODE_R4_A(CODE=CODE,N=UP) + TYPE IS(INTEGER(I8P)) + CALL B64_DECODE_I8_A(CODE=CODE,N=UP) + TYPE IS(INTEGER(I4P)) + CALL B64_DECODE_I4_A(CODE=CODE,N=UP) + TYPE IS(INTEGER(I2P)) + CALL B64_DECODE_I2_A(CODE=CODE,N=UP) + TYPE IS(INTEGER(I1P)) + CALL B64_DECODE_I1_A(CODE=CODE,N=UP) + TYPE IS(CHARACTER(*)) + CALL B64_DECODE_STRING_A(CODE=CODE,S=UP) + ENDSELECT + ENDSUBROUTINE B64_DECODE_UP_A + + PURE SUBROUTINE B64_ENCODE_R16(N, CODE) + !< ENCODE SCALAR NUMBER TO BASE64 (R16P). + !< + !<```FORTRAN + !< USE BEFOR64 + !< USE PENF + !< CHARACTER(LEN=:), ALLOCATABLE :: CODE64 + !< CALL B64_ENCODE(N=134.231_R16P, CODE=CODE64) + !< PRINT "(A)", CODE64 + !<``` + !=> CKWCWMTHYEA= <<< + REAL(R16P), INTENT(IN) :: N !< NUMBER TO BE ENCODED. + CHARACTER(LEN=:), ALLOCATABLE, INTENT(OUT) :: CODE !< ENCODED SCALAR. + INTEGER(I1P), ALLOCATABLE :: NI1P(:) !< ONE BYTE INTEGER ARRAY CONTAINING N. + INTEGER(I4P) :: PADD !< NUMBER OF PADDING CHARACTERS ('='). + + ALLOCATE(NI1P(1:((BYR16P+2)/3)*3)) ; NI1P = 0_I1P + CODE = REPEAT(' ',((BYR16P+2)/3)*4) + NI1P = TRANSFER(N,NI1P) +#if defined _R16P + PADD = MOD((BYR16P),3_I2P) ; IF (PADD>0_I4P) PADD = 3_I4P - PADD +#else + PADD = MOD((BYR16P),3_I2P) ; IF (PADD>0_I4P) PADD = 3_I4P - PADD + ! johodges Edited from 3_I1P to 3_I2P +#endif + CALL ENCODE_BITS(BITS=NI1P,PADD=PADD,CODE=CODE) + ENDSUBROUTINE B64_ENCODE_R16 + + PURE SUBROUTINE B64_ENCODE_R8(N, CODE) + !< ENCODE SCALAR NUMBER TO BASE64 (R8P). + !< + !<```FORTRAN + !< USE BEFOR64 + !< USE PENF + !< CHARACTER(LEN=:), ALLOCATABLE :: CODE64 + !< CALL B64_ENCODE(N=1._R8P, CODE=CODE64) + !< PRINT "(A)", CODE64 + !<``` + !=> AAAAAAAA8D8= <<< + REAL(R8P), INTENT(IN) :: N !< NUMBER TO BE ENCODED. + CHARACTER(LEN=:), ALLOCATABLE, INTENT(OUT) :: CODE !< ENCODED SCALAR. + INTEGER(I1P), ALLOCATABLE :: NI1P(:) !< ONE BYTE INTEGER ARRAY CONTAINING N. + INTEGER(I4P) :: PADD !< NUMBER OF PADDING CHARACTERS ('='). + + ALLOCATE(NI1P(1:((BYR8P+2)/3)*3)) ; NI1P = 0_I1P + CODE = REPEAT(' ',((BYR8P+2)/3)*4) + NI1P = TRANSFER(N,NI1P) + PADD = MOD((BYR8P),3_I1P) ; IF (PADD>0_I4P) PADD = 3_I4P - PADD + CALL ENCODE_BITS(BITS=NI1P,PADD=PADD,CODE=CODE) + ENDSUBROUTINE B64_ENCODE_R8 + + PURE SUBROUTINE B64_ENCODE_R4(N, CODE) + !< ENCODE SCALAR NUMBER TO BASE64 (R4P). + !< + !<```FORTRAN + !< USE BEFOR64 + !< USE PENF + !< CHARACTER(LEN=:), ALLOCATABLE :: CODE64 + !< CALL B64_ENCODE(N=0._R4P, CODE=CODE64) + !< PRINT "(A)", CODE64 + !<``` + !=> AAAAAA== <<< + REAL(R4P), INTENT(IN) :: N !< NUMBER TO BE ENCODED. + CHARACTER(LEN=:), ALLOCATABLE, INTENT(OUT) :: CODE !< ENCODED SCALAR. + INTEGER(I1P), ALLOCATABLE :: NI1P(:) !< ONE BYTE INTEGER ARRAY CONTAINING N. + INTEGER(I4P) :: PADD !< NUMBER OF PADDING CHARACTERS ('='). + + ALLOCATE(NI1P(1:((BYR4P+2)/3)*3)) ; NI1P = 0_I1P + CODE = REPEAT(' ',((BYR4P+2)/3)*4) + NI1P = TRANSFER(N,NI1P) + PADD = MOD((BYR4P),3_I1P) ; IF (PADD>0_I4P) PADD = 3_I4P - PADD + CALL ENCODE_BITS(BITS=NI1P,PADD=PADD,CODE=CODE) + ENDSUBROUTINE B64_ENCODE_R4 + + PURE SUBROUTINE B64_ENCODE_I8(N, CODE) + !< ENCODE SCALAR NUMBER TO BASE64 (I8P). + !< + !<```FORTRAN + !< USE BEFOR64 + !< USE PENF + !< CHARACTER(LEN=:), ALLOCATABLE :: CODE64 + !< CALL B64_ENCODE(N=23_I8P, CODE=CODE64) + !< PRINT "(A)", CODE64 + !<``` + !=> FWAAAAAAAAA= <<< + INTEGER(I8P), INTENT(IN) :: N !< NUMBER TO BE ENCODED. + CHARACTER(LEN=:), ALLOCATABLE, INTENT(OUT) :: CODE !< ENCODED SCALAR. + INTEGER(I1P), ALLOCATABLE :: NI1P(:) !< ONE BYTE INTEGER ARRAY CONTAINING N. + INTEGER(I4P) :: PADD !< NUMBER OF PADDING CHARACTERS ('='). + + ALLOCATE(NI1P(1:((BYI8P+2)/3)*3)) ; NI1P = 0_I1P + CODE = REPEAT(' ',((BYI8P+2)/3)*4) + NI1P = TRANSFER(N,NI1P) + PADD = MOD((BYI8P),3_I8P) ; IF (PADD>0_I4P) PADD = 3_I4P - PADD + CALL ENCODE_BITS(BITS=NI1P,PADD=PADD,CODE=CODE) + ENDSUBROUTINE B64_ENCODE_I8 + + PURE SUBROUTINE B64_ENCODE_I4(N, CODE) + !< ENCODE SCALAR NUMBER TO BASE64 (I4P). + !< + !<```FORTRAN + !< USE BEFOR64 + !< USE PENF + !< CHARACTER(LEN=:), ALLOCATABLE :: CODE64 + !< CALL B64_ENCODE(N=2023_I4P, CODE=CODE64) + !< PRINT "(A)", CODE64 + !<``` + !=> 5WCAAA== <<< + INTEGER(I4P), INTENT(IN) :: N !< NUMBER TO BE ENCODED. + CHARACTER(LEN=:), ALLOCATABLE, INTENT(OUT) :: CODE !< ENCODED SCALAR. + INTEGER(I1P), ALLOCATABLE :: NI1P(:) !< ONE BYTE INTEGER ARRAY CONTAINING N. + INTEGER(I4P) :: PADD !< NUMBER OF PADDING CHARACTERS ('='). + + ALLOCATE(NI1P(1:((BYI4P+2)/3)*3)) ; NI1P = 0_I1P + CODE = REPEAT(' ',((BYI4P+2)/3)*4) + NI1P = TRANSFER(N,NI1P) + PADD = MOD((BYI4P),3_I4P) ; IF (PADD>0_I4P) PADD = 3_I4P - PADD + CALL ENCODE_BITS(BITS=NI1P,PADD=PADD,CODE=CODE) + ENDSUBROUTINE B64_ENCODE_I4 + + PURE SUBROUTINE B64_ENCODE_I2(N, CODE) + !< ENCODE SCALAR NUMBER TO BASE64 (I2P). + !< + !<```FORTRAN + !< USE BEFOR64 + !< USE PENF + !< CHARACTER(LEN=:), ALLOCATABLE :: CODE64 + !< CALL B64_ENCODE(N=-203_I2P, CODE=CODE64) + !< PRINT "(A)", CODE64 + !<``` + !=> NF8= <<< + INTEGER(I2P), INTENT(IN) :: N !< NUMBER TO BE ENCODED. + CHARACTER(LEN=:), ALLOCATABLE, INTENT(OUT) :: CODE !< ENCODED SCALAR. + INTEGER(I1P), ALLOCATABLE :: NI1P(:) !< ONE BYTE INTEGER ARRAY CONTAINING N. + INTEGER(I4P) :: PADD !< NUMBER OF PADDING CHARACTERS ('='). + + ALLOCATE(NI1P(1:((BYI2P+2)/3)*3)) ; NI1P = 0_I1P + CODE = REPEAT(' ',((BYI2P+2)/3)*4) + NI1P = TRANSFER(N,NI1P) + PADD = MOD((BYI2P),3_I2P) ; IF (PADD>0_I4P) PADD = 3_I4P - PADD + CALL ENCODE_BITS(BITS=NI1P,PADD=PADD,CODE=CODE) + ENDSUBROUTINE B64_ENCODE_I2 + + PURE SUBROUTINE B64_ENCODE_I1(N, CODE) + !< ENCODE SCALAR NUMBER TO BASE64 (I1P). + !< + !<```FORTRAN + !< USE BEFOR64 + !< USE PENF + !< CHARACTER(LEN=:), ALLOCATABLE :: CODE64 + !< CALL B64_ENCODE(N=120_I1P, CODE=CODE64) + !< PRINT "(A)", CODE64 + !<``` + !=> EA== <<< + INTEGER(I1P), INTENT(IN) :: N !< NUMBER TO BE ENCODED. + CHARACTER(LEN=:), ALLOCATABLE, INTENT(OUT) :: CODE !< ENCODED SCALAR. + INTEGER(I1P), ALLOCATABLE :: NI1P(:) !< ONE BYTE INTEGER ARRAY CONTAINING N. + INTEGER(I4P) :: PADD !< NUMBER OF PADDING CHARACTERS ('='). + + ALLOCATE(NI1P(1:((BYI1P+2)/3)*3)) ; NI1P = 0_I1P + CODE = REPEAT(' ',((BYI1P+2)/3)*4) + NI1P = TRANSFER(N,NI1P) + PADD = MOD((BYI1P),3_I1P) ; IF (PADD>0_I4P) PADD = 3_I4P - PADD + CALL ENCODE_BITS(BITS=NI1P,PADD=PADD,CODE=CODE) + ENDSUBROUTINE B64_ENCODE_I1 + + PURE SUBROUTINE B64_ENCODE_STRING(S, CODE) + !< ENCODE SCALAR STRING TO BASE64. + !< + !<```FORTRAN + !< USE BEFOR64 + !< USE PENF + !< CHARACTER(LEN=:), ALLOCATABLE :: CODE64 + !< CALL B64_ENCODE(S='HELLO', CODE=CODE64) + !< PRINT "(A)", CODE64 + !<``` + !=> AGVSBG8= <<< + CHARACTER(*), INTENT(IN) :: S !< STRING TO BE ENCODED. + CHARACTER(LEN=:), ALLOCATABLE, INTENT(OUT) :: CODE !< ENCODED SCALAR. + INTEGER(I1P), ALLOCATABLE :: NI1P(:) !< ONE BYTE INTEGER ARRAY CONTAINING N. + INTEGER(I4P) :: PADD !< NUMBER OF PADDING CHARACTERS ('='). + INTEGER(I4P) :: BYCHS !< BYTES OF CHARACTER STRING. + + BYCHS = BYTE_SIZE(S) + ALLOCATE(NI1P(1:((BYCHS+2)/3)*3)) ; NI1P = 0_I1P + CODE = REPEAT(' ',((BYCHS+2)/3)*4) + NI1P = TRANSFER(S,NI1P) + PADD = MOD((BYCHS),3_I4P) ; IF (PADD>0_I4P) PADD = 3_I4P - PADD + CALL ENCODE_BITS(BITS=NI1P,PADD=PADD,CODE=CODE) + ENDSUBROUTINE B64_ENCODE_STRING + + PURE SUBROUTINE B64_ENCODE_R16_A(N, CODE) + !< ENCODE ARRAY NUMBERS TO BASE64 (R16P). + !< + !<```FORTRAN + !< USE BEFOR64 + !< USE PENF + !< CHARACTER(LEN=:), ALLOCATABLE :: CODE64 + !< CALL B64_ENCODE(N=[121._R16P,2.32_R16P], CODE=CODE64) + !< PRINT "(A)", CODE64 + !<``` + !=> AAAAAABAXKCPWVUOXI8CQA== <<< + REAL(R16P), INTENT(IN) :: N(1:) !< ARRAY OF NUMBERS TO BE ENCODED. + CHARACTER(LEN=:), ALLOCATABLE, INTENT(OUT) :: CODE !< ENCODED ARRAY. + INTEGER(I1P), ALLOCATABLE :: NI1P(:) !< ONE BYTE INTEGER ARRAY CONTAINING N. + INTEGER(I4P) :: PADD !< NUMBER OF PADDING CHARACTERS ('='). + INTEGER(I8P) :: NS !< SIZE OF N. + + NS = SIZE(N,DIM=1) + ALLOCATE(NI1P(1:((NS*BYR16P+2)/3)*3)) ; NI1P = 0_I1P + CODE = REPEAT(' ',((NS*BYR16P+2)/3)*4) + NI1P = TRANSFER(N,NI1P) + PADD = MOD((NS*BYR16P),3_I8P) ; IF (PADD>0_I4P) PADD = 3_I4P - PADD + CALL ENCODE_BITS(BITS=NI1P,PADD=PADD,CODE=CODE) + ENDSUBROUTINE B64_ENCODE_R16_A + + PURE SUBROUTINE B64_ENCODE_R8_A(N, CODE) + !< ENCODE ARRAY NUMBERS TO BASE64 (R8P). + !< + !<```FORTRAN + !< USE BEFOR64 + !< USE PENF + !< CHARACTER(LEN=:), ALLOCATABLE :: CODE64 + !< CALL B64_ENCODE(N=[1._R8P,2._R8P], CODE=CODE64) + !< PRINT "(A)", CODE64 + !<``` + !=> AAAAAAAA8D8AAAAAAAAAQA== <<< + REAL(R8P), INTENT(IN) :: N(1:) !< ARRAY OF NUMBERS TO BE ENCODED. + CHARACTER(LEN=:), ALLOCATABLE, INTENT(OUT) :: CODE !< ENCODED ARRAY. + INTEGER(I1P), ALLOCATABLE :: NI1P(:) !< ONE BYTE INTEGER ARRAY CONTAINING N. + INTEGER(I4P) :: PADD !< NUMBER OF PADDING CHARACTERS ('='). + INTEGER(I8P) :: NS !< SIZE OF N. + + NS = SIZE(N,DIM=1) + ALLOCATE(NI1P(1:((NS*BYR8P+2)/3)*3)) ; NI1P = 0_I1P + CODE = REPEAT(' ',((NS*BYR8P+2)/3)*4) + NI1P = TRANSFER(N,NI1P) + PADD = MOD((NS*BYR8P),3_I8P) ; IF (PADD>0_I4P) PADD = 3_I4P - PADD + CALL ENCODE_BITS(BITS=NI1P,PADD=PADD,CODE=CODE) + ENDSUBROUTINE B64_ENCODE_R8_A + + PURE SUBROUTINE B64_ENCODE_R4_A(N, CODE) + !< ENCODE ARRAY NUMBERS TO BASE64 (R4P). + !< + !<```FORTRAN + !< USE BEFOR64 + !< USE PENF + !< CHARACTER(LEN=:), ALLOCATABLE :: CODE64 + !< CALL B64_ENCODE(N=[0._R4P,-32.12_R4P], CODE=CODE64) + !< PRINT "(A)", CODE64 + !<``` + !=> AAAAAOF6AMI= <<< + REAL(R4P), INTENT(IN) :: N(1:) !< ARRAY OF NUMBERS TO BE ENCODED. + CHARACTER(LEN=:), ALLOCATABLE, INTENT(OUT) :: CODE !< ENCODED ARRAY. + INTEGER(I1P), ALLOCATABLE :: NI1P(:) !< ONE BYTE INTEGER ARRAY CONTAINING N. + INTEGER(I4P) :: PADD !< NUMBER OF PADDING CHARACTERS ('='). + INTEGER(I8P) :: NS !< SIZE OF N. + + NS = SIZE(N,DIM=1) + ALLOCATE(NI1P(1:((NS*BYR4P+2)/3)*3)) ; NI1P = 0_I1P + CODE = REPEAT(' ',((NS*BYR4P+2)/3)*4) + NI1P = TRANSFER(N,NI1P) + PADD = MOD((NS*BYR4P),3_I8P) ; IF (PADD>0_I4P) PADD = 3_I4P - PADD + CALL ENCODE_BITS(BITS=NI1P,PADD=PADD,CODE=CODE) + ENDSUBROUTINE B64_ENCODE_R4_A + + PURE SUBROUTINE B64_ENCODE_I8_A(N, CODE) + !< ENCODE ARRAY NUMBERS TO BASE64 (I8P). + !< + !<```FORTRAN + !< USE BEFOR64 + !< USE PENF + !< CHARACTER(LEN=:), ALLOCATABLE :: CODE64 + !< CALL B64_ENCODE(N=[23_I8P,324_I8P,25456656_I8P,2_I8P], CODE=CODE64) + !< PRINT "(A)", CODE64 + !<``` + !=> FWAAAAAAAABEAQAAAAAAABBWHAEAAAAAAGAAAAAAAAA= <<< + INTEGER(I8P), INTENT(IN) :: N(1:) !< ARRAY OF NUMBERS TO BE ENCODED. + CHARACTER(LEN=:), ALLOCATABLE, INTENT(OUT) :: CODE !< ENCODED ARRAY. + INTEGER(I1P), ALLOCATABLE :: NI1P(:) !< ONE BYTE INTEGER ARRAY CONTAINING N. + INTEGER(I4P) :: PADD !< NUMBER OF PADDING CHARACTERS ('='). + INTEGER(I8P) :: NS !< SIZE OF N. + + NS = SIZE(N,DIM=1) + ALLOCATE(NI1P(1:((NS*BYI8P+2)/3)*3)) ; NI1P = 0_I1P + CODE = REPEAT(' ',((NS*BYI8P+2)/3)*4) + NI1P = TRANSFER(N,NI1P) + PADD = MOD((NS*BYI8P),3_I8P) ; IF (PADD>0_I4P) PADD = 3_I4P - PADD + CALL ENCODE_BITS(BITS=NI1P,PADD=PADD,CODE=CODE) + ENDSUBROUTINE B64_ENCODE_I8_A + + PURE SUBROUTINE B64_ENCODE_I4_A(N, CODE) + !< ENCODE ARRAY NUMBERS TO BASE64 (I4P). + !< + !<```FORTRAN + !< USE BEFOR64 + !< USE PENF + !< CHARACTER(LEN=:), ALLOCATABLE :: CODE64 + !< CALL B64_ENCODE(N=[2023_I4P,-24_I4P], CODE=CODE64) + !< PRINT "(A)", CODE64 + !<``` + !=> 5WCAAOJ///8= <<< + INTEGER(I4P), INTENT(IN) :: N(1:) !< ARRAY OF NUMBERS TO BE ENCODED. + CHARACTER(LEN=:), ALLOCATABLE, INTENT(OUT) :: CODE !< ENCODED ARRAY. + INTEGER(I1P), ALLOCATABLE :: NI1P(:) !< ONE BYTE INTEGER ARRAY CONTAINING N. + INTEGER(I4P) :: PADD !< NUMBER OF PADDING CHARACTERS ('='). + INTEGER(I8P) :: NS !< SIZE OF N. + + NS = SIZE(N,DIM=1) + ALLOCATE(NI1P(1:((NS*BYI4P+2)/3)*3)) ; NI1P = 0_I1P + CODE = REPEAT(' ',((NS*BYI4P+2)/3)*4) + NI1P = TRANSFER(N,NI1P) + PADD = MOD((NS*BYI4P),3_I8P) ; IF (PADD>0_I4P) PADD = 3_I4P - PADD + CALL ENCODE_BITS(BITS=NI1P,PADD=PADD,CODE=CODE) + ENDSUBROUTINE B64_ENCODE_I4_A + + PURE SUBROUTINE B64_ENCODE_I2_A(N, CODE) + !< ENCODE ARRAY NUMBERS TO BASE64 (I2P). + !< + !<```FORTRAN + !< USE BEFOR64 + !< USE PENF + !< CHARACTER(LEN=:), ALLOCATABLE :: CODE64 + !< CALL B64_ENCODE(N=[-203_I2P,-10_I2P], CODE=CODE64) + !< PRINT "(A)", CODE64 + !<``` + !=> NF/2/W== <<< + INTEGER(I2P), INTENT(IN) :: N(1:) !< ARRAY OF NUMBERS TO BE ENCODED. + CHARACTER(LEN=:), ALLOCATABLE, INTENT(OUT) :: CODE !< ENCODED ARRAY. + INTEGER(I1P), ALLOCATABLE :: NI1P(:) !< ONE BYTE INTEGER ARRAY CONTAINING N. + INTEGER(I4P) :: PADD !< NUMBER OF PADDING CHARACTERS ('='). + INTEGER(I8P) :: NS !< SIZE OF N. + + NS = SIZE(N,DIM=1) + ALLOCATE(NI1P(1:((NS*BYI2P+2)/3)*3)) ; NI1P = 0_I1P + CODE = REPEAT(' ',((NS*BYI2P+2)/3)*4) + NI1P = TRANSFER(N,NI1P) + PADD = MOD((NS*BYI2P),3_I8P) ; IF (PADD>0_I4P) PADD = 3_I4P - PADD + CALL ENCODE_BITS(BITS=NI1P,PADD=PADD,CODE=CODE) + ENDSUBROUTINE B64_ENCODE_I2_A + + PURE SUBROUTINE B64_ENCODE_I1_A(N, CODE) + !< ENCODE ARRAY NUMBERS TO BASE64 (I1P). + !< + !<```FORTRAN + !< USE BEFOR64 + !< USE PENF + !< CHARACTER(LEN=:), ALLOCATABLE :: CODE64 + !< CALL B64_ENCODE(N=[120_I1P,-1_I1P], CODE=CODE64) + !< PRINT "(A)", CODE64 + !<``` + !=> EP8= <<< + INTEGER(I1P), INTENT(IN) :: N(1:) !< ARRAY OF NUMBERS TO BE ENCODED. + CHARACTER(LEN=:), ALLOCATABLE, INTENT(OUT) :: CODE !< ENCODED ARRAY. + INTEGER(I1P), ALLOCATABLE :: NI1P(:) !< ONE BYTE INTEGER ARRAY CONTAINING N. + INTEGER(I4P) :: PADD !< NUMBER OF PADDING CHARACTERS ('='). + INTEGER(I8P) :: NS !< SIZE OF N. + + NS = SIZE(N,DIM=1) + ALLOCATE(NI1P(1:((NS*BYI1P+2)/3)*3)) ; NI1P = 0_I1P + CODE = REPEAT(' ',((NS*BYI1P+2)/3)*4) + NI1P = TRANSFER(N,NI1P) + PADD = MOD((NS*BYI1P),3_I8P) ; IF (PADD>0_I4P) PADD = 3_I4P - PADD + CALL ENCODE_BITS(BITS=NI1P,PADD=PADD,CODE=CODE) + ENDSUBROUTINE B64_ENCODE_I1_A + + PURE SUBROUTINE B64_ENCODE_STRING_A(S, CODE) + !< ENCODE ARRAY STRING TO BASE64. + !< + !<```FORTRAN + !< USE BEFOR64 + !< USE PENF + !< CHARACTER(LEN=:), ALLOCATABLE :: CODE64 + !< CALL B64_ENCODE(S=['HELLO','WORLD'], CODE=CODE64) + !< PRINT "(A)", CODE64 + !<``` + !=> AGVSBG93B3JSZA== <<< + CHARACTER(*), INTENT(IN) :: S(1:) !< STRING TO BE ENCODED. + CHARACTER(LEN=:), ALLOCATABLE, INTENT(OUT) :: CODE !< ENCODED SCALAR. + INTEGER(I1P), ALLOCATABLE :: NI1P(:) !< ONE BYTE INTEGER ARRAY CONTAINING N. + INTEGER(I4P) :: PADD !< NUMBER OF PADDING CHARACTERS ('='). + INTEGER(I4P) :: BYCHS !< BYTES OF CHARACTER STRING. + + BYCHS = BYTE_SIZE(S(1))*SIZE(S,DIM=1) + ALLOCATE(NI1P(1:((BYCHS+2)/3)*3)) ; NI1P = 0_I1P + CODE = REPEAT(' ',((BYCHS+2)/3)*4) + NI1P = TRANSFER(S,NI1P) + PADD = MOD((BYCHS),3_I4P) ; IF (PADD>0_I4P) PADD = 3_I4P - PADD + CALL ENCODE_BITS(BITS=NI1P,PADD=PADD,CODE=CODE) + ENDSUBROUTINE B64_ENCODE_STRING_A + + ELEMENTAL SUBROUTINE B64_DECODE_R16(CODE, N) + !< DECODE A BASE64 CODE INTO A SCALAR NUMBER (R16P). + !< + !<```FORTRAN + !< USE BEFOR64 + !< USE PENF + !< REAL(R16P) :: SCALAR_R16 + !< CALL B64_DECODE(CODE='CKWCWMTHYEA=',N=SCALAR_R16) + !< PRINT "(L1)", SCALAR_R16==134.231_R16P + !<``` + !=> T <<< + CHARACTER(*), INTENT(IN) :: CODE !< ENCODED SCALAR. + REAL(R16P), INTENT(OUT) :: N !< NUMBER TO BE DECODED. + INTEGER(I1P), ALLOCATABLE :: NI1P(:) !< ONE BYTE INTEGER ARRAY CONTAINING N. + + ALLOCATE(NI1P(1:BYR16P)) ; NI1P = 0_I1P + CALL DECODE_BITS(CODE=CODE,BITS=NI1P) + N = TRANSFER(NI1P,N) + ENDSUBROUTINE B64_DECODE_R16 + + ELEMENTAL SUBROUTINE B64_DECODE_R8(CODE, N) + !< DECODE A BASE64 CODE INTO A SCALAR NUMBER (R8P). + !< + !<```FORTRAN + !< USE BEFOR64 + !< USE PENF + !< REAL(R8P) :: SCALAR_R8 + !< CALL B64_DECODE(CODE='AAAAAAAA8D8=',N=SCALAR_R8) + !< PRINT "(L1)", SCALAR_R8==1._R8P + !<``` + !=> T <<< + CHARACTER(*), INTENT(IN) :: CODE !< ENCODED SCALAR. + REAL(R8P), INTENT(OUT) :: N !< NUMBER TO BE DECODED. + INTEGER(I1P), ALLOCATABLE :: NI1P(:) !< ONE BYTE INTEGER ARRAY CONTAINING N. + + ALLOCATE(NI1P(1:BYR8P)) ; NI1P = 0_I1P + CALL DECODE_BITS(CODE=CODE,BITS=NI1P) + N = TRANSFER(NI1P,N) + ENDSUBROUTINE B64_DECODE_R8 + + ELEMENTAL SUBROUTINE B64_DECODE_R4(CODE, N) + !< DECODE A BASE64 CODE INTO A SCALAR NUMBER (R4P). + !< + !<```FORTRAN + !< USE BEFOR64 + !< USE PENF + !< REAL(R4P) :: SCALAR_R4 + !< CALL B64_DECODE(CODE='AAAAAA==',N=SCALAR_R4) + !< PRINT "(L1)", SCALAR_R4==0._R4P + !<``` + !=> T <<< + CHARACTER(*), INTENT(IN) :: CODE !< ENCODED SCALAR. + REAL(R4P), INTENT(OUT) :: N !< NUMBER TO BE DECODED. + INTEGER(I1P), ALLOCATABLE :: NI1P(:) !< ONE BYTE INTEGER ARRAY CONTAINING N. + + ALLOCATE(NI1P(1:BYR4P)) ; NI1P = 0_I1P + CALL DECODE_BITS(CODE=CODE,BITS=NI1P) + N = TRANSFER(NI1P,N) + ENDSUBROUTINE B64_DECODE_R4 + + ELEMENTAL SUBROUTINE B64_DECODE_I8(CODE, N) + !< DECODE A BASE64 CODE INTO A SCALAR NUMBER (I8P). + !< + !<```FORTRAN + !< USE BEFOR64 + !< USE PENF + !< INTEGER(I8P) :: SCALAR_I8 + !< CALL B64_DECODE(CODE='FWAAAAAAAAA=',N=SCALAR_I8) + !< PRINT "(L1)", SCALAR_I8==23_I8P + !<``` + !=> T <<< + CHARACTER(*), INTENT(IN) :: CODE !< ENCODED SCALAR. + INTEGER(I8P), INTENT(OUT) :: N !< NUMBER TO BE DECODED. + INTEGER(I1P), ALLOCATABLE :: NI1P(:) !< ONE BYTE INTEGER ARRAY CONTAINING N. + + ALLOCATE(NI1P(1:BYI8P)) ; NI1P = 0_I1P + CALL DECODE_BITS(CODE=CODE,BITS=NI1P) + N = TRANSFER(NI1P,N) + ENDSUBROUTINE B64_DECODE_I8 + + ELEMENTAL SUBROUTINE B64_DECODE_I4(CODE, N) + !< DECODE A BASE64 CODE INTO A SCALAR NUMBER (I4P). + !< + !<```FORTRAN + !< USE BEFOR64 + !< USE PENF + !< INTEGER(I4P) :: SCALAR_I4 + !< CALL B64_DECODE(CODE='5WCAAA==',N=SCALAR_I4) + !< PRINT "(L1)", SCALAR_I4==2023_I4P + !<``` + !=> T <<< + CHARACTER(*), INTENT(IN) :: CODE !< ENCODED SCALAR. + INTEGER(I4P), INTENT(OUT) :: N !< NUMBER TO BE DECODED. + INTEGER(I1P), ALLOCATABLE :: NI1P(:) !< ONE BYTE INTEGER ARRAY CONTAINING N. + + ALLOCATE(NI1P(1:BYI4P)) ; NI1P = 0_I1P + CALL DECODE_BITS(CODE=CODE,BITS=NI1P) + N = TRANSFER(NI1P,N) + ENDSUBROUTINE B64_DECODE_I4 + + ELEMENTAL SUBROUTINE B64_DECODE_I2(CODE, N) + !< DECODE A BASE64 CODE INTO A SCALAR NUMBER (I2P). + !< + !<```FORTRAN + !< USE BEFOR64 + !< USE PENF + !< INTEGER(I2P) :: SCALAR_I2 + !< CALL B64_DECODE(CODE='NF8=',N=SCALAR_I2) + !< PRINT "(L1)", SCALAR_I2==-203_I2P + !<``` + !=> T <<< + CHARACTER(*), INTENT(IN) :: CODE !< ENCODED SCALAR. + INTEGER(I2P), INTENT(OUT) :: N !< NUMBER TO BE DECODED. + INTEGER(I1P), ALLOCATABLE :: NI1P(:) !< ONE BYTE INTEGER ARRAY CONTAINING N. + + ALLOCATE(NI1P(1:BYI2P)) ; NI1P = 0_I1P + CALL DECODE_BITS(CODE=CODE,BITS=NI1P) + N = TRANSFER(NI1P,N) + ENDSUBROUTINE B64_DECODE_I2 + + ELEMENTAL SUBROUTINE B64_DECODE_I1(CODE, N) + !< DECODE A BASE64 CODE INTO A SCALAR NUMBER (I1P). + !< + !<```FORTRAN + !< USE BEFOR64 + !< USE PENF + !< INTEGER(I1P) :: SCALAR_I1 + !< CALL B64_DECODE(CODE='EA==',N=SCALAR_I1) + !< PRINT "(L1)", SCALAR_I1==120_I1P + !<``` + !=> T <<< + CHARACTER(*), INTENT(IN) :: CODE !< ENCODED SCALAR. + INTEGER(I1P), INTENT(OUT) :: N !< NUMBER TO BE DECODED. + INTEGER(I1P), ALLOCATABLE :: NI1P(:) !< ONE BYTE INTEGER ARRAY CONTAINING N. + + ALLOCATE(NI1P(1:BYI1P)) ; NI1P = 0_I1P + CALL DECODE_BITS(CODE=CODE,BITS=NI1P) + N = TRANSFER(NI1P,N) + ENDSUBROUTINE B64_DECODE_I1 + + ELEMENTAL SUBROUTINE B64_DECODE_STRING(CODE, S) + !< DECODE A BASE64 CODE INTO A SCALAR STRING. + !< + !<```FORTRAN + !< USE BEFOR64 + !< USE PENF + !< CHARACTER(:), ALLOCATABLE :: CODE64 + !< CODE64 = REPEAT(' ',5) + !< CALL B64_DECODE(CODE='AGVSBG8=',S=CODE64) + !< PRINT "(L1)", CODE64=='HELLO' + !<``` + !=> T <<< + CHARACTER(*), INTENT(IN) :: CODE !< ENCODED SCALAR. + CHARACTER(*), INTENT(OUT) :: S !< STRING TO BE DECODED. + INTEGER(I1P), ALLOCATABLE :: NI1P(:) !< ONE BYTE INTEGER ARRAY CONTAINING N. + + ALLOCATE(NI1P(1:BYTE_SIZE(S))) ; NI1P = 0_I1P + CALL DECODE_BITS(CODE=CODE,BITS=NI1P) + S = TRANSFER(NI1P,S) + ENDSUBROUTINE B64_DECODE_STRING + + PURE SUBROUTINE B64_DECODE_R16_A(CODE, N) + !< DECODE A BASE64 CODE INTO AN ARRAY NUMBERS (R16P). + !< + !<```FORTRAN + !< USE BEFOR64 + !< USE PENF + !< REAL(R16P) :: ARRAY_R16(1:2) + !< CALL B64_DECODE(CODE='AAAAAABAXKCPWVUOXI8CQA==',N=ARRAY_R16) + !< PRINT "(L1)", STR(N=ARRAY_R16)==STR(N=[121._R16P,2.32_R16P]) + !<``` + !=> T <<< + CHARACTER(*), INTENT(IN) :: CODE !< ENCODED ARRAY. + REAL(R16P), INTENT(OUT) :: N(1:) !< ARRAY OF NUMBERS TO BE DECODED. + INTEGER(I1P), ALLOCATABLE :: NI1P(:) !< ONE BYTE INTEGER ARRAY CONTAINING N. + + ALLOCATE(NI1P(1:SIZE(N,DIM=1)*BYR16P)) ; NI1P = 0_I1P + CALL DECODE_BITS(CODE=CODE,BITS=NI1P) + N = TRANSFER(NI1P,N) + ENDSUBROUTINE B64_DECODE_R16_A + + PURE SUBROUTINE B64_DECODE_R8_A(CODE, N) + !< DECODE A BASE64 CODE INTO AN ARRAY NUMBERS (R8P). + !< + !<```FORTRAN + !< USE BEFOR64 + !< USE PENF + !< REAL(R8P) :: ARRAY_R8(1:2) + !< CALL B64_DECODE(CODE='AAAAAAAA8D8AAAAAAAAAQA==',N=ARRAY_R8) + !< PRINT "(L1)", STR(N=ARRAY_R8)==STR(N=[1._R8P,2._R8P]) + !<``` + !=> T <<< + CHARACTER(*), INTENT(IN) :: CODE !< ENCODED ARRAY. + REAL(R8P), INTENT(OUT) :: N(1:) !< ARRAY OF NUMBERS TO BE DECODED. + INTEGER(I1P), ALLOCATABLE :: NI1P(:) !< ONE BYTE INTEGER ARRAY CONTAINING N. + + ALLOCATE(NI1P(1:SIZE(N,DIM=1)*BYR8P)) ; NI1P = 0_I1P + CALL DECODE_BITS(CODE=CODE,BITS=NI1P) + N = TRANSFER(NI1P,N) + ENDSUBROUTINE B64_DECODE_R8_A + + PURE SUBROUTINE B64_DECODE_R4_A(CODE, N) + !< DECODE A BASE64 CODE INTO AN ARRAY NUMBERS (R4P). + !< + !<```FORTRAN + !< USE BEFOR64 + !< USE PENF + !< REAL(R4P) :: ARRAY_R4(1:2) + !< CALL B64_DECODE(CODE='AAAAAOF6AMI=',N=ARRAY_R4) + !< PRINT "(L1)", STR(N=ARRAY_R4)==STR(N=[0._R4P,-32.12_R4P]) + !<``` + !=> T <<< + CHARACTER(*), INTENT(IN) :: CODE !< ENCODED ARRAY. + REAL(R4P), INTENT(OUT) :: N(1:) !< ARRAY OF NUMBERS TO BE DECODED. + INTEGER(I1P), ALLOCATABLE :: NI1P(:) !< ONE BYTE INTEGER ARRAY CONTAINING N. + + ALLOCATE(NI1P(1:SIZE(N,DIM=1)*BYR4P)) ; NI1P = 0_I1P + CALL DECODE_BITS(CODE=CODE,BITS=NI1P) + N = TRANSFER(NI1P,N) + ENDSUBROUTINE B64_DECODE_R4_A + + PURE SUBROUTINE B64_DECODE_I8_A(CODE, N) + !< DECODE A BASE64 CODE INTO AN ARRAY NUMBERS (I8P). + !< + !<```FORTRAN + !< USE BEFOR64 + !< USE PENF + !< INTEGER(I8P) :: ARRAY_I8(1:4) + !< CALL B64_DECODE(CODE='FWAAAAAAAABEAQAAAAAAABBWHAEAAAAAAGAAAAAAAAA=',N=ARRAY_I8) + !< PRINT "(L1)", STR(N=ARRAY_I8)==STR(N=[23_I8P,324_I8P,25456656_I8P,2_I8P]) + !<``` + !=> T <<< + CHARACTER(*), INTENT(IN) :: CODE !< ENCODED ARRAY. + INTEGER(I8P), INTENT(OUT) :: N(1:) !< ARRAY OF NUMBERS TO BE DECODED. + INTEGER(I1P), ALLOCATABLE :: NI1P(:) !< ONE BYTE INTEGER ARRAY CONTAINING N. + + ALLOCATE(NI1P(1:SIZE(N,DIM=1)*BYI8P)) ; NI1P = 0_I1P + CALL DECODE_BITS(CODE=CODE,BITS=NI1P) + N = TRANSFER(NI1P,N) + ENDSUBROUTINE B64_DECODE_I8_A + + PURE SUBROUTINE B64_DECODE_I4_A(CODE, N) + !< DECODE A BASE64 CODE INTO AN ARRAY NUMBERS (I4P). + !< + !<```FORTRAN + !< USE BEFOR64 + !< USE PENF + !< INTEGER(I4P) :: ARRAY_I4(1:2) + !< CALL B64_DECODE(CODE='5WCAAOJ///8=',N=ARRAY_I4) + !< PRINT "(L1)", STR(N=ARRAY_I4)==STR(N=[2023_I4P,-24_I4P]) + !<``` + !=> T <<< + CHARACTER(*), INTENT(IN) :: CODE !< ENCODED ARRAY. + INTEGER(I4P), INTENT(OUT) :: N(1:) !< ARRAY OF NUMBERS TO BE DECODED. + INTEGER(I1P), ALLOCATABLE :: NI1P(:) !< ONE BYTE INTEGER ARRAY CONTAINING N. + + ALLOCATE(NI1P(1:SIZE(N,DIM=1)*BYI4P)) ; NI1P = 0_I1P + CALL DECODE_BITS(CODE=CODE,BITS=NI1P) + N = TRANSFER(NI1P,N) + ENDSUBROUTINE B64_DECODE_I4_A + + PURE SUBROUTINE B64_DECODE_I2_A(CODE, N) + !< DECODE A BASE64 CODE INTO AN ARRAY NUMBERS (I2P). + !< + !<```FORTRAN + !< USE BEFOR64 + !< USE PENF + !< INTEGER(I2P) :: ARRAY_I2(1:2) + !< CALL B64_DECODE(CODE='NF/2/W==',N=ARRAY_I2) + !< PRINT "(L1)", STR(N=ARRAY_I2)==STR(N=[-203_I2P,-10_I2P]) + !<``` + !=> T <<< + CHARACTER(*), INTENT(IN) :: CODE !< ENCODED ARRAY. + INTEGER(I2P), INTENT(OUT) :: N(1:) !< ARRAY OF NUMBERS TO BE DECODED. + INTEGER(I1P), ALLOCATABLE :: NI1P(:) !< ONE BYTE INTEGER ARRAY CONTAINING N. + + ALLOCATE(NI1P(1:SIZE(N,DIM=1)*BYI2P)) ; NI1P = 0_I1P + CALL DECODE_BITS(CODE=CODE,BITS=NI1P) + N = TRANSFER(NI1P,N) + ENDSUBROUTINE B64_DECODE_I2_A + + PURE SUBROUTINE B64_DECODE_I1_A(CODE, N) + !< DECODE A BASE64 CODE INTO AN ARRAY NUMBERS (I1P). + !< + !<```FORTRAN + !< USE BEFOR64 + !< USE PENF + !< INTEGER(I1P) :: ARRAY_I1(1:2) + !< CALL B64_DECODE(CODE='EP8=',N=ARRAY_I1) + !< PRINT "(L1)", STR(N=ARRAY_I1)==STR(N=[120_I1P,-1_I1P]) + !<``` + !=> T <<< + CHARACTER(*), INTENT(IN) :: CODE !< ENCODED ARRAY. + INTEGER(I1P), INTENT(OUT) :: N(1:) !< ARRAY OF NUMBERS TO BE DECODED. + INTEGER(I1P), ALLOCATABLE :: NI1P(:) !< ONE BYTE INTEGER ARRAY CONTAINING N. + + ALLOCATE(NI1P(1:SIZE(N,DIM=1)*BYI1P)) ; NI1P = 0_I1P + CALL DECODE_BITS(CODE=CODE,BITS=NI1P) + N = TRANSFER(NI1P,N) + ENDSUBROUTINE B64_DECODE_I1_A + + PURE SUBROUTINE B64_DECODE_STRING_A(CODE, S) + !< DECODE A BASE64 CODE INTO AN ARRAY OF STRINGS. + !< + !<```FORTRAN + !< USE BEFOR64 + !< USE PENF + !< CHARACTER(5) :: ARRAY_S(1:2) + !< CALL B64_DECODE(CODE='AGVSBG93B3JSZA==',S=ARRAY_S) + !< PRINT "(L1)", ARRAY_S(1)//ARRAY_S(2)=='HELLOWORLD' + !<``` + !=> T <<< + CHARACTER(*), INTENT(IN) :: CODE !< ENCODED SCALAR. + CHARACTER(*), INTENT(OUT) :: S(1:) !< STRING TO BE DECODED. + INTEGER(I1P), ALLOCATABLE :: NI1P(:) !< ONE BYTE INTEGER ARRAY CONTAINING N. + + ALLOCATE(NI1P(1:BYTE_SIZE(S(1))*SIZE(S,DIM=1))) ; NI1P = 0_I1P + CALL DECODE_BITS(CODE=CODE,BITS=NI1P) + S = TRANSFER(NI1P,S) + ENDSUBROUTINE B64_DECODE_STRING_A +ENDMODULE BEFOR64 + + + + + + + +!< FACE, FORTRAN ANSI COLORS ENVIRONMENT. +MODULE FACE +!< FACE, FORTRAN ANSI COLORS ENVIRONMENT. +USE, INTRINSIC :: ISO_FORTRAN_ENV, ONLY: INT32 + +IMPLICIT NONE +PRIVATE +PUBLIC :: COLORIZE +PUBLIC :: COLORS_SAMPLES +PUBLIC :: STYLES_SAMPLES +PUBLIC :: ASCII +PUBLIC :: UCS4 + +INTERFACE COLORIZE +#if defined ASCII_SUPPORTED && defined ASCII_NEQ_DEFAULT + MODULE PROCEDURE COLORIZE_ASCII + MODULE PROCEDURE COLORIZE_DEFAULT +#else + MODULE PROCEDURE COLORIZE_DEFAULT +#endif +#ifdef UCS4_SUPPORTED + MODULE PROCEDURE COLORIZE_UCS4 +#endif +ENDINTERFACE + +! KIND PARAMETERS +#ifdef ASCII_SUPPORTED +INTEGER, PARAMETER :: ASCII = SELECTED_CHAR_KIND('ASCII') !< ASCII CHARACTER SET KIND. +#else +INTEGER, PARAMETER :: ASCII = SELECTED_CHAR_KIND('DEFAULT') !< ASCII CHARACTER SET KIND. +#endif +#ifdef UCS4_SUPPORTED +INTEGER, PARAMETER :: UCS4 = SELECTED_CHAR_KIND('ISO_10646') !< UNICODE CHARACTER SET KIND. +#else +INTEGER, PARAMETER :: UCS4 = SELECTED_CHAR_KIND('DEFAULT') !< UNICODE CHARACTER SET KIND. +#endif +! PARAMETERS +CHARACTER(26), PARAMETER :: UPPER_ALPHABET='ABCDEFGHIJKLMNOPQRSTUVWXYZ' !< UPPER CASE ALPHABET. +CHARACTER(26), PARAMETER :: LOWER_ALPHABET='ABCDEFGHIJKLMNOPQRSTUVWXYZ' !< LOWER CASE ALPHABET. +CHARACTER(1), PARAMETER :: NL=NEW_LINE('A') !< NEW LINE CHARACTER. +CHARACTER(1), PARAMETER :: ESCAPE=ACHAR(27) !< "\" CHARACTER. +! CODES +CHARACTER(2), PARAMETER :: CODE_START=ESCAPE//'[' !< START ANSI CODE, "\[". +CHARACTER(1), PARAMETER :: CODE_END='M' !< END ANSI CODE, "M". +CHARACTER(4), PARAMETER :: CODE_CLEAR=CODE_START//'0'//CODE_END !< CLEAR ALL STYLES, "\[0M". +! STYLES CODES +CHARACTER(17), PARAMETER :: STYLES(1:2,1:16)=RESHAPE([& + 'BOLD_ON ','1 ', & ! BOLD ON. + 'ITALICS_ON ','3 ', & ! ITALICS ON. + 'UNDERLINE_ON ','4 ', & ! UNDERLINE ON. + 'INVERSE_ON ','7 ', & ! INVERSE ON: REVERSE FOREGROUND AND BACKGROUND COLORS. + 'STRIKETHROUGH_ON ','9 ', & ! STRIKETHROUGH ON. + 'BOLD_OFF ','22 ', & ! BOLD OFF. + 'ITALICS_OFF ','23 ', & ! ITALICS OFF. + 'UNDERLINE_OFF ','24 ', & ! UNDERLINE OFF. + 'INVERSE_OFF ','27 ', & ! INVERSE OFF: REVERSE FOREGROUND AND BACKGROUND COLORS. + 'STRIKETHROUGH_OFF','29 ', & ! STRIKETHROUGH OFF. + 'FRAMED_ON ','51 ', & ! FRAMED ON. + 'ENCIRCLED_ON ','52 ', & ! ENCIRCLED ON. + 'OVERLINED_ON ','53 ', & ! OVERLINED ON. + 'FRAMED_OFF ','54 ', & ! FRAMED OFF. + 'ENCIRCLED_OFF ','54 ', & ! ENCIRCLED OFF. + 'OVERLINED_OFF ','55 ' & ! OVERLINED OFF. + ], [2,16]) !< STYLES. +! COLORS CODES +CHARACTER(15), PARAMETER :: COLORS_FG(1:2,1:17)=RESHAPE([& + 'BLACK ','30 ', & ! BLACK. + 'RED ','31 ', & ! RED. + 'GREEN ','32 ', & ! GREEN. + 'YELLOW ','33 ', & ! YELLOW. + 'BLUE ','34 ', & ! BLUE. + 'MAGENTA ','35 ', & ! MAGENTA. + 'CYAN ','36 ', & ! CYAN. + 'WHITE ','37 ', & ! WHITE. + 'DEFAULT ','39 ', & ! DEFAULT (WHITE). + 'BLACK_INTENSE ','90 ', & ! BLACK INTENSE. + 'RED_INTENSE ','91 ', & ! RED INTENSE. + 'GREEN_INTENSE ','92 ', & ! GREEN INTENSE. + 'YELLOW_INTENSE ','93 ', & ! YELLOW INTENSE. + 'BLUE_INTENSE ','94 ', & ! BLUE INTENSE. + 'MAGENTA_INTENSE','95 ', & ! MAGENTA INTENSE. + 'CYAN_INTENSE ','96 ', & ! CYAN INTENSE. + 'WHITE_INTENSE ','97 ' & ! WHITE INTENSE. + ], [2,17]) !< FOREGROUND COLORS. +CHARACTER(15), PARAMETER :: COLORS_BG(1:2,1:17)=RESHAPE([& + 'BLACK ','40 ', & ! BLACK. + 'RED ','41 ', & ! RED. + 'GREEN ','42 ', & ! GREEN. + 'YELLOW ','43 ', & ! YELLOW. + 'BLUE ','44 ', & ! BLUE. + 'MAGENTA ','45 ', & ! MAGENTA. + 'CYAN ','46 ', & ! CYAN. + 'WHITE ','47 ', & ! WHITE. + 'DEFAULT ','49 ', & ! DEFAULT (BLACK). + 'BLACK_INTENSE ','100 ', & ! BLACK INTENSE. + 'RED_INTENSE ','101 ', & ! RED INTENSE. + 'GREEN_INTENSE ','102 ', & ! GREEN INTENSE. + 'YELLOW_INTENSE ','103 ', & ! YELLOW INTENSE. + 'BLUE_INTENSE ','104 ', & ! BLUE INTENSE. + 'MAGENTA_INTENSE','105 ', & ! MAGENTA INTENSE. + 'CYAN_INTENSE ','106 ', & ! CYAN INTENSE. + 'WHITE_INTENSE ','107 ' & ! WHITE INTENSE. + ], [2,17]) !< BACKGROUND COLORS. +CONTAINS + ! PUBLIC PROCEDURES + SUBROUTINE COLORS_SAMPLES() + !< PRINT TO STANDARD OUTPUT ALL COLORS SAMPLES. + INTEGER(INT32) :: C !< COUNTER. + + PRINT '(A)', COLORIZE('FOREGROUND COLORS SAMPLES', COLOR_FG='RED_INTENSE') + DO C=1, SIZE(COLORS_FG, DIM=2) + PRINT '(A)', ' COLORIZE("'//COLORS_FG(1, C)//'", COLOR_FG="'//COLORS_FG(1, C)//'") => '//& + COLORIZE(COLORS_FG(1, C), COLOR_FG=COLORS_FG(1, C))//& + ' CODE: '//COLORIZE(TRIM(COLORS_FG(2, C)), COLOR_FG=COLORS_FG(1, C), STYLE='INVERSE_ON') + ENDDO + PRINT '(A)', COLORIZE('BACKGROUND COLORS SAMPLES', COLOR_FG='RED_INTENSE') + DO C=1, SIZE(COLORS_BG, DIM=2) + PRINT '(A)', ' COLORIZE("'//COLORS_BG(1, C)//'", COLOR_BG="'//COLORS_BG(1, C)//'") => '//& + COLORIZE(COLORS_BG(1, C), COLOR_BG=COLORS_BG(1, C))//& + ' CODE: '//COLORIZE(TRIM(COLORS_BG(2, C)), COLOR_BG=COLORS_BG(1, C), STYLE='INVERSE_ON') + ENDDO + ENDSUBROUTINE COLORS_SAMPLES + + SUBROUTINE STYLES_SAMPLES() + !< PRINT TO STANDARD OUTPUT ALL STYLES SAMPLES. + INTEGER(INT32) :: S !< COUNTER. + + PRINT '(A)', COLORIZE('STYLES SAMPLES', COLOR_FG='RED_INTENSE') + DO S=1, SIZE(STYLES, DIM=2) + PRINT '(A)', ' COLORIZE("'//STYLES(1, S)//'", STYLE="'//STYLES(1, S)//'") => '//& + COLORIZE(STYLES(1, S), STYLE=STYLES(1, S))//& + ' CODE: '//COLORIZE(TRIM(STYLES(2, S)), COLOR_FG='MAGENTA', STYLE='INVERSE_ON') + ENDDO + ENDSUBROUTINE STYLES_SAMPLES + + ! PRIVATE PROCEDURES + PURE FUNCTION COLORIZE_ASCII(STRING, COLOR_FG, COLOR_BG, STYLE) RESULT(COLORIZED) + !< COLORIZE AND STYLIZE STRINGS, ASCII KIND. + CHARACTER(LEN=*, KIND=ASCII), INTENT(IN) :: STRING !< INPUT STRING. + CHARACTER(LEN=*), INTENT(IN), OPTIONAL :: COLOR_FG !< FOREGROUND COLOR DEFINITION. + CHARACTER(LEN=*), INTENT(IN), OPTIONAL :: COLOR_BG !< BACKGROUND COLOR DEFINITION. + CHARACTER(LEN=*), INTENT(IN), OPTIONAL :: STYLE !< STYLE DEFINITION. + CHARACTER(LEN=:, KIND=ASCII), ALLOCATABLE :: COLORIZED !< COLORIZED STRING. + CHARACTER(LEN=:, KIND=ASCII), ALLOCATABLE :: BUFFER !< TEMPORARY BUFFER. + INTEGER(INT32) :: I !< COUNTER. + + COLORIZED = STRING + IF (PRESENT(COLOR_FG)) THEN + I = COLOR_INDEX(UPPER(COLOR_FG)) + IF (I>0) THEN + BUFFER = CODE_START//TRIM(COLORS_FG(2, I))//CODE_END + COLORIZED = BUFFER//COLORIZED + BUFFER = CODE_CLEAR + COLORIZED = COLORIZED//BUFFER + ENDIF + ENDIF + IF (PRESENT(COLOR_BG)) THEN + I = COLOR_INDEX(UPPER(COLOR_BG)) + IF (I>0) THEN + BUFFER = CODE_START//TRIM(COLORS_BG(2, I))//CODE_END + COLORIZED = BUFFER//COLORIZED + BUFFER = CODE_CLEAR + COLORIZED = COLORIZED//BUFFER + ENDIF + ENDIF + IF (PRESENT(STYLE)) THEN + I = STYLE_INDEX(UPPER(STYLE)) + IF (I>0) THEN + BUFFER = CODE_START//TRIM(STYLES(2, I))//CODE_END + COLORIZED = BUFFER//COLORIZED + BUFFER = CODE_CLEAR + COLORIZED = COLORIZED//BUFFER + ENDIF + ENDIF + ENDFUNCTION COLORIZE_ASCII + + PURE FUNCTION COLORIZE_DEFAULT(STRING, COLOR_FG, COLOR_BG, STYLE) RESULT(COLORIZED) + !< COLORIZE AND STYLIZE STRINGS, DEFAULT KIND. + CHARACTER(LEN=*), INTENT(IN) :: STRING !< INPUT STRING. + CHARACTER(LEN=*), INTENT(IN), OPTIONAL :: COLOR_FG !< FOREGROUND COLOR DEFINITION. + CHARACTER(LEN=*), INTENT(IN), OPTIONAL :: COLOR_BG !< BACKGROUND COLOR DEFINITION. + CHARACTER(LEN=*), INTENT(IN), OPTIONAL :: STYLE !< STYLE DEFINITION. + CHARACTER(LEN=:), ALLOCATABLE :: COLORIZED !< COLORIZED STRING. + INTEGER(INT32) :: I !< COUNTER. + + COLORIZED = STRING + IF (PRESENT(COLOR_FG)) THEN + I = COLOR_INDEX(UPPER(COLOR_FG)) + IF (I>0) COLORIZED = CODE_START//TRIM(COLORS_FG(2, I))//CODE_END//COLORIZED//CODE_CLEAR + ENDIF + IF (PRESENT(COLOR_BG)) THEN + I = COLOR_INDEX(UPPER(COLOR_BG)) + IF (I>0) COLORIZED = CODE_START//TRIM(COLORS_BG(2, I))//CODE_END//COLORIZED//CODE_CLEAR + ENDIF + IF (PRESENT(STYLE)) THEN + I = STYLE_INDEX(UPPER(STYLE)) + IF (I>0) COLORIZED = CODE_START//TRIM(STYLES(2, I))//CODE_END//COLORIZED//CODE_CLEAR + ENDIF + ENDFUNCTION COLORIZE_DEFAULT + + PURE FUNCTION COLORIZE_UCS4(STRING, COLOR_FG, COLOR_BG, STYLE) RESULT(COLORIZED) + !< COLORIZE AND STYLIZE STRINGS, UCS4 KIND. + CHARACTER(LEN=*, KIND=UCS4), INTENT(IN) :: STRING !< INPUT STRING. + CHARACTER(LEN=*), INTENT(IN), OPTIONAL :: COLOR_FG !< FOREGROUND COLOR DEFINITION. + CHARACTER(LEN=*), INTENT(IN), OPTIONAL :: COLOR_BG !< BACKGROUND COLOR DEFINITION. + CHARACTER(LEN=*), INTENT(IN), OPTIONAL :: STYLE !< STYLE DEFINITION. + CHARACTER(LEN=:, KIND=UCS4), ALLOCATABLE :: COLORIZED !< COLORIZED STRING. + CHARACTER(LEN=:, KIND=UCS4), ALLOCATABLE :: BUFFER !< TEMPORARY BUFFER. + INTEGER(INT32) :: I !< COUNTER. + + COLORIZED = STRING + IF (PRESENT(COLOR_FG)) THEN + I = COLOR_INDEX(UPPER(COLOR_FG)) + IF (I>0) THEN + BUFFER = CODE_START//TRIM(COLORS_FG(2, I))//CODE_END + COLORIZED = BUFFER//COLORIZED + BUFFER = CODE_CLEAR + COLORIZED = COLORIZED//BUFFER + ENDIF + ENDIF + IF (PRESENT(COLOR_BG)) THEN + I = COLOR_INDEX(UPPER(COLOR_BG)) + IF (I>0) THEN + BUFFER = CODE_START//TRIM(COLORS_BG(2, I))//CODE_END + COLORIZED = BUFFER//COLORIZED + BUFFER = CODE_CLEAR + COLORIZED = COLORIZED//BUFFER + ENDIF + ENDIF + IF (PRESENT(STYLE)) THEN + I = STYLE_INDEX(UPPER(STYLE)) + IF (I>0) THEN + BUFFER = CODE_START//TRIM(STYLES(2, I))//CODE_END + COLORIZED = BUFFER//COLORIZED + BUFFER = CODE_CLEAR + COLORIZED = COLORIZED//BUFFER + ENDIF + ENDIF + ENDFUNCTION COLORIZE_UCS4 + + ELEMENTAL FUNCTION COLOR_INDEX(COLOR) + !< RETURN THE ARRAY-INDEX CORRESPONDING TO THE QUERIED COLOR. + !< + !< @NOTE BECAUSE FOREGROUND AND BACKROUND COLORS LISTS SHARE THE SAME NAME, NO MATTER WHAT ARRAY IS USED TO FIND THE COLOR INDEX. + !< THUS, THE FOREGROUND ARRAY IS USED. + CHARACTER(LEN=*), INTENT(IN) :: COLOR !< COLOR DEFINITION. + INTEGER(INT32) :: COLOR_INDEX !< INDEX INTO THE COLORS ARRAYS. + INTEGER(INT32) :: C !< COUNTER. + + COLOR_INDEX = 0 + DO C=1, SIZE(COLORS_FG, DIM=2) + IF (TRIM(COLORS_FG(1, C))==TRIM(ADJUSTL(COLOR))) THEN + COLOR_INDEX = C + EXIT + ENDIF + ENDDO + ENDFUNCTION COLOR_INDEX + + ELEMENTAL FUNCTION STYLE_INDEX(STYLE) + !< RETURN THE ARRAY-INDEX CORRESPONDING TO THE QUERIED STYLE. + CHARACTER(LEN=*), INTENT(IN) :: STYLE !< STYLE DEFINITION. + INTEGER(INT32) :: STYLE_INDEX !< INDEX INTO THE STYLES ARRAY. + INTEGER(INT32) :: S !< COUNTER. + + STYLE_INDEX = 0 + DO S=1, SIZE(STYLES, DIM=2) + IF (TRIM(STYLES(1, S))==TRIM(ADJUSTL(STYLE))) THEN + STYLE_INDEX = S + EXIT + ENDIF + ENDDO + ENDFUNCTION STYLE_INDEX + + ELEMENTAL FUNCTION UPPER(STRING) + !< RETURN A STRING WITH ALL UPPERCASE CHARACTERS. + CHARACTER(LEN=*), INTENT(IN) :: STRING !< INPUT STRING. + CHARACTER(LEN=LEN(STRING)) :: UPPER !< UPPER CASE STRING. + INTEGER :: N1 !< CHARACTERS COUNTER. + INTEGER :: N2 !< CHARACTERS COUNTER. + + UPPER = STRING + DO N1=1, LEN(STRING) + N2 = INDEX(LOWER_ALPHABET, STRING(N1:N1)) + IF (N2>0) UPPER(N1:N1) = UPPER_ALPHABET(N2:N2) + ENDDO + ENDFUNCTION UPPER +ENDMODULE FACE + + + + + +!< STRINGIFOR, DEFINITION OF `STRING` TYPE. +MODULE STRINGIFOR_STRING_T +!< STRINGIFOR, DEFINITION OF `STRING` TYPE. +USE, INTRINSIC :: ISO_FORTRAN_ENV, ONLY : IOSTAT_EOR +USE BEFOR64, ONLY : B64_DECODE, B64_ENCODE +USE FACE, ONLY : COLORIZE +USE PENF, ONLY : I1P, I2P, I4P, I8P, R4P, R8P, R16P, STR + +IMPLICIT NONE +PRIVATE +SAVE +! EXPOSE STINGIFOR OVERLOADED BUILTINS AND OPERATORS +! PUBLIC :: ADJUSTL, ADJUSTR, COUNT, INDEX, LEN, LEN_TRIM, REPEAT, SCAN, TRIM, VERIFY +PUBLIC :: ADJUSTL, ADJUSTR, COUNT, INDEX, LEN_TRIM, REPEAT, SCAN, TRIM, VERIFY +! EXPOSE STINGIFOR OBJECTS +PUBLIC :: CK +PUBLIC :: GLOB +PUBLIC :: STRJOIN +PUBLIC :: STRING + +INTEGER, PARAMETER :: CK = SELECTED_CHAR_KIND('DEFAULT') !< DEFAULT CHARACTER KIND. + +TYPE :: STRING + !< OOP DESIGNED STRING CLASS. + CHARACTER(KIND=CK, LEN=:), ALLOCATABLE :: RAW !< RAW DATA. + CONTAINS + ! PUBLIC METHODS + ! BUILTINS REPLACEMENTS + PROCEDURE, PASS(SELF) :: ADJUSTL => SADJUSTL !< ADJUSTL REPLACEMENT. + PROCEDURE, PASS(SELF) :: ADJUSTR => SADJUSTR !< ADJUSTR REPLACEMENT. + PROCEDURE, PASS(SELF) :: COUNT => SCOUNT !< COUNT REPLACEMENT. + GENERIC :: INDEX => SINDEX_STRING_STRING, & + SINDEX_STRING_CHARACTER !< INDEX REPLACEMENT. + PROCEDURE, PASS(SELF) :: LEN => SLEN !< LEN REPLACEMENT. + PROCEDURE, PASS(SELF) :: LEN_TRIM => SLEN_TRIM !< LEN_TRIM REPLACEMENT. + GENERIC :: REPEAT => SREPEAT_STRING_STRING, & + SREPEAT_CHARACTER_STRING !< REPEAT REPLACEMENT. + GENERIC :: SCAN => SSCAN_STRING_STRING, & + SSCAN_STRING_CHARACTER !< SCAN REPLACEMENT. + PROCEDURE, PASS(SELF) :: TRIM => STRIM !< TRIM REPLACEMENT. + GENERIC :: VERIFY => SVERIFY_STRING_STRING, & + SVERIFY_STRING_CHARACTER !< VERIFY REPLACEMENT. + ! AUXILIARY METHODS + PROCEDURE, PASS(SELF) :: BASEDIR !< RETURN THE BASE DIRECTORY NAME OF A STRING CONTAINING A FILE NAME. + PROCEDURE, PASS(SELF) :: BASENAME !< RETURN THE BASE FILE NAME OF A STRING CONTAINING A FILE NAME. + PROCEDURE, PASS(SELF) :: CAMELCASE !< RETURN A STRING WITH ALL WORDS CAPITALIZED WITHOUT SPACES. + PROCEDURE, PASS(SELF) :: CAPITALIZE !< RETURN A STRING WITH ITS FIRST CHARACTER CAPITALIZED AND THE REST LOWERCASED. + PROCEDURE, PASS(SELF) :: CHARS !< RETURN THE RAW CHARACTERS DATA. + GENERIC :: COLORIZE => & + COLORIZE_STR !< COLORIZE AND STYLIZE STRINGS. + PROCEDURE, PASS(SELF) :: DECODE !< DECODE STRING. + PROCEDURE, PASS(SELF) :: ENCODE !< ENCODE STRING. + PROCEDURE, PASS(SELF) :: ESCAPE !< ESCAPE BACKSLASHES (OR CUSTOM ESCAPE CHARACTER). + PROCEDURE, PASS(SELF) :: EXTENSION !< RETURN THE EXTENSION OF A STRING CONTAINING A FILE NAME. + PROCEDURE, PASS(SELF) :: FILL !< PAD STRING ON THE LEFT (OR RIGHT) WITH ZEROS (OR OTHER CHAR) TO FILL WIDTH. + PROCEDURE, PASS(SELF) :: FREE !< FREE DYNAMIC MEMORY. + GENERIC :: GLOB => & + GLOB_CHARACTER, & + GLOB_STRING !< GLOB SEARCH, FINDS ALL THE PATHNAMES MATCHING A GIVEN PATTERN. + GENERIC :: INSERT => & + INSERT_STRING, & + INSERT_CHARACTER !< INSERT SUBSTRING INTO STRING AT A SPECIFIED POSITION. + GENERIC :: JOIN => & + JOIN_STRINGS, & + JOIN_CHARACTERS !< RETURN A STRING THAT IS A JOIN OF AN ARRAY OF STRINGS OR CHARACTERS. + GENERIC :: STRJOIN => & + STRJOIN_STRINGS, & + STRJOIN_CHARACTERS, & + STRJOIN_STRINGS_ARRAY, & + STRJOIN_CHARACTERS_ARRAY !< RETURN A STRING THAT IS A JOIN OF AN ARRAY OF STRINGS OR CHARACTERS; + !< RETURN JOIN 1D STRING ARRAY OF AN 2D ARRAY OF STRINGS OR CHARACTERS IN COLUMNS OR ROWS. + PROCEDURE, PASS(SELF) :: LOWER !< RETURN A STRING WITH ALL LOWERCASE CHARACTERS. + PROCEDURE, PASS(SELF) :: PARTITION !< SPLIT STRING AT SEPARATOR AND RETURN THE 3 PARTS (BEFORE, THE SEPARATOR AND AFTER). + PROCEDURE, PASS(SELF) :: READ_FILE !< READ A FILE A SINGLE STRING STREAM. + PROCEDURE, PASS(SELF) :: READ_LINE !< READ LINE (RECORD) FROM A CONNECTED UNIT. + PROCEDURE, PASS(SELF) :: READ_LINES !< READ (ALL) LINES (RECORDS) FROM A CONNECTED UNIT AS A SINGLE ASCII STREAM. + PROCEDURE, PASS(SELF) :: REPLACE !< RETURN A STRING WITH ALL OCCURRENCES OF SUBSTRING OLD REPLACED BY NEW. + PROCEDURE, PASS(SELF) :: REVERSE !< RETURN A REVERSED STRING. + PROCEDURE, PASS(SELF) :: SEARCH !< SEARCH FOR *TAGGED* RECORD INTO STRING. + PROCEDURE, PASS(SELF) :: SLICE !< RETURN THE RAW CHARACTERS DATA SLICED. + PROCEDURE, PASS(SELF) :: SNAKECASE !< RETURN A STRING WITH ALL WORDS LOWERCASE SEPARATED BY "_". + PROCEDURE, PASS(SELF) :: SPLIT !< RETURN A LIST OF SUBSTRING IN THE STRING, USING SEP AS THE DELIMITER STRING. + PROCEDURE, PASS(SELF) :: SPLIT_CHUNKED !< RETURN A LIST OF SUBSTRING IN THE STRING, USING SEP AS THE DELIMITER STRING. + PROCEDURE, PASS(SELF) :: STARTCASE !< RETURN A STRING WITH ALL WORDS CAPITALIZED, E.G. TITLE CASE. + PROCEDURE, PASS(SELF) :: STRIP !< RETURN A STRING WITH THE LEADING AND TRAILING CHARACTERS REMOVED. + PROCEDURE, PASS(SELF) :: SWAPCASE !< RETURN A STRING WITH UPPERCASE CHARS CONVERTED TO LOWERCASE AND VICE VERSA. + PROCEDURE, PASS(SELF) :: TEMPNAME !< RETURN A SAFE TEMPORARY NAME SUITABLE FOR TEMPORARY FILE OR DIRECTORIES. + GENERIC :: TO_NUMBER => & + TO_INTEGER_I1P,& +#ifndef _NVF + TO_INTEGER_I2P,& +#endif + TO_INTEGER_I4P,& + TO_INTEGER_I8P,& +#if defined _R16P + TO_REAL_R16P, & +#endif + TO_REAL_R8P, & + TO_REAL_R4P !< CAST STRING TO NUMBER. + PROCEDURE, PASS(SELF) :: UNESCAPE !< UNESCAPE DOUBLE BACKSLASHES (OR CUSTOM ESCAPED CHARACTER). + PROCEDURE, PASS(SELF) :: UNIQUE !< REDUCE TO ONE (UNIQUE) MULTIPLE OCCURRENCES OF A SUBSTRING INTO A STRING. + PROCEDURE, PASS(SELF) :: UPPER !< RETURN A STRING WITH ALL UPPERCASE CHARACTERS. + PROCEDURE, PASS(SELF) :: WRITE_FILE !< WRITE A SINGLE STRING STREAM INTO FILE. + PROCEDURE, PASS(SELF) :: WRITE_LINE !< WRITE LINE (RECORD) TO A CONNECTED UNIT. + PROCEDURE, PASS(SELF) :: WRITE_LINES !< WRITE LINES (RECORDS) TO A CONNECTED UNIT. + ! INQUIRE METHODS + PROCEDURE, PASS(SELF) :: END_WITH !< RETURN TRUE IF A STRING ENDS WITH A SPECIFIED SUFFIX. + PROCEDURE, PASS(SELF) :: IS_ALLOCATED !< RETURN TRUE IF THE STRING IS ALLOCATED. + PROCEDURE, PASS(SELF) :: IS_DIGIT !< RETURN TRUE IF ALL CHARACTERS IN THE STRING ARE DIGITS. + PROCEDURE, PASS(SELF) :: IS_INTEGER !< RETURN TRUE IF THE STRING CONTAINS AN INTEGER. + PROCEDURE, PASS(SELF) :: IS_LOWER !< RETURN TRUE IF ALL CHARACTERS IN THE STRING ARE LOWERCASE. + PROCEDURE, PASS(SELF) :: IS_NUMBER !< RETURN TRUE IF THE STRING CONTAINS A NUMBER (REAL OR INTEGER). + PROCEDURE, PASS(SELF) :: IS_REAL !< RETURN TRUE IF THE STRING CONTAINS AN REAL. + PROCEDURE, PASS(SELF) :: IS_UPPER !< RETURN TRUE IF ALL CHARACTERS IN THE STRING ARE UPPERCASE. + PROCEDURE, PASS(SELF) :: START_WITH !< RETURN TRUE IF A STRING STARTS WITH A SPECIFIED PREFIX. + ! OPERATORS + GENERIC :: ASSIGNMENT(=) => STRING_ASSIGN_STRING, & + STRING_ASSIGN_CHARACTER, & + STRING_ASSIGN_INTEGER_I1P, & + STRING_ASSIGN_INTEGER_I2P, & + STRING_ASSIGN_INTEGER_I4P, & + STRING_ASSIGN_INTEGER_I8P, & +#if defined _R16P + STRING_ASSIGN_REAL_R16P, & +#endif + STRING_ASSIGN_REAL_R8P, & + STRING_ASSIGN_REAL_R4P !< ASSIGNMENT OPERATOR OVERLOADING. + GENERIC :: OPERATOR(//) => STRING_CONCAT_STRING, & + STRING_CONCAT_CHARACTER, & + CHARACTER_CONCAT_STRING !< CONCATENATION OPERATOR OVERLOADING. + GENERIC :: OPERATOR(.CAT.) => STRING_CONCAT_STRING_STRING, & + STRING_CONCAT_CHARACTER_STRING, & + CHARACTER_CONCAT_STRING_STRING !< CONCATENATION OPERATOR (STRING OUTPUT) OVERLOADING. + GENERIC :: OPERATOR(==) => STRING_EQ_STRING, & + STRING_EQ_CHARACTER, & + CHARACTER_EQ_STRING !< EQUAL OPERATOR OVERLOADING. + GENERIC :: OPERATOR(/=) => STRING_NE_STRING, & + STRING_NE_CHARACTER, & + CHARACTER_NE_STRING !< NOT EQUAL OPERATOR OVERLOADING. + GENERIC :: OPERATOR(<) => STRING_LT_STRING, & + STRING_LT_CHARACTER, & + CHARACTER_LT_STRING !< LOWER THAN OPERATOR OVERLOADING. + GENERIC :: OPERATOR(<=) => STRING_LE_STRING, & + STRING_LE_CHARACTER, & + CHARACTER_LE_STRING !< LOWER EQUAL THAN OPERATOR OVERLOADING. + GENERIC :: OPERATOR(>=) => STRING_GE_STRING, & + STRING_GE_CHARACTER, & + CHARACTER_GE_STRING !< GREATER EQUAL THAN OPERATOR OVERLOADING. + GENERIC :: OPERATOR(>) => STRING_GT_STRING, & + STRING_GT_CHARACTER, & + CHARACTER_GT_STRING !< GREATER THAN OPERATOR OVERLOADING. + ! IO + GENERIC :: READ(FORMATTED) => READ_FORMATTED !< FORMATTED INPUT. + GENERIC :: WRITE(FORMATTED) => WRITE_FORMATTED !< FORMATTED OUTPUT. + GENERIC :: READ(UNFORMATTED) => READ_UNFORMATTED !< UNFORMATTED INPUT. + GENERIC :: WRITE(UNFORMATTED) => WRITE_UNFORMATTED !< UNFORMATTED OUTPUT. + ! PRIVATE METHODS + ! BUILTINS REPLACEMENTS + PROCEDURE, PRIVATE, PASS(SELF) :: SINDEX_STRING_STRING !< INDEX REPLACEMENT. + PROCEDURE, PRIVATE, PASS(SELF) :: SINDEX_STRING_CHARACTER !< INDEX REPLACEMENT. + PROCEDURE, PRIVATE, PASS(SELF) :: SREPEAT_STRING_STRING !< REPEAT REPLACEMENT. + PROCEDURE, PRIVATE, NOPASS :: SREPEAT_CHARACTER_STRING !< REPEAT REPLACEMENT. + PROCEDURE, PRIVATE, PASS(SELF) :: SSCAN_STRING_STRING !< SCAN REPLACEMENT. + PROCEDURE, PRIVATE, PASS(SELF) :: SSCAN_STRING_CHARACTER !< SCAN REPLACEMENT. + PROCEDURE, PRIVATE, PASS(SELF) :: SVERIFY_STRING_STRING !< VERIFY REPLACEMENT. + PROCEDURE, PRIVATE, PASS(SELF) :: SVERIFY_STRING_CHARACTER !< VERIFY REPLACEMENT. + ! AUXILIARY METHODS + PROCEDURE, PRIVATE, PASS(SELF) :: COLORIZE_STR !< COLORIZE AND STYLIZE STRINGS. + PROCEDURE, PRIVATE, PASS(SELF) :: GLOB_CHARACTER !< GLOB SEARCH (CHARACTER OUTPUT). + PROCEDURE, PRIVATE, PASS(SELF) :: GLOB_STRING !< GLOB SEARCH (STRING OUTPUT). + PROCEDURE, PRIVATE, PASS(SELF) :: INSERT_STRING !< INSERT SUBSTRING INTO STRING AT A SPECIFIED POSITION. + PROCEDURE, PRIVATE, PASS(SELF) :: INSERT_CHARACTER !< INSERT SUBSTRING INTO STRING AT A SPECIFIED POSITION. + PROCEDURE, PRIVATE, PASS(SELF) :: JOIN_STRINGS !< RETURN JOIN STRING OF AN ARRAY OF STRINGS. + PROCEDURE, PRIVATE, PASS(SELF) :: JOIN_CHARACTERS !< RETURN JOIN STRING OF AN ARRAY OF CHARACTERS. + PROCEDURE, PRIVATE, NOPASS :: STRJOIN_STRINGS !< RETURN JOIN STRING OF AN ARRAY OF STRINGS. + PROCEDURE, PRIVATE, NOPASS :: STRJOIN_CHARACTERS !< RETURN JOIN STRING OF AN ARRAY OF STRINGS. + PROCEDURE, PRIVATE, NOPASS :: STRJOIN_STRINGS_ARRAY !< RETURN JOIN 1D STRING ARRAY OF AN 2D ARRAY OF STRINGS IN COLUMNS OR ROWS. + PROCEDURE, PRIVATE, NOPASS :: STRJOIN_CHARACTERS_ARRAY !< RETURN JOIN 1D STRING ARRAY OF AN 2D ARRAY OF CHARACTERS IN COLUMNS OR ROWS. + PROCEDURE, PRIVATE, PASS(SELF) :: TO_INTEGER_I1P !< CAST STRING TO INTEGER. +#ifndef _NVF + PROCEDURE, PRIVATE, PASS(SELF) :: TO_INTEGER_I2P !< CAST STRING TO INTEGER. +#endif + PROCEDURE, PRIVATE, PASS(SELF) :: TO_INTEGER_I4P !< CAST STRING TO INTEGER. + PROCEDURE, PRIVATE, PASS(SELF) :: TO_INTEGER_I8P !< CAST STRING TO INTEGER. + PROCEDURE, PRIVATE, PASS(SELF) :: TO_REAL_R4P !< CAST STRING TO REAL. + PROCEDURE, PRIVATE, PASS(SELF) :: TO_REAL_R8P !< CAST STRING TO REAL. + PROCEDURE, PRIVATE, PASS(SELF) :: TO_REAL_R16P !< CAST STRING TO REAL. + ! ASSIGNMENTS + PROCEDURE, PRIVATE, PASS(LHS) :: STRING_ASSIGN_STRING !< ASSIGNMENT OPERATOR FROM STRING INPUT. + PROCEDURE, PRIVATE, PASS(LHS) :: STRING_ASSIGN_CHARACTER !< ASSIGNMENT OPERATOR FROM CHARACTER INPUT. + PROCEDURE, PRIVATE, PASS(LHS) :: STRING_ASSIGN_INTEGER_I1P !< ASSIGNMENT OPERATOR FROM INTEGER INPUT. + PROCEDURE, PRIVATE, PASS(LHS) :: STRING_ASSIGN_INTEGER_I2P !< ASSIGNMENT OPERATOR FROM INTEGER INPUT. + PROCEDURE, PRIVATE, PASS(LHS) :: STRING_ASSIGN_INTEGER_I4P !< ASSIGNMENT OPERATOR FROM INTEGER INPUT. + PROCEDURE, PRIVATE, PASS(LHS) :: STRING_ASSIGN_INTEGER_I8P !< ASSIGNMENT OPERATOR FROM INTEGER INPUT. + PROCEDURE, PRIVATE, PASS(LHS) :: STRING_ASSIGN_REAL_R4P !< ASSIGNMENT OPERATOR FROM REAL INPUT. + PROCEDURE, PRIVATE, PASS(LHS) :: STRING_ASSIGN_REAL_R8P !< ASSIGNMENT OPERATOR FROM REAL INPUT. + PROCEDURE, PRIVATE, PASS(LHS) :: STRING_ASSIGN_REAL_R16P !< ASSIGNMENT OPERATOR FROM REAL INPUT. + ! CONCATENATION OPERATORS + PROCEDURE, PRIVATE, PASS(LHS) :: STRING_CONCAT_STRING !< CONCATENATION WITH STRING. + PROCEDURE, PRIVATE, PASS(LHS) :: STRING_CONCAT_CHARACTER !< CONCATENATION WITH CHARACTER. + PROCEDURE, PRIVATE, PASS(RHS) :: CHARACTER_CONCAT_STRING !< CONCATENATION WITH CHARACTER (INVERTED). + PROCEDURE, PRIVATE, PASS(LHS) :: STRING_CONCAT_STRING_STRING !< CONCATENATION WITH STRING (STRING OUTPUT). + PROCEDURE, PRIVATE, PASS(LHS) :: STRING_CONCAT_CHARACTER_STRING !< CONCATENATION WITH CHARACTER (STRING OUTPUT). + PROCEDURE, PRIVATE, PASS(RHS) :: CHARACTER_CONCAT_STRING_STRING !< CONCATENATION WITH CHARACTER (INVERTED, STRING OUTPUT). + ! LOGICAL OPERATORS + PROCEDURE, PRIVATE, PASS(LHS) :: STRING_EQ_STRING !< EQUAL TO STRING LOGICAL OPERATOR. + PROCEDURE, PRIVATE, PASS(LHS) :: STRING_EQ_CHARACTER !< EQUAL TO CHARACTER LOGICAL OPERATOR. + PROCEDURE, PRIVATE, PASS(RHS) :: CHARACTER_EQ_STRING !< EQUAL TO CHARACTER (INVERTED) LOGICAL OPERATOR. + PROCEDURE, PRIVATE, PASS(LHS) :: STRING_NE_STRING !< NOT EQUAL TO STRING LOGICAL OPERATOR. + PROCEDURE, PRIVATE, PASS(LHS) :: STRING_NE_CHARACTER !< NOT EQUAL TO CHARACTER LOGICAL OPERATOR. + PROCEDURE, PRIVATE, PASS(RHS) :: CHARACTER_NE_STRING !< NOT EQUAL TO CHARACTER (INVERTED) LOGICAL OPERATOR. + PROCEDURE, PRIVATE, PASS(LHS) :: STRING_LT_STRING !< LOWER THAN TO STRING LOGICAL OPERATOR. + PROCEDURE, PRIVATE, PASS(LHS) :: STRING_LT_CHARACTER !< LOWER THAN TO CHARACTER LOGICAL OPERATOR. + PROCEDURE, PRIVATE, PASS(RHS) :: CHARACTER_LT_STRING !< LOWER THAN TO CHARACTER (INVERTED) LOGICAL OPERATOR. + PROCEDURE, PRIVATE, PASS(LHS) :: STRING_LE_STRING !< LOWER EQUAL THAN TO STRING LOGICAL OPERATOR. + PROCEDURE, PRIVATE, PASS(LHS) :: STRING_LE_CHARACTER !< LOWER EQUAL THAN TO CHARACTER LOGICAL OPERATOR. + PROCEDURE, PRIVATE, PASS(RHS) :: CHARACTER_LE_STRING !< LOWER EQUAL THAN TO CHARACTER (INVERTED) LOGICAL OPERATOR. + PROCEDURE, PRIVATE, PASS(LHS) :: STRING_GE_STRING !< GREATER EQUAL THAN TO STRING LOGICAL OPERATOR. + PROCEDURE, PRIVATE, PASS(LHS) :: STRING_GE_CHARACTER !< GREATER EQUAL THAN TO CHARACTER LOGICAL OPERATOR. + PROCEDURE, PRIVATE, PASS(RHS) :: CHARACTER_GE_STRING !< GREATER EQUAL THAN TO CHARACTER (INVERTED) LOGICAL OPERATOR. + PROCEDURE, PRIVATE, PASS(LHS) :: STRING_GT_STRING !< GREATER THAN TO STRING LOGICAL OPERATOR. + PROCEDURE, PRIVATE, PASS(LHS) :: STRING_GT_CHARACTER !< GREATER THAN TO CHARACTER LOGICAL OPERATOR. + PROCEDURE, PRIVATE, PASS(RHS) :: CHARACTER_GT_STRING !< GREATER THAN TO CHARACTER (INVERTED) LOGICAL OPERATOR. + ! IO + PROCEDURE, PRIVATE, PASS(DTV) :: READ_FORMATTED !< FORMATTED INPUT. + PROCEDURE, PRIVATE, PASS(DTV) :: READ_DELIMITED !< READ A DELIMITED INPUT. + PROCEDURE, PRIVATE, PASS(DTV) :: READ_UNDELIMITED !< READ AN UNDELIMITED INPUT. + PROCEDURE, PRIVATE, PASS(DTV) :: READ_UNDELIMITED_LISTDIRECTED !< READ AN UNDELIMITED LIST DIRECTED INPUT. + PROCEDURE, PRIVATE, PASS(DTV) :: WRITE_FORMATTED !< FORMATTED OUTPUT. + PROCEDURE, PRIVATE, PASS(DTV) :: READ_UNFORMATTED !< UNFORMATTED INPUT. + PROCEDURE, PRIVATE, PASS(DTV) :: WRITE_UNFORMATTED !< UNFORMATTED OUTPUT. + ! MISCELLANEA + PROCEDURE, PRIVATE, PASS(SELF) :: REPLACE_ONE_OCCURRENCE !< REPLACE THE FIRST OCCURRENCE OF SUBSTRING OLD BY NEW. +ENDTYPE STRING + +! INTERNAL PARAMETERS +CHARACTER(KIND=CK, LEN=26), PARAMETER :: UPPER_ALPHABET = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' !< UPPER CASE ALPHABET. +CHARACTER(KIND=CK, LEN=26), PARAMETER :: LOWER_ALPHABET = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' !< LOWER CASE ALPHABET. +CHARACTER(KIND=CK, LEN=1), PARAMETER :: SPACE = ' ' !< SPACE CHARACTER. +CHARACTER(KIND=CK, LEN=1), PARAMETER :: TAB = ACHAR(9) !< TAB CHARACTER. +CHARACTER(KIND=CK, LEN=1), PARAMETER :: UIX_DIR_SEP = CHAR(47) !< UNIX/LINUX DIRECTORIES SEPARATOR (/). +CHARACTER(KIND=CK, LEN=1), PARAMETER :: BACKSLASH = CHAR(92) !< BACKSLASH CHARACTER. + +INTERFACE GLOB + !< OVERLOADING GLOB PROCEDURE. + !<```FORTRAN + !< TYPE(STRING) :: ASTRING + !< CHARACTER(LEN=:), ALLOCATABLE :: ALIST_CHR(:) + !< TYPE(STRING), ALLOCATABLE :: ALIST_STR(:) + !< INTEGER, PARAMETER :: NF=5 + !< CHARACTER(14) :: FILES(1:NF) + !< INTEGER :: FILE_UNIT + !< INTEGER :: F + !< INTEGER :: FF + !< LOGICAL :: TEST_PASSED + !< DO F=1, NF + !< FILES(F) = ASTRING%TEMPNAME(PREFIX='FOO-') + !< OPEN(NEWUNIT=FILE_UNIT, FILE=FILES(F)) + !< WRITE(FILE_UNIT, *)F + !< CLOSE(UNIT=FILE_UNIT) + !< ENDDO + !< CALL GLOB(SELF=ASTRING, PATTERN='FOO-*', LIST=ALIST_CHR) + !< CALL GLOB(SELF=ASTRING, PATTERN='FOO-*', LIST=ALIST_STR) + !< DO F=1, NF + !< OPEN(NEWUNIT=FILE_UNIT, FILE=FILES(F)) + !< CLOSE(UNIT=FILE_UNIT, STATUS='DELETE') + !< ENDDO + !< TEST_PASSED = .FALSE. + !< OUTER_CHR: DO F=1, SIZE(ALIST_CHR, DIM=1) + !< DO FF=1, NF + !< TEST_PASSED = ALIST_CHR(F) == FILES(FF) + !< IF (TEST_PASSED) CYCLE OUTER_CHR + !< ENDDO + !< ENDDO OUTER_CHR + !< IF (TEST_PASSED) THEN + !< TEST_PASSED = .FALSE. + !< OUTER_STR: DO F=1, SIZE(ALIST_STR, DIM=1) + !< DO FF=1, NF + !< TEST_PASSED = ALIST_STR(F) == FILES(FF) + !< IF (TEST_PASSED) CYCLE OUTER_STR + !< ENDDO + !< ENDDO OUTER_STR + !< ENDIF + !< PRINT '(L1)', TEST_PASSED + !<``` + !=> T <<< + MODULE PROCEDURE GLOB_CHARACTER, GLOB_STRING +ENDINTERFACE GLOB + +INTERFACE STRJOIN + MODULE PROCEDURE STRJOIN_STRINGS, STRJOIN_CHARACTERS, STRJOIN_STRINGS_ARRAY, STRJOIN_CHARACTERS_ARRAY +ENDINTERFACE STRJOIN + +! BUILTIN OVERLOADING +INTERFACE ADJUSTL + !< BUILTIN ADJUSTL OVERLOADING. + MODULE PROCEDURE SADJUSTL_CHARACTER +ENDINTERFACE ADJUSTL + +INTERFACE ADJUSTR + !< BUILTIN ADJUSTR OVERLOADING. + MODULE PROCEDURE SADJUSTR_CHARACTER +ENDINTERFACE ADJUSTR + +INTERFACE COUNT + !< BUILTIN COUNT OVERLOADING. + MODULE PROCEDURE COUNT_SUBSTRING +ENDINTERFACE + +INTERFACE INDEX + !< BUILTIN INDEX OVERLOADING. + MODULE PROCEDURE SINDEX_STRING_STRING, SINDEX_STRING_CHARACTER, SINDEX_CHARACTER_STRING +ENDINTERFACE INDEX + +!INTERFACE LEN +! !< BUILTIN LEN OVERLOADING. +! MODULE PROCEDURE SLEN +!ENDINTERFACE LEN + +INTERFACE LEN_TRIM + !< BUILTIN LEN_TRIM OVERLOADING. + MODULE PROCEDURE SLEN_TRIM +ENDINTERFACE LEN_TRIM + +INTERFACE REPEAT + !< BUILTIN REPEAT OVERLOADING. + MODULE PROCEDURE SREPEAT_STRING_STRING +ENDINTERFACE REPEAT + +INTERFACE SCAN + !< BUILTIN SCAN OVERLOADING. + MODULE PROCEDURE SSCAN_STRING_STRING, SSCAN_STRING_CHARACTER, SSCAN_CHARACTER_STRING +ENDINTERFACE SCAN + +INTERFACE TRIM + !< BUILTIN TRIM OVERLOADING. + MODULE PROCEDURE STRIM +ENDINTERFACE TRIM + +INTERFACE VERIFY + !< BUILTIN VERIFY OVERLOADING. + MODULE PROCEDURE SVERIFY_STRING_STRING, SVERIFY_STRING_CHARACTER, SVERIFY_CHARACTER_STRING +ENDINTERFACE VERIFY + +CONTAINS + ! PUBLIC NON TBP + + ! CREATOR + PURE FUNCTION STRING_(C) + !< RETURN A STRING GIVEN A CHARACTER INPUT. + !< + !<```FORTRAN + !< PRINT "(L1)", STRING('HELLO WORLD')//''=='HELLO WORLD' + !<``` + !=> T <<< + CHARACTER(*), INTENT(IN) :: C !< CHARACTER. + TYPE(STRING) :: STRING_ !< STRING. + + STRING_%RAW = C + ENDFUNCTION STRING_ + + ! BUILTINS REPLACEMENTS + PURE FUNCTION SADJUSTL_CHARACTER(S) RESULT(ADJUSTED) + !< LEFT ADJUST A STRING BY REMOVING LEADING SPACES (CHARACTER OUTPUT). + !< + !<```FORTRAN + !< TYPE(STRING) :: ASTRING + !< ASTRING = ' HELLO WORLD!' + !< PRINT "(L1)", ADJUSTL(ASTRING)=='HELLO WORLD! ' + !<``` + !=> T <<< + CLASS(STRING), INTENT(IN) :: S !< STRING. + CHARACTER(KIND=CK, LEN=:), ALLOCATABLE :: ADJUSTED !< ADJUSTED STRING. + + IF (ALLOCATED(S%RAW)) ADJUSTED = ADJUSTL(S%RAW) + ENDFUNCTION SADJUSTL_CHARACTER + + PURE FUNCTION SADJUSTR_CHARACTER(S) RESULT(ADJUSTED) + !< RIGHT ADJUST A STRING BY REMOVING LEADING SPACES (CHARACTER OUTPUT). + !< + !<```FORTRAN + !< TYPE(STRING) :: ASTRING + !< ASTRING = 'HELLO WORLD! ' + !< PRINT "(L1)", ADJUSTR(ASTRING)==' HELLO WORLD!' + !<``` + !=> T <<< + CLASS(STRING), INTENT(IN) :: S !< STRING. + CHARACTER(KIND=CK, LEN=:), ALLOCATABLE :: ADJUSTED !< ADJUSTED STRING. + + IF (ALLOCATED(S%RAW)) ADJUSTED = ADJUSTR(S%RAW) + ENDFUNCTION SADJUSTR_CHARACTER + + ELEMENTAL FUNCTION COUNT_SUBSTRING(S, SUBSTRING) RESULT(NO) + !< COUNT THE NUMBER OF OCCURENCES OF A SUBSTRING INTO A STRING. + !< + !<```FORTRAN + !< PRINT "(L1)", COUNT('HELLO', SUBSTRING='LL')==1 + !<``` + !=> T <<< + CHARACTER(*), INTENT(IN) :: S !< STRING. + CHARACTER(*), INTENT(IN) :: SUBSTRING !< SUBSTRING. + INTEGER(I4P) :: NO !< NUMBER OF OCCURRENCES. + INTEGER(I4P) :: C1 !< COUNTERS. + INTEGER(I4P) :: C2 !< COUNTERS. + + NO = 0 + IF (LEN(SUBSTRING) > LEN(S)) RETURN + C1 = 1 + DO + C2 = INDEX(STRING=S(C1:), SUBSTRING=SUBSTRING) + IF (C2==0) RETURN + NO = NO + 1 + C1 = C1 + C2 + LEN(SUBSTRING) + ENDDO + ENDFUNCTION COUNT_SUBSTRING + + ELEMENTAL FUNCTION SINDEX_CHARACTER_STRING(S, SUBSTRING, BACK) RESULT(I) + !< RETURN THE POSITION OF THE START OF THE FIRST OCCURRENCE OF STRING `SUBSTRING` AS A SUBSTRING IN `STRING`, COUNTING FROM ONE. + !< IF `SUBSTRING` IS NOT PRESENT IN `STRING`, ZERO IS RETURNED. IF THE BACK ARGUMENT IS PRESENT AND TRUE, THE RETURN VALUE IS + !< THE START OF THE LAST OCCURRENCE RATHER THAN THE FIRST. + !< + !<```FORTRAN + !< TYPE(STRING) :: STRING1 + !< LOGICAL :: TEST_PASSED(2) + !< STRING1 = 'LLO' + !< TEST_PASSED(1) = INDEX(S='HELLO WORLD HELLO!', SUBSTRING=STRING1)==INDEX(STRING='HELLO WORLD HELLO!', SUBSTRING='LLO') + !< TEST_PASSED(2) = INDEX(S='HELLO WORLD HELLO!', SUBSTRING=STRING1, BACK=.TRUE.)==INDEX(STRING='HELLO WORLD HELLO!', & + !< SUBSTRING='LLO', BACK=.TRUE.) + !< PRINT '(L1)', ALL(TEST_PASSED) + !<``` + !=> T <<< + CHARACTER(KIND=CK, LEN=*), INTENT(IN) :: S !< STRING. + TYPE(STRING), INTENT(IN) :: SUBSTRING !< SEARCHED SUBSTRING. + LOGICAL, INTENT(IN), OPTIONAL :: BACK !< START OF THE LAST OCCURRENCE RATHER THAN THE FIRST. + INTEGER :: I !< RESULT OF THE SEARCH. + + IF (ALLOCATED(SUBSTRING%RAW)) THEN + I = INDEX(STRING=S, SUBSTRING=SUBSTRING%RAW, BACK=BACK) + ELSE + I = 0 + ENDIF + ENDFUNCTION SINDEX_CHARACTER_STRING + + ELEMENTAL FUNCTION SSCAN_CHARACTER_STRING(S, SET, BACK) RESULT(I) + !< RETURN THE LEFTMOST (IF `BACK` IS EITHER ABSENT OR EQUALS FALSE, OTHERWISE THE RIGHTMOST) CHARACTER OF STRING THAT IS IN `SET`. + !< + !<```FORTRAN + !< TYPE(STRING) :: STRING1 + !< LOGICAL :: TEST_PASSED(2) + !< STRING1 = 'LLO' + !< TEST_PASSED(1) = SCAN(S='HELLO WORLD HELLO!', SET=STRING1)==SCAN(STRING='HELLO WORLD HELLO!', SET='LLO') + !< TEST_PASSED(2) = SCAN(S='HELLO WORLD HELLO!', SET=STRING1, BACK=.TRUE.)==SCAN(STRING='HELLO WORLD HELLO!', & + !< SET='LLO', BACK=.TRUE.) + !< PRINT '(L1)', ALL(TEST_PASSED) + !<``` + !=> T <<< + CHARACTER(KIND=CK, LEN=*), INTENT(IN) :: S !< STRING. + TYPE(STRING), INTENT(IN) :: SET !< SEARCHED SET. + LOGICAL, INTENT(IN), OPTIONAL :: BACK !< START OF THE LAST OCCURRENCE RATHER THAN THE FIRST. + INTEGER :: I !< RESULT OF THE SEARCH. + + IF (ALLOCATED(SET%RAW)) THEN + I = SCAN(STRING=S, SET=SET%RAW, BACK=BACK) + ELSE + I = 0 + ENDIF + ENDFUNCTION SSCAN_CHARACTER_STRING + + ELEMENTAL FUNCTION SVERIFY_CHARACTER_STRING(S, SET, BACK) RESULT(I) + !< RETURN THE LEFTMOST (IF `BACK` IS EITHER ABSENT OR EQUALS FALSE, OTHERWISE THE RIGHTMOST) CHARACTER OF STRING THAT IS NOT + !< IN `SET`. IF ALL CHARACTERS OF `STRING` ARE FOUND IN `SET`, THE RESULT IS ZERO. + !< + !<```FORTRAN + !< TYPE(STRING) :: STRING1 + !< LOGICAL :: TEST_PASSED(2) + !< STRING1 = 'ELL' + !< TEST_PASSED(1) = VERIFY(S='HELLO WORLD HELLO!', SET=STRING1)==VERIFY(STRING='HELLO WORLD HELLO!', SET='LLO') + !< TEST_PASSED(2) = VERIFY(S='HELLO WORLD HELLO!', SET=STRING1, BACK=.TRUE.)==VERIFY(STRING='HELLO WORLD HELLO!', SET='LLO', & + !< BACK=.TRUE.) + !< PRINT '(L1)', ALL(TEST_PASSED) + !<``` + !=> T <<< + CHARACTER(KIND=CK, LEN=*), INTENT(IN) :: S !< STRING. + TYPE(STRING), INTENT(IN) :: SET !< SEARCHED SET. + LOGICAL, INTENT(IN), OPTIONAL :: BACK !< START OF THE LAST OCCURRENCE RATHER THAN THE FIRST. + INTEGER :: I !< RESULT OF THE SEARCH. + + IF (ALLOCATED(SET%RAW)) THEN + I = VERIFY(STRING=S, SET=SET%RAW, BACK=BACK) + ELSE + I = 0 + ENDIF + ENDFUNCTION SVERIFY_CHARACTER_STRING + + ! PUBLIC METHODS + + ! BUILTINS REPLACEMENTS + ELEMENTAL FUNCTION SADJUSTL(SELF) RESULT(ADJUSTED) + !< LEFT ADJUST A STRING BY REMOVING LEADING SPACES. + !< + !<```FORTRAN + !< TYPE(STRING) :: ASTRING + !< ASTRING = ' HELLO WORLD!' + !< PRINT "(L1)", ASTRING%ADJUSTL()//''=='HELLO WORLD! ' + !<``` + !=> T <<< + CLASS(STRING), INTENT(IN) :: SELF !< THE STRING. + TYPE(STRING) :: ADJUSTED !< ADJUSTED STRING. + + ADJUSTED = SELF + IF (ALLOCATED(ADJUSTED%RAW)) ADJUSTED%RAW = ADJUSTL(ADJUSTED%RAW) + ENDFUNCTION SADJUSTL + + ELEMENTAL FUNCTION SADJUSTR(SELF) RESULT(ADJUSTED) + !< RIGHT ADJUST A STRING BY REMOVING LEADING SPACES. + !< + !<```FORTRAN + !< TYPE(STRING) :: ASTRING + !< ASTRING = 'HELLO WORLD! ' + !< PRINT "(L1)", ASTRING%ADJUSTR()//''==' HELLO WORLD!' + !<``` + !=> T <<< + CLASS(STRING), INTENT(IN) :: SELF !< THE STRING. + TYPE(STRING) :: ADJUSTED !< ADJUSTED STRING. + + ADJUSTED = SELF + IF (ALLOCATED(ADJUSTED%RAW)) ADJUSTED%RAW = ADJUSTR(ADJUSTED%RAW) + ENDFUNCTION SADJUSTR + + ELEMENTAL FUNCTION SCOUNT(SELF, SUBSTRING, IGNORE_ISOLATED) RESULT(NO) + !< COUNT THE NUMBER OF OCCURENCES OF A SUBSTRING INTO A STRING. + !< + !< @NOTE IF `IGNORE_ISOLATED` IS SET TO TRUE THE EVENTUAL "ISOLATED" OCCURENCES ARE IGNORED: AN ISOLATED OCCURRENCES ARE THOSE + !< OCCURRENCES HAPPENING AT THE START OF STRING (THUS NOT HAVING A LEFT COMPANION) OR AT THE END OF THE STRING (THUS NOT HAVING A + !< RIGHT COMPANION). + !< + !<```FORTRAN + !< TYPE(STRING) :: ASTRING + !< LOGICAL :: TEST_PASSED(4) + !< ASTRING = ' HELLO WORLD ! ' + !< TEST_PASSED(1) = ASTRING%COUNT(SUBSTRING=' ')==10 + !< ASTRING = 'HELLO WORLD ! ' + !< TEST_PASSED(2) = ASTRING%COUNT(SUBSTRING=' ', IGNORE_ISOLATED=.TRUE.)==6 + !< ASTRING = ' HELLO WORLD !' + !< TEST_PASSED(3) = ASTRING%COUNT(SUBSTRING=' ', IGNORE_ISOLATED=.TRUE.)==6 + !< ASTRING = ' HELLO WORLD ! ' + !< TEST_PASSED(4) = ASTRING%COUNT(SUBSTRING=' ', IGNORE_ISOLATED=.TRUE.)==8 + !< PRINT '(L1)', ALL(TEST_PASSED) + !<``` + !=> T <<< + CLASS(STRING), INTENT(IN) :: SELF !< THE STRING. + CHARACTER(*), INTENT(IN) :: SUBSTRING !< SUBSTRING. + LOGICAL, INTENT(IN), OPTIONAL :: IGNORE_ISOLATED !< IGNORE "ISOLATED" OCCURRENCES. + INTEGER :: NO !< NUMBER OF OCCURRENCES. + LOGICAL :: IGNORE_ISOLATED_ !< IGNORE "ISOLATED" OCCURRENCES, LOCAL VARIABLE. + INTEGER :: C1 !< COUNTER. + INTEGER :: C2 !< COUNTER. + + NO = 0 + IF (ALLOCATED(SELF%RAW)) THEN + IF (LEN(SUBSTRING)>LEN(SELF%RAW)) RETURN + IGNORE_ISOLATED_ = .FALSE. ; IF (PRESENT(IGNORE_ISOLATED)) IGNORE_ISOLATED_ = IGNORE_ISOLATED + C1 = 1 + DO + C2 = INDEX(STRING=SELF%RAW(C1:), SUBSTRING=SUBSTRING) + IF (C2==0) RETURN + IF (.NOT.IGNORE_ISOLATED_) THEN + NO = NO + 1 + ELSE + IF (.NOT.((C1==1.AND.C2==1) .OR. (C1==LEN(SELF%RAW)-LEN(SUBSTRING)+1))) THEN + NO = NO + 1 + ENDIF + ENDIF + C1 = C1 + C2 - 1 + LEN(SUBSTRING) + ENDDO + ENDIF + ENDFUNCTION SCOUNT + + ELEMENTAL FUNCTION SINDEX_STRING_STRING(SELF, SUBSTRING, BACK) RESULT(I) + !< RETURN THE POSITION OF THE START OF THE FIRST OCCURRENCE OF STRING `SUBSTRING` AS A SUBSTRING IN `STRING`, COUNTING FROM ONE. + !< IF `SUBSTRING` IS NOT PRESENT IN `STRING`, ZERO IS RETURNED. IF THE BACK ARGUMENT IS PRESENT AND TRUE, THE RETURN VALUE IS + !< THE START OF THE LAST OCCURRENCE RATHER THAN THE FIRST. + !< + !<```FORTRAN + !< TYPE(STRING) :: STRING1 + !< TYPE(STRING) :: STRING2 + !< LOGICAL :: TEST_PASSED(2) + !< STRING1 = 'HELLO WORLD HELLO!' + !< STRING2 = 'LLO' + !< TEST_PASSED(1) = STRING1%INDEX(SUBSTRING=STRING2)==INDEX(STRING='HELLO WORLD HELLO!', SUBSTRING='LLO') + !< TEST_PASSED(2) = STRING1%INDEX(SUBSTRING=STRING2, BACK=.TRUE.)==INDEX(STRING='HELLO WORLD HELLO!', SUBSTRING='LLO', & + !< BACK=.TRUE.) + !< PRINT '(L1)', ALL(TEST_PASSED) + !<``` + !=> T <<< + CLASS(STRING), INTENT(IN) :: SELF !< THE STRING. + TYPE(STRING), INTENT(IN) :: SUBSTRING !< SEARCHED SUBSTRING. + LOGICAL, INTENT(IN), OPTIONAL :: BACK !< START OF THE LAST OCCURRENCE RATHER THAN THE FIRST. + INTEGER :: I !< RESULT OF THE SEARCH. + + IF (ALLOCATED(SELF%RAW)) THEN + I = INDEX(STRING=SELF%RAW, SUBSTRING=SUBSTRING%RAW, BACK=BACK) + ELSE + I = 0 + ENDIF + ENDFUNCTION SINDEX_STRING_STRING + + ELEMENTAL FUNCTION SINDEX_STRING_CHARACTER(SELF, SUBSTRING, BACK) RESULT(I) + !< RETURN THE POSITION OF THE START OF THE FIRST OCCURRENCE OF STRING `SUBSTRING` AS A SUBSTRING IN `STRING`, COUNTING FROM ONE. + !< IF `SUBSTRING` IS NOT PRESENT IN `STRING`, ZERO IS RETURNED. IF THE BACK ARGUMENT IS PRESENT AND TRUE, THE RETURN VALUE IS + !< THE START OF THE LAST OCCURRENCE RATHER THAN THE FIRST. + !< + !<```FORTRAN + !< TYPE(STRING) :: STRING1 + !< LOGICAL :: TEST_PASSED(2) + !< STRING1 = 'HELLO WORLD HELLO!' + !< TEST_PASSED(1) = STRING1%INDEX(SUBSTRING='LLO')==INDEX(STRING='HELLO WORLD HELLO!', SUBSTRING='LLO') + !< TEST_PASSED(2) = STRING1%INDEX(SUBSTRING='LLO', BACK=.TRUE.)==INDEX(STRING='HELLO WORLD HELLO!', SUBSTRING='LLO', BACK=.TRUE.) + !< PRINT '(L1)', ALL(TEST_PASSED) + !<``` + !=> T <<< + CLASS(STRING), INTENT(IN) :: SELF !< THE STRING. + CHARACTER(KIND=CK, LEN=*), INTENT(IN) :: SUBSTRING !< SEARCHED SUBSTRING. + LOGICAL, INTENT(IN), OPTIONAL :: BACK !< START OF THE LAST OCCURRENCE RATHER THAN THE FIRST. + INTEGER :: I !< RESULT OF THE SEARCH. + + IF (ALLOCATED(SELF%RAW)) THEN + I = INDEX(STRING=SELF%RAW, SUBSTRING=SUBSTRING, BACK=BACK) + ELSE + I = 0 + ENDIF + ENDFUNCTION SINDEX_STRING_CHARACTER + + ELEMENTAL FUNCTION SLEN(SELF) RESULT(L) + !< RETURN THE LENGTH OF A STRING. + !< + !<```FORTRAN + !< TYPE(STRING) :: ASTRING + !< ASTRING = 'HELLO WORLD! ' + !< PRINT "(L1)", ASTRING%LEN()==LEN('HELLO WORLD! ') + !<``` + !=> T <<< + CLASS(STRING), INTENT(IN) :: SELF !< THE STRING. + INTEGER :: L !< STRING LENGTH. + + IF (ALLOCATED(SELF%RAW)) THEN + L = LEN(STRING=SELF%RAW) + ELSE + L = 0 + ENDIF + ENDFUNCTION SLEN + + ELEMENTAL FUNCTION SLEN_TRIM(SELF) RESULT(L) + !< RETURN THE LENGTH OF A STRING, IGNORING ANY TRAILING BLANKS. + !< + !<```FORTRAN + !< TYPE(STRING) :: ASTRING + !< ASTRING = 'HELLO WORLD! ' + !< PRINT "(L1)", ASTRING%LEN_TRIM()==LEN_TRIM('HELLO WORLD! ') + !<``` + !=> T <<< + CLASS(STRING), INTENT(IN) :: SELF !< THE STRING. + INTEGER :: L !< STRING LENGTH. + + IF (ALLOCATED(SELF%RAW)) THEN + L = LEN_TRIM(STRING=SELF%RAW) + ELSE + L = 0 + ENDIF + ENDFUNCTION SLEN_TRIM + + ELEMENTAL FUNCTION SREPEAT_STRING_STRING(SELF, NCOPIES) RESULT(REPEATED) + !< CONCATENATES SEVERAL COPIES OF AN INPUT STRING. + !< + !<```FORTRAN + !< TYPE(STRING) :: ASTRING + !< ASTRING = 'X' + !< PRINT "(L1)", ASTRING%REPEAT(5)//''=='XXXXX' + !<``` + !=> T <<< + CLASS(STRING), INTENT(IN) :: SELF !< STRING TO BE REPEATED. + INTEGER, INTENT(IN) :: NCOPIES !< NUMBER OF STRING COPIES. + TYPE(STRING) :: REPEATED !< REPEATED STRING. +#ifdef _NVF + CHARACTER(9999) :: NVF_BUG !< WORK AROUND FOR NVFORTRAN BUG. +#endif + +#ifdef _NVF + NVF_BUG = SELF%RAW + REPEATED%RAW = REPEAT(STRING=TRIM(NVF_BUG), NCOPIES=NCOPIES) +#else + REPEATED%RAW = REPEAT(STRING=SELF%RAW, NCOPIES=NCOPIES) +#endif + ENDFUNCTION SREPEAT_STRING_STRING + + ELEMENTAL FUNCTION SREPEAT_CHARACTER_STRING(RSTRING, NCOPIES) RESULT(REPEATED) + !< CONCATENATES SEVERAL COPIES OF AN INPUT STRING. + !< + !<```FORTRAN + !< TYPE(STRING) :: ASTRING + !< ASTRING = 'Y' + !< PRINT "(L1)", ASTRING%REPEAT('X', 5)//''=='XXXXX' + !<``` + !=> T <<< + CHARACTER(KIND=CK, LEN=*), INTENT(IN) :: RSTRING !< STRING TO BE REPEATED. + INTEGER, INTENT(IN) :: NCOPIES !< NUMBER OF STRING COPIES. + TYPE(STRING) :: REPEATED !< REPEATED STRING. + + REPEATED%RAW = REPEAT(STRING=RSTRING, NCOPIES=NCOPIES) + ENDFUNCTION SREPEAT_CHARACTER_STRING + + ELEMENTAL FUNCTION SSCAN_STRING_STRING(SELF, SET, BACK) RESULT(I) + !< RETURN THE LEFTMOST (IF `BACK` IS EITHER ABSENT OR EQUALS FALSE, OTHERWISE THE RIGHTMOST) CHARACTER OF STRING THAT IS IN `SET`. + !< + !<```FORTRAN + !< TYPE(STRING) :: STRING1 + !< TYPE(STRING) :: STRING2 + !< LOGICAL :: TEST_PASSED(2) + !< STRING1 = 'HELLO WORLD HELLO!' + !< STRING2 = 'LLO' + !< TEST_PASSED(1) = STRING1%SCAN(SET=STRING2)==SCAN(STRING='HELLO WORLD HELLO!', SET='LLO') + !< TEST_PASSED(2) = STRING1%SCAN(SET=STRING2, BACK=.TRUE.)==SCAN(STRING='HELLO WORLD HELLO!', SET='LLO', BACK=.TRUE.) + !< PRINT '(L1)', ALL(TEST_PASSED) + !<``` + !=> T <<< + CLASS(STRING), INTENT(IN) :: SELF !< THE STRING. + TYPE(STRING), INTENT(IN) :: SET !< SEARCHED SET. + LOGICAL, INTENT(IN), OPTIONAL :: BACK !< START OF THE LAST OCCURRENCE RATHER THAN THE FIRST. + INTEGER :: I !< RESULT OF THE SEARCH. + + IF (ALLOCATED(SELF%RAW).AND.ALLOCATED(SET%RAW)) THEN + I = SCAN(STRING=SELF%RAW, SET=SET%RAW, BACK=BACK) + ELSE + I = 0 + ENDIF + ENDFUNCTION SSCAN_STRING_STRING + + ELEMENTAL FUNCTION SSCAN_STRING_CHARACTER(SELF, SET, BACK) RESULT(I) + !< RETURN THE LEFTMOST (IF `BACK` IS EITHER ABSENT OR EQUALS FALSE, OTHERWISE THE RIGHTMOST) CHARACTER OF STRING THAT IS IN `SET`. + !< + !<```FORTRAN + !< TYPE(STRING) :: STRING1 + !< LOGICAL :: TEST_PASSED(2) + !< STRING1 = 'HELLO WORLD HELLO!' + !< TEST_PASSED(1) = STRING1%SCAN(SET='LLO')==SCAN(STRING='HELLO WORLD HELLO!', SET='LLO') + !< TEST_PASSED(2) = STRING1%SCAN(SET='LLO', BACK=.TRUE.)==SCAN(STRING='HELLO WORLD HELLO!', SET='LLO', BACK=.TRUE.) + !< PRINT '(L1)', ALL(TEST_PASSED) + !<``` + !=> T <<< + CLASS(STRING), INTENT(IN) :: SELF !< THE STRING. + CHARACTER(KIND=CK, LEN=*), INTENT(IN) :: SET !< SEARCHED SET. + LOGICAL, INTENT(IN), OPTIONAL :: BACK !< START OF THE LAST OCCURRENCE RATHER THAN THE FIRST. + INTEGER :: I !< RESULT OF THE SEARCH. + + IF (ALLOCATED(SELF%RAW)) THEN + I = SCAN(STRING=SELF%RAW, SET=SET, BACK=BACK) + ELSE + I = 0 + ENDIF + ENDFUNCTION SSCAN_STRING_CHARACTER + + ELEMENTAL FUNCTION STRIM(SELF) RESULT(TRIMMED) + !< REMOVE TRAILING SPACES. + !< + !<```FORTRAN + !< TYPE(STRING) :: ASTRING + !< ASTRING = 'HELLO WORLD! ' + !< PRINT "(L1)", ASTRING%TRIM()==TRIM('HELLO WORLD! ') + !<``` + !=> T <<< + CLASS(STRING), INTENT(IN) :: SELF !< THE STRING. + TYPE(STRING) :: TRIMMED !< TRIMMED STRING. + + TRIMMED = SELF + IF (ALLOCATED(TRIMMED%RAW)) TRIMMED%RAW = TRIM(TRIMMED%RAW) + ENDFUNCTION STRIM + + ELEMENTAL FUNCTION SVERIFY_STRING_STRING(SELF, SET, BACK) RESULT(I) + !< RETURN THE LEFTMOST (IF `BACK` IS EITHER ABSENT OR EQUALS FALSE, OTHERWISE THE RIGHTMOST) CHARACTER OF STRING THAT IS NOT + !< IN `SET`. IF ALL CHARACTERS OF `STRING` ARE FOUND IN `SET`, THE RESULT IS ZERO. + !< + !<```FORTRAN + !< TYPE(STRING) :: STRING1 + !< TYPE(STRING) :: STRING2 + !< LOGICAL :: TEST_PASSED(2) + !< STRING1 = 'HELLO WORLD HELLO!' + !< STRING2 = 'LLO' + !< TEST_PASSED(1) = STRING1%VERIFY(SET=STRING2)==VERIFY(STRING='HELLO WORLD HELLO!', SET='LLO') + !< TEST_PASSED(2) = STRING1%VERIFY(SET=STRING2, BACK=.TRUE.)==VERIFY(STRING='HELLO WORLD HELLO!', SET='LLO', BACK=.TRUE.) + !< PRINT '(L1)', ALL(TEST_PASSED) + !<``` + !=> T <<< + CLASS(STRING), INTENT(IN) :: SELF !< THE STRING. + TYPE(STRING), INTENT(IN) :: SET !< SEARCHED SET. + LOGICAL, INTENT(IN), OPTIONAL :: BACK !< START OF THE LAST OCCURRENCE RATHER THAN THE FIRST. + INTEGER :: I !< RESULT OF THE SEARCH. + + IF (ALLOCATED(SELF%RAW).AND.ALLOCATED(SET%RAW)) THEN + I = VERIFY(STRING=SELF%RAW, SET=SET%RAW, BACK=BACK) + ELSE + I = 0 + ENDIF + ENDFUNCTION SVERIFY_STRING_STRING + + ELEMENTAL FUNCTION SVERIFY_STRING_CHARACTER(SELF, SET, BACK) RESULT(I) + !< RETURN THE LEFTMOST (IF `BACK` IS EITHER ABSENT OR EQUALS FALSE, OTHERWISE THE RIGHTMOST) CHARACTER OF STRING THAT IS NOT + !< IN `SET`. IF ALL CHARACTERS OF `STRING` ARE FOUND IN `SET`, THE RESULT IS ZERO. + !< + !<```FORTRAN + !< TYPE(STRING) :: STRING1 + !< LOGICAL :: TEST_PASSED(2) + !< STRING1 = 'HELLO WORLD HELLO!' + !< TEST_PASSED(1) = STRING1%VERIFY(SET='LLO')==VERIFY(STRING='HELLO WORLD HELLO!', SET='LLO') + !< TEST_PASSED(2) = STRING1%VERIFY(SET='LLO', BACK=.TRUE.)==VERIFY(STRING='HELLO WORLD HELLO!', SET='LLO', BACK=.TRUE.) + !< PRINT '(L1)', ALL(TEST_PASSED) + !<``` + !=> T <<< + CLASS(STRING), INTENT(IN) :: SELF !< THE STRING. + CHARACTER(KIND=CK, LEN=*), INTENT(IN) :: SET !< SEARCHED SET. + LOGICAL, INTENT(IN), OPTIONAL :: BACK !< START OF THE LAST OCCURRENCE RATHER THAN THE FIRST. + INTEGER :: I !< RESULT OF THE SEARCH. + + IF (ALLOCATED(SELF%RAW)) THEN + I = VERIFY(STRING=SELF%RAW, SET=SET, BACK=BACK) + ELSE + I = 0 + ENDIF + ENDFUNCTION SVERIFY_STRING_CHARACTER + + ! AUXILIARY METHODS + ELEMENTAL FUNCTION BASEDIR(SELF, SEP) + !< RETURN THE BASE DIRECTORY NAME OF A STRING CONTAINING A FILE NAME. + !< + !<```FORTRAN + !< TYPE(STRING) :: STRING1 + !< LOGICAL :: TEST_PASSED(4) + !< STRING1 = '/BAR/FOO.TAR.BZ2' + !< TEST_PASSED(1) = STRING1%BASEDIR()//''=='/BAR' + !< STRING1 = './BAR/FOO.TAR.BZ2' + !< TEST_PASSED(2) = STRING1%BASEDIR()//''=='./BAR' + !< STRING1 = 'BAR/FOO.TAR.BZ2' + !< TEST_PASSED(3) = STRING1%BASEDIR()//''=='BAR' + !< STRING1 = '\BAR\FOO.TAR.BZ2' + !< TEST_PASSED(4) = STRING1%BASEDIR(SEP='\')//''=='\BAR' + !< PRINT '(L1)', ALL(TEST_PASSED) + !<``` + !=> T <<< + CLASS(STRING), INTENT(IN) :: SELF !< THE STRING. + CHARACTER(KIND=CK, LEN=*), INTENT(IN), OPTIONAL :: SEP !< DIRECTORY SEPARATOR. + TYPE(STRING) :: BASEDIR !< BASE DIRECTORY NAME. + CHARACTER(KIND=CK, LEN=:), ALLOCATABLE :: SEP_ !< SEPARATOR, DEFAULT VALUE. + INTEGER :: POS !< CHARACTER POSITION. + + IF (ALLOCATED(SELF%RAW)) THEN + SEP_ = UIX_DIR_SEP ; IF (PRESENT(SEP)) SEP_ = SEP + BASEDIR = SELF + POS = INDEX(SELF%RAW, SEP_, BACK=.TRUE.) + IF (POS>0) BASEDIR%RAW = SELF%RAW(1:POS-1) + ENDIF + ENDFUNCTION BASEDIR + + ELEMENTAL FUNCTION BASENAME(SELF, SEP, EXTENSION, STRIP_LAST_EXTENSION) + !< RETURN THE BASE FILE NAME OF A STRING CONTAINING A FILE NAME. + !< + !< OPTIONALLY, THE EXTENSION IS ALSO STRIPPED IF PROVIDED OR THE LAST ONE IF REQUIRED, E.G. + !< + !<```FORTRAN + !< TYPE(STRING) :: ASTRING + !< LOGICAL :: TEST_PASSED(5) + !< ASTRING = 'BAR/FOO.TAR.BZ2' + !< TEST_PASSED(1) = ASTRING%BASENAME()//''=='FOO.TAR.BZ2' + !< TEST_PASSED(2) = ASTRING%BASENAME(EXTENSION='.TAR.BZ2')//''=='FOO' + !< TEST_PASSED(3) = ASTRING%BASENAME(STRIP_LAST_EXTENSION=.TRUE.)//''=='FOO.TAR' + !< ASTRING = '\BAR\FOO.TAR.BZ2' + !< TEST_PASSED(4) = ASTRING%BASENAME(SEP='\')//''=='FOO.TAR.BZ2' + !< ASTRING = 'BAR' + !< TEST_PASSED(5) = ASTRING%BASENAME(STRIP_LAST_EXTENSION=.TRUE.)//''=='BAR' + !< PRINT '(L1)', ALL(TEST_PASSED) + !<``` + !=> T <<< + CLASS(STRING), INTENT(IN) :: SELF !< THE STRING. + CHARACTER(KIND=CK, LEN=*), INTENT(IN), OPTIONAL :: SEP !< DIRECTORY SEPARATOR. + CHARACTER(KIND=CK, LEN=*), INTENT(IN), OPTIONAL :: EXTENSION !< FILE EXTENSION. + LOGICAL, INTENT(IN), OPTIONAL :: STRIP_LAST_EXTENSION !< FLAG TO ENABLE THE STRIPPING OF LAST EXTENSION. + TYPE(STRING) :: BASENAME !< BASE FILE NAME. + CHARACTER(KIND=CK, LEN=:), ALLOCATABLE :: SEP_ !< SEPARATOR, DEFAULT VALUE. + INTEGER :: POS !< CHARACTER POSITION. + + IF (ALLOCATED(SELF%RAW)) THEN + SEP_ = UIX_DIR_SEP ; IF (PRESENT(SEP)) SEP_ = SEP + BASENAME = SELF + POS = INDEX(BASENAME%RAW, SEP_, BACK=.TRUE.) + IF (POS>0) BASENAME%RAW = SELF%RAW(POS+1:) + IF (PRESENT(EXTENSION)) THEN + POS = INDEX(BASENAME%RAW, EXTENSION, BACK=.TRUE.) + IF (POS>0) BASENAME%RAW = BASENAME%RAW(1:POS-1) + ELSEIF (PRESENT(STRIP_LAST_EXTENSION)) THEN + IF (STRIP_LAST_EXTENSION) THEN + POS = INDEX(BASENAME%RAW, '.', BACK=.TRUE.) + IF (POS>0) BASENAME%RAW = BASENAME%RAW(1:POS-1) + ENDIF + ENDIF + ENDIF + ENDFUNCTION BASENAME + + ELEMENTAL FUNCTION CAMELCASE(SELF, SEP) + !< RETURN A STRING WITH ALL WORDS CAPITALIZED WITHOUT SPACES. + !< + !< @NOTE MULTIPLE SUBSEQUENT SEPARATORS ARE COLLAPSED TO ONE OCCURENCE. + !< + !<```FORTRAN + !< TYPE(STRING) :: ASTRING + !< ASTRING = 'CAMEL CASE VAR' + !< PRINT '(L1)', ASTRING%CAMELCASE()//''=='CAMELCASEVAR' + !<``` + !=> T <<< + CLASS(STRING), INTENT(IN) :: SELF !< THE STRING. + CHARACTER(KIND=CK, LEN=*), INTENT(IN), OPTIONAL :: SEP !< SEPARATOR. + TYPE(STRING) :: CAMELCASE !< CAMEL CASE STRING. + TYPE(STRING), ALLOCATABLE :: TOKENS(:) !< STRING TOKENS. + + IF (ALLOCATED(SELF%RAW)) THEN + CALL SELF%SPLIT(TOKENS=TOKENS, SEP=SEP) + TOKENS = TOKENS%CAPITALIZE() + CAMELCASE = CAMELCASE%JOIN(ARRAY=TOKENS) + ENDIF + ENDFUNCTION CAMELCASE + + ELEMENTAL FUNCTION CAPITALIZE(SELF) RESULT(CAPITALIZED) + !< RETURN A STRING WITH ITS FIRST CHARACTER CAPITALIZED AND THE REST LOWERCASED. + !< + !<```FORTRAN + !< TYPE(STRING) :: ASTRING + !< ASTRING = 'SAY ALL HELLO WORLD!' + !< PRINT '(L1)', ASTRING%CAPITALIZE()//''=='SAY ALL HELLO WORLD!' + !<``` + !=> T <<< + CLASS(STRING), INTENT(IN) :: SELF !< THE STRING. + TYPE(STRING) :: CAPITALIZED !< UPPER CASE STRING. + INTEGER :: C !< CHARACTER COUNTER. + + IF (ALLOCATED(SELF%RAW)) THEN + CAPITALIZED = SELF%LOWER() + C = INDEX(LOWER_ALPHABET, CAPITALIZED%RAW(1:1)) + IF (C>0) CAPITALIZED%RAW(1:1) = UPPER_ALPHABET(C:C) + ENDIF + ENDFUNCTION CAPITALIZE + + PURE FUNCTION CHARS(SELF) RESULT(RAW) + !< RETURN THE RAW CHARACTERS DATA. + !< + !<```FORTRAN + !< TYPE(STRING) :: ASTRING + !< ASTRING = 'SAY ALL HELLO WORLD!' + !< PRINT '(L1)', ASTRING%CHARS()=='SAY ALL HELLO WORLD!' + !<``` + !=> T <<< + CLASS(STRING), INTENT(IN) :: SELF !< THE STRING. + CHARACTER(KIND=CK, LEN=:), ALLOCATABLE :: RAW !< RAW CHARACTERS DATA. + + IF (ALLOCATED(SELF%RAW)) THEN + RAW = SELF%RAW + ELSE + RAW = '' + ENDIF + ENDFUNCTION CHARS + + PURE FUNCTION COLORIZE_STR(SELF, COLOR_FG, COLOR_BG, STYLE) RESULT(COLORIZED) + !< COLORIZE AND STYLIZE STRINGS, DEFAULT KIND. + !< + !<```FORTRAN + !< TYPE(STRING) :: ASTRING + !< ASTRING = 'SAY ALL HELLO WORLD!' + !< PRINT '(L1)', ASTRING%COLORIZE(COLOR_FG='RED')=='[31MSAY ALL HELLO WORLD![0M' + !<``` + !=> T <<< + CLASS(STRING), INTENT(IN) :: SELF !< THE STRING. + CHARACTER(LEN=*), INTENT(IN), OPTIONAL :: COLOR_FG !< FOREGROUND COLOR DEFINITION. + CHARACTER(LEN=*), INTENT(IN), OPTIONAL :: COLOR_BG !< BACKGROUND COLOR DEFINITION. + CHARACTER(LEN=*), INTENT(IN), OPTIONAL :: STYLE !< STYLE DEFINITION. + CHARACTER(LEN=:), ALLOCATABLE :: COLORIZED !< COLORIZED STRING. + + COLORIZED = COLORIZE(STRING=SELF%CHARS(), COLOR_FG=COLOR_FG, COLOR_BG=COLOR_BG, STYLE=STYLE) + ENDFUNCTION COLORIZE_STR + + ELEMENTAL FUNCTION DECODE(SELF, CODEC) RESULT(DECODED) + !< RETURN A STRING DECODED ACCORDINGLY THE CODEC. + !< + !< @NOTE ONLY BASE64 CODEC IS CURRENTLY AVAILABLE. + !< + !<```FORTRAN + !< TYPE(STRING) :: ASTRING + !< ASTRING = 'SG93IGFYZSB5B3U/' + !< PRINT '(L1)', ASTRING%DECODE(CODEC='BASE64')//''=='HOW ARE YOU?' + !<``` + !=> T <<< + CLASS(STRING), INTENT(IN) :: SELF !< THE STRING. + CHARACTER(KIND=CK, LEN=*), INTENT(IN) :: CODEC !< ENCODING CODEC. + TYPE(STRING) :: DECODED !< DECODED STRING. + TYPE(STRING) :: CODEC_U !< ENCODING CODEC IN UPPER CASE STRING. + + IF (ALLOCATED(SELF%RAW)) THEN + DECODED = SELF + CODEC_U = CODEC + SELECT CASE(CODEC_U%UPPER()//'') + CASE('BASE64') + CALL B64_DECODE(CODE=SELF%RAW, S=DECODED%RAW) + ENDSELECT + DECODED = DECODED%STRIP(REMOVE_NULLS=.TRUE.) + ENDIF + ENDFUNCTION DECODE + + ELEMENTAL FUNCTION ENCODE(SELF, CODEC) RESULT(ENCODED) + !< RETURN A STRING ENCODED ACCORDINGLY THE CODEC. + !< + !< @NOTE ONLY BASE64 CODEC IS CURRENTLY AVAILABLE. + !< + !<```FORTRAN + !< TYPE(STRING) :: ASTRING + !< ASTRING = 'HOW ARE YOU?' + !< PRINT '(L1)', ASTRING%ENCODE(CODEC='BASE64')//''=='SG93IGFYZSB5B3U/' + !<``` + !=> T <<< + CLASS(STRING), INTENT(IN) :: SELF !< THE STRING. + CHARACTER(KIND=CK, LEN=*), INTENT(IN) :: CODEC !< ENCODING CODEC. + TYPE(STRING) :: ENCODED !< ENCODED STRING. + + IF (ALLOCATED(SELF%RAW)) THEN + ENCODED = CODEC + SELECT CASE(ENCODED%UPPER()//'') + CASE('BASE64') + CALL B64_ENCODE(S=SELF%RAW, CODE=ENCODED%RAW) + ENDSELECT + ENDIF + ENDFUNCTION ENCODE + + ELEMENTAL FUNCTION ESCAPE(SELF, TO_ESCAPE, ESC) RESULT(ESCAPED) + !< ESCAPE BACKSLASHES (OR CUSTOM ESCAPE CHARACTER). + !< + !<```FORTRAN + !< TYPE(STRING) :: ASTRING + !< LOGICAL :: TEST_PASSED(2) + !< ASTRING = '^\S \D+\S*' + !< TEST_PASSED(1) = ASTRING%ESCAPE(TO_ESCAPE='\')//''=='^\\S \\D+\\S*' + !< TEST_PASSED(2) = ASTRING%ESCAPE(TO_ESCAPE='\', ESC='|')//''=='^|\S |\D+|\S*' + !< PRINT '(L1)', ALL(TEST_PASSED) + !<``` + !=> T <<< + CLASS(STRING), INTENT(IN) :: SELF !< THE STRING. + CHARACTER(KIND=CK, LEN=1), INTENT(IN) :: TO_ESCAPE !< CHARACTER TO BE ESCAPED. + CHARACTER(KIND=CK, LEN=*), INTENT(IN), OPTIONAL :: ESC !< CHARACTER USED TO ESCAPE. + TYPE(STRING) :: ESCAPED !< ESCAPED STRING. + CHARACTER(KIND=CK, LEN=:), ALLOCATABLE :: ESC_ !< CHARACTER TO ESCAPE, LOCAL VARIABLE. + INTEGER :: C !< CHARACTER COUNTER. + + IF (ALLOCATED(SELF%RAW)) THEN + ESC_ = BACKSLASH ; IF (PRESENT(ESC)) ESC_ = ESC + ESCAPED%RAW = '' + DO C=1, LEN(SELF%RAW) + IF (SELF%RAW(C:C)==TO_ESCAPE) THEN + ESCAPED%RAW = ESCAPED%RAW//ESC_//TO_ESCAPE + ELSE + ESCAPED%RAW = ESCAPED%RAW//SELF%RAW(C:C) + ENDIF + ENDDO + ENDIF + ENDFUNCTION ESCAPE + + ELEMENTAL FUNCTION EXTENSION(SELF) + !< RETURN THE EXTENSION OF A STRING CONTAINING A FILE NAME. + !< + !<```FORTRAN + !< TYPE(STRING) :: ASTRING + !< ASTRING = '/BAR/FOO.TAR.BZ2' + !< PRINT '(L1)', ASTRING%EXTENSION()//''=='.BZ2' + !<``` + !=> T <<< + CLASS(STRING), INTENT(IN) :: SELF !< THE STRING. + TYPE(STRING) :: EXTENSION !< EXTENSION FILE NAME. + INTEGER :: POS !< CHARACTER POSITION. + + IF (ALLOCATED(SELF%RAW)) THEN + EXTENSION = '' + POS = INDEX(SELF%RAW, '.', BACK=.TRUE.) + IF (POS>0) EXTENSION%RAW = SELF%RAW(POS:) + ENDIF + ENDFUNCTION EXTENSION + + ELEMENTAL FUNCTION FILL(SELF, WIDTH, RIGHT, FILLING_CHAR) RESULT(FILLED) + !< PAD STRING ON THE LEFT (OR RIGHT) WITH ZEROS (OR OTHER CHAR) TO FILL WIDTH. + !< + !<```FORTRAN + !< TYPE(STRING) :: ASTRING + !< LOGICAL :: TEST_PASSED(4) + !< ASTRING = 'THIS IS STRING EXAMPLE....WOW!!!' + !< TEST_PASSED(1) = ASTRING%FILL(WIDTH=40)//''=='00000000THIS IS STRING EXAMPLE....WOW!!!' + !< TEST_PASSED(2) = ASTRING%FILL(WIDTH=50)//''=='000000000000000000THIS IS STRING EXAMPLE....WOW!!!' + !< TEST_PASSED(3) = ASTRING%FILL(WIDTH=50, RIGHT=.TRUE.)//''=='THIS IS STRING EXAMPLE....WOW!!!000000000000000000' + !< TEST_PASSED(4) = ASTRING%FILL(WIDTH=40, FILLING_CHAR='*')//''=='********THIS IS STRING EXAMPLE....WOW!!!' + !< PRINT '(L1)', ALL(TEST_PASSED) + !<``` + !=> T <<< + CLASS(STRING), INTENT(IN) :: SELF !< THE STRING. + INTEGER, INTENT(IN) :: WIDTH !< FINAL WIDTH OF FILLED STRING. + LOGICAL, INTENT(IN), OPTIONAL :: RIGHT !< FILL ON THE RIGHT INSTEAD OF LEFT. + CHARACTER(KIND=CK, LEN=1), INTENT(IN), OPTIONAL :: FILLING_CHAR !< FILLING CHARACTER (DEFAULT "0"). + TYPE(STRING) :: FILLED !< FILLED STRING. + LOGICAL :: RIGHT_ !< FILL ON THE RIGHT INSTEAD OF LEFT, LOCAL VARIABLE. + CHARACTER(KIND=CK, LEN=1) :: FILLING_CHAR_ !< FILLING CHARACTER (DEFAULT "0"), LOCAL VARIABLE. + + IF (ALLOCATED(SELF%RAW)) THEN + IF (WIDTH>LEN(SELF%RAW)) THEN + RIGHT_ = .FALSE. ; IF (PRESENT(RIGHT)) RIGHT_ = RIGHT + FILLING_CHAR_ = '0' ; IF (PRESENT(FILLING_CHAR)) FILLING_CHAR_ = FILLING_CHAR + IF (.NOT.RIGHT_) THEN + FILLED%RAW = REPEAT(FILLING_CHAR_, WIDTH-LEN(SELF%RAW))//SELF%RAW + ELSE + FILLED%RAW = SELF%RAW//REPEAT(FILLING_CHAR_, WIDTH-LEN(SELF%RAW)) + ENDIF + ENDIF + ENDIF + ENDFUNCTION FILL + + ELEMENTAL SUBROUTINE FREE(SELF) + !< FREE DYNAMIC MEMORY. + !< + !<```FORTRAN + !< TYPE(STRING) :: ASTRING + !< ASTRING = 'THIS IS STRING EXAMPLE....WOW!!!' + !< CALL ASTRING%FREE + !< PRINT '(L1)', ASTRING%IS_ALLOCATED().EQV..FALSE. + !<``` + !=> T <<< + CLASS(STRING), INTENT(INOUT) :: SELF !< THE STRING. + + IF (ALLOCATED(SELF%RAW)) DEALLOCATE(SELF%RAW) + ENDSUBROUTINE FREE + + SUBROUTINE GLOB_CHARACTER(SELF, PATTERN, LIST) + !< GLOB SEARCH (CHARACTER OUTPUT), FINDS ALL THE PATHNAMES MATCHING A GIVEN PATTERN ACCORDING TO THE RULES USED BY THE UNIX SHELL. + !< + !< @NOTE METHOD NOT PORTABLE: WORKS ONLY ON UNIX/GNU LINUX OS. + !< + !<```FORTRAN + !< TYPE(STRING) :: ASTRING + !< CHARACTER(LEN=:), ALLOCATABLE :: ALIST_CHR(:) + !< INTEGER, PARAMETER :: NF=5 + !< CHARACTER(14) :: FILES(1:NF) + !< INTEGER :: FILE_UNIT + !< INTEGER :: F + !< INTEGER :: FF + !< LOGICAL :: TEST_PASSED + !< DO F=1, NF + !< FILES(F) = ASTRING%TEMPNAME(PREFIX='FOO-') + !< OPEN(NEWUNIT=FILE_UNIT, FILE=FILES(F)) + !< WRITE(FILE_UNIT, *)F + !< CLOSE(UNIT=FILE_UNIT) + !< ENDDO + !< CALL ASTRING%GLOB(PATTERN='FOO-*', LIST=ALIST_CHR) + !< DO F=1, NF + !< OPEN(NEWUNIT=FILE_UNIT, FILE=FILES(F)) + !< CLOSE(UNIT=FILE_UNIT, STATUS='DELETE') + !< ENDDO + !< TEST_PASSED = .FALSE. + !< OUTER_CHR: DO F=1, SIZE(ALIST_CHR, DIM=1) + !< DO FF=1, NF + !< TEST_PASSED = ALIST_CHR(F) == FILES(FF) + !< IF (TEST_PASSED) CYCLE OUTER_CHR + !< ENDDO + !< ENDDO OUTER_CHR + !< PRINT '(L1)', TEST_PASSED + !<``` + !=> T <<< + CLASS(STRING), INTENT(IN) :: SELF !< THE STRING. + CHARACTER(*), INTENT(IN) :: PATTERN !< GIVEN PATTERN. + CHARACTER(LEN=:), ALLOCATABLE, INTENT(OUT) :: LIST(:) !< LIST OF MATCHING PATHNAMES. + TYPE(STRING), ALLOCATABLE :: LIST_(:) !< LIST OF MATCHING PATHNAMES. + INTEGER(I4P) :: MAX_LEN !< MAXIMUM LENGTH. + INTEGER(I4P) :: MATCHES_NUMBER !< MATCHES NUMBER. + INTEGER(I4P) :: M !< COUNTER. + + CALL SELF%GLOB(PATTERN=PATTERN, LIST=LIST_) + IF (ALLOCATED(LIST_)) THEN + MATCHES_NUMBER = SIZE(LIST_, DIM=1) + MAX_LEN = 0 + DO M=1, MATCHES_NUMBER + MAX_LEN = MAX(MAX_LEN, LIST_(M)%LEN()) + ENDDO + ALLOCATE(CHARACTER(MAX_LEN) :: LIST(1:MATCHES_NUMBER)) + DO M=1, MATCHES_NUMBER + LIST(M) = LIST_(M)%CHARS() + ENDDO + ENDIF + ENDSUBROUTINE GLOB_CHARACTER + + SUBROUTINE GLOB_STRING(SELF, PATTERN, LIST) + !< GLOB SEARCH (STRING OUTPUT), FINDS ALL THE PATHNAMES MATCHING A GIVEN PATTERN ACCORDING TO THE RULES USED BY THE UNIX SHELL. + !< + !< @NOTE METHOD NOT PORTABLE: WORKS ONLY ON UNIX/GNU LINUX OS. + !< + !<```FORTRAN + !< TYPE(STRING) :: ASTRING + !< TYPE(STRING), ALLOCATABLE :: ALIST_STR(:) + !< INTEGER, PARAMETER :: NF=5 + !< CHARACTER(14) :: FILES(1:NF) + !< INTEGER :: FILE_UNIT + !< INTEGER :: F + !< INTEGER :: FF + !< LOGICAL :: TEST_PASSED + !< + !< DO F=1, NF + !< FILES(F) = ASTRING%TEMPNAME(PREFIX='FOO-') + !< OPEN(NEWUNIT=FILE_UNIT, FILE=FILES(F)) + !< WRITE(FILE_UNIT, *)F + !< CLOSE(UNIT=FILE_UNIT) + !< ENDDO + !< CALL ASTRING%GLOB(PATTERN='FOO-*', LIST=ALIST_STR) + !< DO F=1, NF + !< OPEN(NEWUNIT=FILE_UNIT, FILE=FILES(F)) + !< CLOSE(UNIT=FILE_UNIT, STATUS='DELETE') + !< ENDDO + !< TEST_PASSED = .FALSE. + !< OUTER_STR: DO F=1, SIZE(ALIST_STR, DIM=1) + !< DO FF=1, NF + !< TEST_PASSED = ALIST_STR(F) == FILES(FF) + !< IF (TEST_PASSED) CYCLE OUTER_STR + !< ENDDO + !< ENDDO OUTER_STR + !< PRINT '(L1)', TEST_PASSED + !<``` + !=> T <<< + CLASS(STRING), INTENT(IN) :: SELF !< THE STRING. + CHARACTER(*), INTENT(IN) :: PATTERN !< GIVEN PATTERN. + TYPE(STRING), ALLOCATABLE, INTENT(OUT) :: LIST(:) !< LIST OF MATCHING PATHNAMES. + TYPE(STRING) :: TEMPFILE !< SAFE TEMPORARY FILE. + CHARACTER(LEN=:), ALLOCATABLE :: TEMPNAME !< SAFE TEMPORARY NAME. + INTEGER(I4P) :: TEMPUNIT !< UNIT OF TEMPORARY FILE. + + TEMPNAME = SELF%TEMPNAME() + CALL EXECUTE_COMMAND_LINE('LS -1 '//TRIM(ADJUSTL(PATTERN))//' > '//TEMPNAME) + CALL TEMPFILE%READ_FILE(FILE=TEMPNAME) + CALL TEMPFILE%SPLIT(SEP=NEW_LINE('A'), TOKENS=LIST) + OPEN(NEWUNIT=TEMPUNIT, FILE=TEMPNAME) + CLOSE(UNIT=TEMPUNIT, STATUS='DELETE') + ENDSUBROUTINE GLOB_STRING + + ELEMENTAL FUNCTION INSERT_CHARACTER(SELF, SUBSTRING, POS) RESULT(INSERTED) + !< INSERT SUBSTRING INTO STRING AT A SPECIFIED POSITION. + !< + !<```FORTRAN + !< TYPE(STRING) :: ASTRING + !< CHARACTER(LEN=:), ALLOCATABLE :: ACHARACTER + !< LOGICAL :: TEST_PASSED(5) + !< ASTRING = 'THIS IS STRING EXAMPLE WOW!!!' + !< ACHARACTER = '... ' + !< TEST_PASSED(1) = ASTRING%INSERT(SUBSTRING=ACHARACTER, POS=1)//''=='... THIS IS STRING EXAMPLE WOW!!!' + !< TEST_PASSED(2) = ASTRING%INSERT(SUBSTRING=ACHARACTER, POS=23)//''=='THIS IS STRING EXAMPLE... WOW!!!' + !< TEST_PASSED(3) = ASTRING%INSERT(SUBSTRING=ACHARACTER, POS=29)//''=='THIS IS STRING EXAMPLE WOW!!!... ' + !< TEST_PASSED(4) = ASTRING%INSERT(SUBSTRING=ACHARACTER, POS=-1)//''=='... THIS IS STRING EXAMPLE WOW!!!' + !< TEST_PASSED(5) = ASTRING%INSERT(SUBSTRING=ACHARACTER, POS=100)//''=='THIS IS STRING EXAMPLE WOW!!!... ' + !< PRINT '(L1)', ALL(TEST_PASSED) + !<``` + !=> T <<< + CLASS(STRING), INTENT(IN) :: SELF !< THE STRING. + CHARACTER(LEN=*), INTENT(IN) :: SUBSTRING !< SUBSTRING. + INTEGER, INTENT(IN) :: POS !< POSITION FROM WHICH INSERT SUBSTRING. + TYPE(STRING) :: INSERTED !< INSERTED STRING. + INTEGER :: SAFEPOS !< SAFE POSITION FROM WHICH INSERT SUBSTRING. + + IF (ALLOCATED(SELF%RAW)) THEN + INSERTED = SELF + SAFEPOS = MIN(MAX(1, POS), LEN(SELF%RAW)) + IF (SAFEPOS==1) THEN + INSERTED%RAW = SUBSTRING//SELF%RAW + ELSEIF (SAFEPOS==LEN(SELF%RAW)) THEN + INSERTED%RAW = SELF%RAW//SUBSTRING + ELSE + INSERTED%RAW = SELF%RAW(1:SAFEPOS-1)//SUBSTRING//SELF%RAW(SAFEPOS:) + ENDIF + ELSE + INSERTED%RAW = SUBSTRING + ENDIF + ENDFUNCTION INSERT_CHARACTER + + ELEMENTAL FUNCTION INSERT_STRING(SELF, SUBSTRING, POS) RESULT(INSERTED) + !< INSERT SUBSTRING INTO STRING AT A SPECIFIED POSITION. + !< + !<```FORTRAN + !< TYPE(STRING) :: ASTRING + !< TYPE(STRING) :: ANOTHERSTRING + !< LOGICAL :: TEST_PASSED(5) + !< ASTRING = 'THIS IS STRING EXAMPLE WOW!!!' + !< ANOTHERSTRING = '... ' + !< TEST_PASSED(1) = ASTRING%INSERT(SUBSTRING=ANOTHERSTRING, POS=1)//''=='... THIS IS STRING EXAMPLE WOW!!!' + !< TEST_PASSED(2) = ASTRING%INSERT(SUBSTRING=ANOTHERSTRING, POS=23)//''=='THIS IS STRING EXAMPLE... WOW!!!' + !< TEST_PASSED(3) = ASTRING%INSERT(SUBSTRING=ANOTHERSTRING, POS=29)//''=='THIS IS STRING EXAMPLE WOW!!!... ' + !< TEST_PASSED(4) = ASTRING%INSERT(SUBSTRING=ANOTHERSTRING, POS=-1)//''=='... THIS IS STRING EXAMPLE WOW!!!' + !< TEST_PASSED(5) = ASTRING%INSERT(SUBSTRING=ANOTHERSTRING, POS=100)//''=='THIS IS STRING EXAMPLE WOW!!!... ' + !< PRINT '(L1)', ALL(TEST_PASSED) + !<``` + !=> T <<< + CLASS(STRING), INTENT(IN) :: SELF !< THE STRING. + TYPE(STRING), INTENT(IN) :: SUBSTRING !< SUBSTRING. + INTEGER, INTENT(IN) :: POS !< POSITION FROM WHICH INSERT SUBSTRING. + TYPE(STRING) :: INSERTED !< INSERTED STRING. + INTEGER :: SAFEPOS !< SAFE POSITION FROM WHICH INSERT SUBSTRING. + + IF (ALLOCATED(SELF%RAW)) THEN + INSERTED = SELF + IF (ALLOCATED(SUBSTRING%RAW)) THEN + SAFEPOS = MIN(MAX(1, POS), LEN(SELF%RAW)) + IF (SAFEPOS==1) THEN + INSERTED%RAW = SUBSTRING%RAW//SELF%RAW + ELSEIF (SAFEPOS==LEN(SELF%RAW)) THEN + INSERTED%RAW = SELF%RAW//SUBSTRING%RAW + ELSE + INSERTED%RAW = SELF%RAW(1:SAFEPOS-1)//SUBSTRING%RAW//SELF%RAW(SAFEPOS:) + ENDIF + ENDIF + ELSE + IF (ALLOCATED(SUBSTRING%RAW)) INSERTED%RAW = SUBSTRING%RAW + ENDIF + ENDFUNCTION INSERT_STRING + + PURE FUNCTION JOIN_STRINGS(SELF, ARRAY, SEP) RESULT(JOIN) + !< RETURN A STRING THAT IS A JOIN OF AN ARRAY OF STRINGS. + !< + !< THE JOIN-SEPARATOR IS SET EQUALS TO SELF IF SELF HAS A VALUE OR IT IS SET TO A NULL STRING ''. THIS VALUE CAN BE OVERRIDDEN + !< PASSING A CUSTOM SEPARATOR. + !< + !<```FORTRAN + !< TYPE(STRING) :: ASTRING + !< TYPE(STRING) :: STRINGS(3) + !< LOGICAL :: TEST_PASSED(5) + !< STRINGS(1) = 'ONE' + !< STRINGS(2) = 'TWO' + !< STRINGS(3) = 'THREE' + !< TEST_PASSED(1) = (ASTRING%JOIN(ARRAY=STRINGS)//''==STRINGS(1)//STRINGS(2)//STRINGS(3)) + !< TEST_PASSED(2) = (ASTRING%JOIN(ARRAY=STRINGS, SEP='-')//''==STRINGS(1)//'-'//STRINGS(2)//'-'//STRINGS(3)) + !< CALL STRINGS(1)%FREE + !< STRINGS(2) = 'TWO' + !< STRINGS(3) = 'THREE' + !< TEST_PASSED(3) = (ASTRING%JOIN(ARRAY=STRINGS, SEP='-')//''==STRINGS(2)//'-'//STRINGS(3)) + !< STRINGS(1) = 'ONE' + !< STRINGS(2) = 'TWO' + !< CALL STRINGS(3)%FREE + !< TEST_PASSED(4) = (ASTRING%JOIN(ARRAY=STRINGS, SEP='-')//''==STRINGS(1)//'-'//STRINGS(2)) + !< STRINGS(1) = 'ONE' + !< CALL STRINGS(2)%FREE + !< STRINGS(3) = 'THREE' + !< TEST_PASSED(5) = (ASTRING%JOIN(ARRAY=STRINGS, SEP='-')//''==STRINGS(1)//'-'//STRINGS(3)) + !< PRINT '(L1)', ALL(TEST_PASSED) + !<``` + !=> T <<< + CLASS(STRING), INTENT(IN) :: SELF !< THE STRING. + TYPE(STRING), INTENT(IN) :: ARRAY(1:) !< ARRAY TO BE JOINED. + CHARACTER(KIND=CK, LEN=*), INTENT(IN), OPTIONAL :: SEP !< SEPARATOR. + TYPE(STRING) :: JOIN !< THE JOIN OF ARRAY. + CHARACTER(KIND=CK, LEN=:), ALLOCATABLE :: SEP_ !< SEPARATOR, DEFAULT VALUE. + INTEGER :: A !< COUNTER. + + IF (ALLOCATED(SELF%RAW)) THEN + SEP_ = SELF%RAW + ELSE + SEP_ = '' + ENDIF + IF (PRESENT(SEP)) SEP_ = SEP + JOIN = '' + DO A=2, SIZE(ARRAY, DIM=1) + IF (ALLOCATED(ARRAY(A)%RAW)) JOIN%RAW = JOIN%RAW//SEP_//ARRAY(A)%RAW + ENDDO + IF (ALLOCATED(ARRAY(1)%RAW)) THEN + JOIN%RAW = ARRAY(1)%RAW//JOIN%RAW + ELSE + JOIN%RAW = JOIN%RAW(LEN(SEP_)+1:LEN(JOIN%RAW)) + ENDIF + ENDFUNCTION JOIN_STRINGS + + PURE FUNCTION JOIN_CHARACTERS(SELF, ARRAY, SEP) RESULT(JOIN) + !< RETURN A STRING THAT IS A JOIN OF AN ARRAY OF CHARACTERS. + !< + !< THE JOIN-SEPARATOR IS SET EQUALS TO SELF IF SELF HAS A VALUE OR IT IS SET TO A NULL STRING ''. THIS VALUE CAN BE OVERRIDDEN + !< PASSING A CUSTOM SEPARATOR. + !< + !<```FORTRAN + !< TYPE(STRING) :: ASTRING + !< CHARACTER(5) :: CHARACTERS(3) + !< LOGICAL :: TEST_PASSED(6) + !< CHARACTERS(1) = 'ONE' + !< CHARACTERS(2) = 'TWO' + !< CHARACTERS(3) = 'THREE' + !< TEST_PASSED(1) = (ASTRING%JOIN(ARRAY=CHARACTERS)//''==CHARACTERS(1)//CHARACTERS(2)//CHARACTERS(3)) + !< TEST_PASSED(2) = (ASTRING%JOIN(ARRAY=CHARACTERS, SEP='-')//''==CHARACTERS(1)//'-'//CHARACTERS(2)//'-'//CHARACTERS(3)) + !< CHARACTERS(1) = '' + !< CHARACTERS(2) = 'TWO' + !< CHARACTERS(3) = 'THREE' + !< TEST_PASSED(3) = (ASTRING%JOIN(ARRAY=CHARACTERS, SEP='-')//''==CHARACTERS(2)//'-'//CHARACTERS(3)) + !< CHARACTERS(1) = 'ONE' + !< CHARACTERS(2) = 'TWO' + !< CHARACTERS(3) = '' + !< TEST_PASSED(4) = (ASTRING%JOIN(ARRAY=CHARACTERS, SEP='-')//''==CHARACTERS(1)//'-'//CHARACTERS(2)) + !< CHARACTERS(1) = 'ONE' + !< CHARACTERS(2) = '' + !< CHARACTERS(3) = 'THREE' + !< TEST_PASSED(5) = (ASTRING%JOIN(ARRAY=CHARACTERS, SEP='-')//''==CHARACTERS(1)//'-'//CHARACTERS(3)) + !< CHARACTERS(1) = 'ONE' + !< CHARACTERS(2) = 'TWO' + !< CHARACTERS(3) = 'THREE' + !< ASTRING = '_' + !< TEST_PASSED(6) = (ASTRING%JOIN(ARRAY=CHARACTERS)//''==CHARACTERS(1)//'_'//CHARACTERS(2)//'_'//CHARACTERS(3)) + !< PRINT '(L1)', ALL(TEST_PASSED) + !<``` + !=> T <<< + CLASS(STRING), INTENT(IN) :: SELF !< THE STRING. + CHARACTER(KIND=CK, LEN=*), INTENT(IN) :: ARRAY(1:) !< ARRAY TO BE JOINED. + CHARACTER(KIND=CK, LEN=*), INTENT(IN), OPTIONAL :: SEP !< SEPARATOR. + TYPE(STRING) :: JOIN !< THE JOIN OF ARRAY. + CHARACTER(KIND=CK, LEN=:), ALLOCATABLE :: SEP_ !< SEPARATOR, DEFAULT VALUE. + INTEGER :: A !< COUNTER. + + IF (ALLOCATED(SELF%RAW)) THEN + SEP_ = SELF%RAW + ELSE + SEP_ = '' + ENDIF + IF (PRESENT(SEP)) SEP_ = SEP + JOIN = '' + DO A=2, SIZE(ARRAY, DIM=1) + IF (ARRAY(A)/='') JOIN%RAW = JOIN%RAW//SEP_//ARRAY(A) + ENDDO + IF (ARRAY(1)/='') THEN + JOIN%RAW = ARRAY(1)//JOIN%RAW + ELSE + JOIN%RAW = JOIN%RAW(LEN(SEP_)+1:LEN(JOIN%RAW)) + ENDIF + ENDFUNCTION JOIN_CHARACTERS + + PURE FUNCTION STRJOIN_STRINGS(ARRAY, SEP) RESULT(JOIN) + !< RETURN A STRING THAT IS A JOIN OF AN ARRAY OF STRINGS. + !< + !< THE JOIN-SEPARATOR IS SET EQUALS TO A NULL STRING '' IF CUSTOM SEPARATOR ISN'T SPECIFIED. + !< + !<```FORTRAN + !< TYPE(STRING) :: STRINGS(3) + !< LOGICAL :: TEST_PASSED(5) + !< STRINGS(1) = 'ONE' + !< STRINGS(2) = 'TWO' + !< STRINGS(3) = 'THREE' + !< TEST_PASSED(1) = (STRJOIN(ARRAY=STRINGS)//''==STRINGS(1)//STRINGS(2)//STRINGS(3)) + !< TEST_PASSED(2) = (STRJOIN(ARRAY=STRINGS, SEP='-')//''==STRINGS(1)//'-'//STRINGS(2)//'-'//STRINGS(3)) + !< CALL STRINGS(1)%FREE + !< STRINGS(2) = 'TWO' + !< STRINGS(3) = 'THREE' + !< TEST_PASSED(3) = (STRJOIN(ARRAY=STRINGS, SEP='-')//''==STRINGS(2)//'-'//STRINGS(3)) + !< STRINGS(1) = 'ONE' + !< STRINGS(2) = 'TWO' + !< CALL STRINGS(3)%FREE + !< TEST_PASSED(4) = (STRJOIN(ARRAY=STRINGS, SEP='-')//''==STRINGS(1)//'-'//STRINGS(2)) + !< STRINGS(1) = 'ONE' + !< CALL STRINGS(2)%FREE + !< STRINGS(3) = 'THREE' + !< TEST_PASSED(5) = (STRJOIN(ARRAY=STRINGS, SEP='-')//''==STRINGS(1)//'-'//STRINGS(3)) + !< PRINT '(L1)', ALL(TEST_PASSED) + !<``` + !=> T <<< + CLASS(STRING), INTENT(IN) :: ARRAY(1:) !< ARRAY TO BE JOINED. + CHARACTER(KIND=CK, LEN=*), INTENT(IN), OPTIONAL :: SEP !< SEPARATOR. + TYPE(STRING) :: JOIN !< THE JOIN OF ARRAY. + CHARACTER(KIND=CK, LEN=:), ALLOCATABLE :: SEP_ !< SEPARATOR, DEFAULT VALUE. + INTEGER :: A !< COUNTER. + + SEP_ = '' + IF (PRESENT(SEP)) SEP_ = SEP + JOIN = '' + DO A=2, SIZE(ARRAY, DIM=1) + IF (ALLOCATED(ARRAY(A)%RAW))JOIN%RAW = JOIN%RAW//SEP_//ARRAY(A)%RAW + ENDDO + IF (ALLOCATED(ARRAY(1)%RAW)) THEN + JOIN%RAW = ARRAY(1)%RAW//JOIN%RAW + ELSE + JOIN%RAW = JOIN%RAW(LEN(SEP_)+1:LEN(JOIN%RAW)) + ENDIF + ENDFUNCTION STRJOIN_STRINGS + + PURE FUNCTION STRJOIN_CHARACTERS(ARRAY, SEP, IS_TRIM) RESULT(JOIN) + !< RETURN A STRING THAT IS A JOIN OF AN ARRAY OF CHARACTERS. + !< + !< THE JOIN-SEPARATOR IS SET EQUALS TO A NULL STRING '' IF CUSTOM SEPARATOR ISN'T SPECIFIED. + !< THE TRIM FUNCTION IS APPLIED TO ARRAY ITEMS IF OPTIONAL LOGICAL IS_TRIM VARIABLE ISN'T SET TO .FALSE. + !< + !<```FORTRAN + !< CHARACTER(5) :: CHARACTERS(3) + !< LOGICAL :: TEST_PASSED(13) + !< CHARACTERS(1) = 'ONE' + !< CHARACTERS(2) = 'TWO' + !< CHARACTERS(3) = 'THREE' + !< TEST_PASSED(1) = (STRJOIN(ARRAY=CHARACTERS)//''==TRIM(CHARACTERS(1))//TRIM(CHARACTERS(2))//TRIM(CHARACTERS(3))) + !< TEST_PASSED(2) = (STRJOIN(ARRAY=CHARACTERS, SEP='-')//''==TRIM(CHARACTERS(1))//'-'//TRIM(CHARACTERS(2))//'-'//TRIM(CHARACTERS(3))) + !< TEST_PASSED(3) = ( STRJOIN(ARRAY=CHARACTERS, IS_TRIM=.FALSE.)//''==CHARACTERS(1)//CHARACTERS(2)//CHARACTERS(3)) + !< TEST_PASSED(4) = ( STRJOIN(ARRAY=CHARACTERS, SEP='-', IS_TRIM=.FALSE.)//''==CHARACTERS(1)//'-'//CHARACTERS(2)//'-'//CHARACTERS(3)) + !< CHARACTERS(1) = '' + !< CHARACTERS(2) = 'TWO' + !< CHARACTERS(3) = 'THREE' + !< TEST_PASSED(5) = (STRJOIN(ARRAY=CHARACTERS)//''==TRIM(CHARACTERS(2))//TRIM(CHARACTERS(3))) + !< CHARACTERS(1) = 'ONE' + !< CHARACTERS(2) = 'TWO' + !< CHARACTERS(3) = '' + !< TEST_PASSED(6) = (STRJOIN(ARRAY=CHARACTERS)//''==TRIM(CHARACTERS(1))//TRIM(CHARACTERS(2))) + !< CHARACTERS(1) = 'ONE' + !< CHARACTERS(2) = '' + !< CHARACTERS(3) = 'THREE' + !< TEST_PASSED(7) = (STRJOIN(ARRAY=CHARACTERS)//''==TRIM(CHARACTERS(1))//TRIM(CHARACTERS(3))) + !< CHARACTERS(1) = '' + !< CHARACTERS(2) = 'TWO' + !< CHARACTERS(3) = 'THREE' + !< TEST_PASSED(8) = (STRJOIN(ARRAY=CHARACTERS, SEP='-')//''==TRIM(CHARACTERS(2))//'-'//TRIM(CHARACTERS(3))) + !< CHARACTERS(1) = 'ONE' + !< CHARACTERS(2) = 'TWO' + !< CHARACTERS(3) = '' + !< TEST_PASSED(9) = (STRJOIN(ARRAY=CHARACTERS, SEP='-')//''==TRIM(CHARACTERS(1))//'-'//TRIM(CHARACTERS(2))) + !< CHARACTERS(1) = 'ONE' + !< CHARACTERS(2) = '' + !< CHARACTERS(3) = 'THREE' + !< TEST_PASSED(10) = (STRJOIN(ARRAY=CHARACTERS, SEP='-')//''==TRIM(CHARACTERS(1))//'-'//TRIM(CHARACTERS(3))) + !< CHARACTERS(1) = '' + !< CHARACTERS(2) = 'TWO' + !< CHARACTERS(3) = 'THREE' + !< TEST_PASSED(11) = (STRJOIN(ARRAY=CHARACTERS, SEP='-', IS_TRIM=.FALSE.)//''==CHARACTERS(2)//'-'//CHARACTERS(3)) + !< CHARACTERS(1) = 'ONE' + !< CHARACTERS(2) = 'TWO' + !< CHARACTERS(3) = '' + !< TEST_PASSED(12) = (STRJOIN(ARRAY=CHARACTERS, SEP='-', IS_TRIM=.FALSE.)//''==CHARACTERS(1)//'-'//CHARACTERS(2)) + !< CHARACTERS(1) = 'ONE' + !< CHARACTERS(2) = '' + !< CHARACTERS(3) = 'THREE' + !< TEST_PASSED(13) = (STRJOIN(ARRAY=CHARACTERS, SEP='-', IS_TRIM=.FALSE.)//''==CHARACTERS(1)//'-'//CHARACTERS(3)) + !< PRINT '(L1)', ALL(TEST_PASSED) + !<``` + !=> T <<< + CHARACTER(KIND=CK, LEN=*), INTENT(IN) :: ARRAY(1:) !< ARRAY TO BE JOINED. + CHARACTER(KIND=CK, LEN=*), INTENT(IN), OPTIONAL :: SEP !< SEPARATOR. + LOGICAL, INTENT(IN), OPTIONAL :: IS_TRIM !< FLAG TO SETUP TRIM CHARACTER OR NOT + TYPE(STRING) :: JOIN !< THE JOIN OF ARRAY. + CHARACTER(KIND=CK, LEN=:), ALLOCATABLE :: SEP_ !< SEPARATOR, DEFAULT VALUE. + LOGICAL :: IS_TRIM_ !< FLAG TO SETUP TRIM CHARACTER OR NOT + INTEGER :: A !< COUNTER. + + SEP_ = '' + IF (PRESENT(SEP)) SEP_ = SEP + IS_TRIM_ = .TRUE. ; IF (PRESENT(IS_TRIM)) IS_TRIM_ = IS_TRIM + JOIN = '' + + IF (IS_TRIM_) THEN + DO A=2, SIZE(ARRAY, DIM=1) + IF (TRIM(ARRAY(A))/='') JOIN%RAW = JOIN%RAW//SEP_//TRIM(ARRAY(A)) + ENDDO + IF (TRIM(ARRAY(1))/='') THEN + JOIN%RAW = TRIM(ARRAY(1))//JOIN%RAW + ELSE + JOIN%RAW = JOIN%RAW(LEN(SEP_)+1:LEN(JOIN%RAW)) + ENDIF + ELSE + DO A=2, SIZE(ARRAY, DIM=1) + IF (ARRAY(A)/='') JOIN%RAW = JOIN%RAW//SEP_//ARRAY(A) + ENDDO + IF (ARRAY(1)/='') THEN + JOIN%RAW = ARRAY(1)//JOIN%RAW + ELSE + JOIN%RAW = JOIN%RAW(LEN(SEP_)+1:LEN(JOIN%RAW)) + ENDIF + ENDIF + ENDFUNCTION STRJOIN_CHARACTERS + + PURE FUNCTION STRJOIN_STRINGS_ARRAY(ARRAY, SEP, IS_COL) RESULT(JOIN) + !< RETURN A STRING THAT IS A JOIN OF COLUMNS OR ROWS OF AN ARRAY OF STRINGS. + !< + !< THE JOIN-SEPARATOR IS SET EQUALS TO A NULL STRING '' IF CUSTOM SEPARATOR ISN'T SPECIFIED. + !< THE IS_COL IS SETUP THE DIRECTION OF JOIN: WITHIN DEFAULT COLUMNS (.TRUE.) OR ROWS(.FALSE.). + !< + !<```FORTRAN + !< TYPE(STRING), ALLOCATABLE :: STRINGS_ARR(:, :) + !< LOGICAL :: TEST_PASSED(5) + !< + !< STRINGS_ARR = RESHAPE( SOURCE = & + !< [STRING('ONE'), STRING('TWO'), STRING('THREE'), & + !< STRING('ONE'), STRING('TWO'), STRING('THREE')], & + !< SHAPE = [3, 2] ) + !< + !< TEST_PASSED(1) = ALL( STRJOIN(ARRAY=STRINGS_ARR) == & + !< RESHAPE([STRING('ONETWOTHREE'), STRING('ONETWOTHREE')], & + !< SHAPE = [2]) ) + !< + !< TEST_PASSED(2) = ALL( STRJOIN(ARRAY=STRINGS_ARR, SEP='_') == & + !< RESHAPE([STRING('ONE_TWO_THREE'), STRING('ONE_TWO_THREE')], & + !< SHAPE = [2]) ) + !< + !< TEST_PASSED(3) = ALL( STRJOIN(ARRAY=STRINGS_ARR, IS_COL=.FALSE.) == & + !< RESHAPE([STRING('ONEONE'), STRING('TWOTWO'), STRING('THREETHREE')], & + !< SHAPE = [3]) ) + !< + !< TEST_PASSED(4) = ALL( STRJOIN(ARRAY=STRINGS_ARR, SEP='_', IS_COL=.FALSE.) == & + !< RESHAPE([STRING('ONE_ONE'), STRING('TWO_TWO'), STRING('THREE_THREE')], & + !< SHAPE = [3]) ) + !< + !< CALL STRINGS_ARR(2, 1)%FREE + !< TEST_PASSED(5) = ALL( STRJOIN(ARRAY=STRINGS_ARR, SEP='_', IS_COL=.FALSE.) == & + !< RESHAPE([STRING('ONE_ONE'), STRING('TWO'), STRING('THREE_THREE')], & + !< SHAPE = [3]) ) + !< + !< PRINT '(L1)', ALL(TEST_PASSED) + !<``` + !=> T <<< + CLASS(STRING), INTENT(IN) :: ARRAY(1:, 1:) !< ARRAY TO BE JOINED. + CHARACTER(KIND=CK, LEN=*), INTENT(IN), OPTIONAL :: SEP !< SEPARATOR. + LOGICAL, INTENT(IN), OPTIONAL :: IS_COL !< DIRECTION: 'COLUMNS' IF .TRUE. OR 'ROWS' IF .FALSE. + TYPE(STRING), ALLOCATABLE :: JOIN(:) !< THE JOIN OF ARRAY. + TYPE(STRING), ALLOCATABLE :: SLICE(:) !< THE COLUMN OR ROW SLICE OF ARRAY + CHARACTER(KIND=CK, LEN=:), ALLOCATABLE :: SEP_ !< SEPARATOR, DEFAULT VALUE. + LOGICAL :: IS_COL_ !< DIRECTION, DEFAULT VALUE. + INTEGER :: A, JOIN_SIZE, SLICE_SIZE !< COUNTER, SIZES OF JOIN VECTOR AND OF SLICE OF ARRAY + + SEP_ = '' ; IF (PRESENT(SEP)) SEP_ = SEP + IS_COL_ = .TRUE. ; IF (PRESENT(IS_COL)) IS_COL_ = IS_COL + + IF (IS_COL_) THEN + JOIN_SIZE = SIZE(ARRAY, DIM=2) + SLICE_SIZE = SIZE(ARRAY, DIM=1) + + IF (.NOT.ALLOCATED(JOIN)) ALLOCATE(JOIN(JOIN_SIZE)) + IF (.NOT.ALLOCATED(SLICE)) ALLOCATE(SLICE(SLICE_SIZE)) + DO A = 1, JOIN_SIZE + SLICE(:) = ARRAY(:, A) + JOIN(A) = STRJOIN_STRINGS(SLICE, SEP_) + END DO + ELSE + JOIN_SIZE = SIZE(ARRAY, DIM=1) + SLICE_SIZE = SIZE(ARRAY, DIM=2) + + IF (.NOT.ALLOCATED(JOIN)) ALLOCATE(JOIN(JOIN_SIZE)) + IF (.NOT.ALLOCATED(SLICE)) ALLOCATE(SLICE(SLICE_SIZE)) + DO A = 1, JOIN_SIZE + SLICE(:) = ARRAY(A, :) + JOIN(A) = STRJOIN_STRINGS(SLICE, SEP_) + END DO + ENDIF + ENDFUNCTION STRJOIN_STRINGS_ARRAY + + PURE FUNCTION STRJOIN_CHARACTERS_ARRAY(ARRAY, SEP, IS_TRIM, IS_COL) RESULT(JOIN) + !< RETURN A STRING THAT IS A JOIN OF COLUMNS OR ROWS OF AN ARRAY OF CHARACTERS. + !< + !< THE JOIN-SEPARATOR IS SET EQUALS TO A NULL STRING '' IF CUSTOM SEPARATOR ISN'T SPECIFIED. + !< THE TRIM FUNCTION IS APPLIED TO ARRAY ITEMS IF OPTIONAL LOGICAL IS_TRIM VARIABLE ISN'T SET TO .FALSE. + !< THE IS_COL IS SETUP THE DIRECTION OF JOIN: WITHIN DEFAULT COLUMNS (.TRUE.) OR ROWS(.FALSE.). + !< + !<```FORTRAN + !< CHARACTER(LEN=10) :: CHARS_ARR(3, 2) + !< LOGICAL :: TEST_PASSED(9) + !< CHARS_ARR(:, 1) = ['ONE ', 'TWO ', 'THREE '] + !< CHARS_ARR(:, 2) = ['ONE ', 'TWO ', 'THREE '] + !< + !< TEST_PASSED(1) = ALL( STRJOIN(ARRAY=CHARS_ARR) == & + !< RESHAPE([STRING('ONETWOTHREE'), STRING('ONETWOTHREE')], & + !< SHAPE = [2]) ) + !< + !< TEST_PASSED(2) = ALL( STRJOIN(ARRAY=CHARS_ARR, IS_TRIM=.FALSE.) == & + !< RESHAPE([STRING('ONE TWO THREE '), & + !< STRING('ONE TWO THREE ')], & + !< SHAPE = [2]) ) + !< + !< TEST_PASSED(3) = ALL( STRJOIN(ARRAY=CHARS_ARR, SEP='_') == & + !< RESHAPE([STRING('ONE_TWO_THREE'), STRING('ONE_TWO_THREE')], & + !< SHAPE = [2]) ) + !< + !< TEST_PASSED(4) = ALL( STRJOIN(ARRAY=CHARS_ARR, SEP='_', IS_TRIM=.FALSE.) == & + !< RESHAPE([STRING('ONE _TWO _THREE '), & + !< STRING('ONE _TWO _THREE ')], & + !< SHAPE = [2]) ) + !< + !< TEST_PASSED(5) = ALL( STRJOIN(ARRAY=CHARS_ARR, IS_COL=.FALSE.) == & + !< RESHAPE([STRING('ONEONE'), STRING('TWOTWO'), STRING('THREETHREE')], & + !< SHAPE = [3]) ) + !< + !< TEST_PASSED(6) = ALL( STRJOIN(ARRAY=CHARS_ARR, IS_TRIM=.FALSE., IS_COL=.FALSE.) == & + !< RESHAPE([STRING('ONE ONE '), & + !< STRING('TWO TWO '), & + !< STRING('THREE THREE ')], & + !< SHAPE = [3]) ) + !< + !< TEST_PASSED(7) = ALL( STRJOIN(ARRAY=CHARS_ARR, SEP='_', IS_COL=.FALSE.) == & + !< RESHAPE([STRING('ONE_ONE'), STRING('TWO_TWO'), STRING('THREE_THREE')], & + !< SHAPE = [3]) ) + !< + !< TEST_PASSED(8) = ALL( STRJOIN(ARRAY=CHARS_ARR, SEP='_', IS_TRIM=.FALSE., IS_COL=.FALSE.) == & + !< RESHAPE([STRING('ONE _ONE '), & + !< STRING('TWO _TWO '), & + !< STRING('THREE _THREE ')], & + !< SHAPE = [3]) ) + !< + !< CHARS_ARR(2,1) = '' + !< TEST_PASSED(9) = ALL( STRJOIN(ARRAY=CHARS_ARR, SEP='_', IS_COL=.FALSE.) == & + !< RESHAPE([STRING('ONE_ONE'), & + !< STRING('TWO'), & + !< STRING('THREE_THREE')], & + !< SHAPE = [3]) ) + !< + !< PRINT '(L1)', ALL(TEST_PASSED) + !<``` + !=> T <<< + CHARACTER(KIND=CK, LEN=*), INTENT(IN) :: ARRAY(1:, 1:) !< ARRAY TO BE JOINED. + CHARACTER(KIND=CK, LEN=*), INTENT(IN), OPTIONAL :: SEP !< SEPARATOR. + LOGICAL, INTENT(IN), OPTIONAL :: IS_TRIM !< FLAG TO SETUP TRIM CHARACTER OR NOT + LOGICAL, INTENT(IN), OPTIONAL :: IS_COL !< DIRECTION: 'COLUMNS' IF .TRUE. OR 'ROWS' IF .FALSE. + TYPE(STRING), ALLOCATABLE :: JOIN(:) !< THE JOIN OF ARRAY. + CHARACTER(KIND=CK, LEN=:), ALLOCATABLE :: SLICE(:) !< THE COLUMN OR ROW SLICE OF ARRAY + CHARACTER(KIND=CK, LEN=:), ALLOCATABLE :: SEP_ !< SEPARATOR, DEFAULT VALUE. + LOGICAL :: IS_TRIM_ !< FLAG TO SETUP TRIM CHARACTER OR NOT + LOGICAL :: IS_COL_ !< DIRECTION, DEFAULT VALUE. + INTEGER :: A, JOIN_SIZE, SLICE_SIZE !< COUNTER, SIZES OF JOIN VECTOR AND OF SLICE OF ARRAY + INTEGER :: ITEM_LEN !< LENGTH OF ARRAY ITEM (ALL ITEMS OF CHARACTER ARRAY HAVE EQUAL LENGTHS) + + ITEM_LEN = LEN(ARRAY(1,1)) !< ALL ITEMS OF CHARACTER ARRAY HAVE EQUAL LENGTHS + SEP_ = '' ; IF (PRESENT(SEP)) SEP_ = SEP + IS_TRIM_ = .TRUE. ; IF (PRESENT(IS_TRIM)) IS_TRIM_ = IS_TRIM + IS_COL_ = .TRUE. ; IF (PRESENT(IS_COL)) IS_COL_ = IS_COL + + IF (IS_COL_) THEN + JOIN_SIZE = SIZE(ARRAY, DIM=2) + SLICE_SIZE = SIZE(ARRAY, DIM=1) + + IF (.NOT.ALLOCATED(JOIN)) ALLOCATE(JOIN(JOIN_SIZE)) + IF (.NOT.ALLOCATED(SLICE)) ALLOCATE(CHARACTER(LEN=ITEM_LEN) :: SLICE(SLICE_SIZE)) + DO A = 1, JOIN_SIZE + SLICE(:) = ARRAY(:, A) + JOIN(A) = STRJOIN_CHARACTERS(SLICE, SEP_, IS_TRIM_) + END DO + ELSE + JOIN_SIZE = SIZE(ARRAY, DIM=1) + SLICE_SIZE = SIZE(ARRAY, DIM=2) + + IF (.NOT.ALLOCATED(JOIN)) ALLOCATE(JOIN(JOIN_SIZE)) + IF (.NOT.ALLOCATED(SLICE)) ALLOCATE(CHARACTER(LEN=ITEM_LEN) :: SLICE(SLICE_SIZE)) + DO A = 1, JOIN_SIZE + SLICE(:) = ARRAY(A, :) + JOIN(A) = STRJOIN_CHARACTERS(SLICE, SEP_, IS_TRIM_) + END DO + ENDIF + ENDFUNCTION STRJOIN_CHARACTERS_ARRAY + + ELEMENTAL FUNCTION LOWER(SELF) + !< RETURN A STRING WITH ALL LOWERCASE CHARACTERS. + !< + !<```FORTRAN + !< TYPE(STRING) :: ASTRING + !< LOGICAL :: TEST_PASSED(1) + !< ASTRING = 'HELLO WORLD!' + !< TEST_PASSED(1) = ASTRING%LOWER()//''=='HELLO WORLD!' + !< PRINT '(L1)', ALL(TEST_PASSED) + !<``` + !=> T <<< + CLASS(STRING), INTENT(IN) :: SELF !< THE STRING. + TYPE(STRING) :: LOWER !< UPPER CASE STRING. + INTEGER :: N1 !< CHARACTERS COUNTER. + INTEGER :: N2 !< CHARACTERS COUNTER. + + IF (ALLOCATED(SELF%RAW)) THEN + LOWER = SELF + DO N1=1, LEN(SELF%RAW) + N2 = INDEX(UPPER_ALPHABET, SELF%RAW(N1:N1)) + IF (N2>0) LOWER%RAW(N1:N1) = LOWER_ALPHABET(N2:N2) + ENDDO + ENDIF + ENDFUNCTION LOWER + + PURE FUNCTION PARTITION(SELF, SEP) RESULT(PARTITIONS) + !< SPLIT STRING AT SEPARATOR AND RETURN THE 3 PARTS (BEFORE, THE SEPARATOR AND AFTER). + !< + !<```FORTRAN + !< TYPE(STRING) :: ASTRING + !< TYPE(STRING) :: STRINGS(3) + !< LOGICAL :: TEST_PASSED(3) + !< ASTRING = 'HELLO WORLD!' + !< STRINGS = ASTRING%PARTITION(SEP='LO WO') + !< TEST_PASSED(1) = (STRINGS(1)//''=='HEL'.AND.STRINGS(2)//''=='LO WO'.AND.STRINGS(3)//''=='RLD!') + !< STRINGS = ASTRING%PARTITION(SEP='HELLO') + !< TEST_PASSED(2) = (STRINGS(1)//''==''.AND.STRINGS(2)//''=='HELLO'.AND.STRINGS(3)//''==' WORLD!') + !< ASTRING = 'HELLO WORLD!' + !< STRINGS = ASTRING%PARTITION() + !< TEST_PASSED(3) = (STRINGS(1)//''=='HELLO'.AND.STRINGS(2)//''==' '.AND.STRINGS(3)//''=='WORLD!') + !< PRINT '(L1)', ALL(TEST_PASSED) + !<``` + !=> T <<< + CLASS(STRING), INTENT(IN) :: SELF !< THE STRING. + CHARACTER(KIND=CK, LEN=*), INTENT(IN), OPTIONAL :: SEP !< SEPARATOR. + TYPE(STRING) :: PARTITIONS(1:3) !< PARTIONS: BEFORE THE SEPARATOR, THE SEPARATOR ITSELS AND + !< AFTER THE SEPARATOR. + CHARACTER(KIND=CK, LEN=:), ALLOCATABLE :: SEP_ !< SEPARATOR, DEFAULT VALUE. + INTEGER :: C !< CHARACTER COUNTER. + + IF (ALLOCATED(SELF%RAW)) THEN + SEP_ = SPACE ; IF (PRESENT(SEP)) SEP_ = SEP + + PARTITIONS(1) = SELF + PARTITIONS(2) = SEP_ + PARTITIONS(3) = '' + IF (LEN(SEP_)>=LEN(SELF%RAW)) RETURN + C = INDEX(SELF%RAW, SEP_) + IF (C>0) THEN + PARTITIONS(1)%RAW = SELF%RAW(1:C-1) + PARTITIONS(2)%RAW = SELF%RAW(C:C+LEN(SEP_)-1) + PARTITIONS(3)%RAW = SELF%RAW(C+LEN(SEP_):) + ENDIF + ENDIF + ENDFUNCTION PARTITION + + SUBROUTINE READ_FILE(SELF, FILE, IS_FAST, FORM, IOSTAT, IOMSG) + !< READ A FILE AS A SINGLE STRING STREAM. + !< + !< @NOTE ALL THE LINES ARE STORED INTO THE STRING SELF AS A SINGLE ASCII STREAM. EACH LINE (RECORD) IS SEPARATED BY A `NEW_LINE` + !< CHARACTER. + !< + !< @NOTE FOR UNFORMATTED READ ONLY `ACCESS='STREAM'` IS SUPPORTED WITH NEW_LINE AS LINE TERMINATOR. + !< + !< @NOTE *FAST* FILE READING ALLOWS A VERY EFFICIENT READING OF STREAMED FILE, BUT IT DUMPS FILE AS SINGLE STREAMED STRING. + !< + !<```FORTRAN + !< TYPE(STRING) :: ASTRING + !< TYPE(STRING), ALLOCATABLE :: STRINGS(:) + !< TYPE(STRING) :: LINE(3) + !< INTEGER :: IOSTAT + !< CHARACTER(LEN=99) :: IOMSG + !< INTEGER :: SCRATCH + !< INTEGER :: L + !< LOGICAL :: TEST_PASSED(9) + !< LINE(1) = ' HELLO WORLD! ' + !< LINE(2) = 'HOW ARE YOU? ' + !< LINE(3) = ' ALL SAY: "FINE THANKS"' + !< OPEN(NEWUNIT=SCRATCH, FILE='READ_FILE_TEST.TMP') + !< WRITE(SCRATCH, "(A)") LINE(1)%CHARS() + !< WRITE(SCRATCH, "(A)") LINE(2)%CHARS() + !< WRITE(SCRATCH, "(A)") LINE(3)%CHARS() + !< CLOSE(SCRATCH) + !< CALL ASTRING%READ_FILE(FILE='READ_FILE_TEST.TMP', IOSTAT=IOSTAT, IOMSG=IOMSG) + !< CALL ASTRING%SPLIT(TOKENS=STRINGS, SEP=NEW_LINE('A')) + !< TEST_PASSED(1) = (SIZE(STRINGS, DIM=1)==SIZE(LINE, DIM=1)) + !< DO L=1, SIZE(STRINGS, DIM=1) + !< TEST_PASSED(L+1) = (STRINGS(L)==LINE(L)) + !< ENDDO + !< OPEN(NEWUNIT=SCRATCH, FILE='READ_FILE_TEST.TMP', FORM='UNFORMATTED', ACCESS='STREAM') + !< WRITE(SCRATCH) LINE(1)%CHARS()//NEW_LINE('A') + !< WRITE(SCRATCH) LINE(2)%CHARS()//NEW_LINE('A') + !< WRITE(SCRATCH) LINE(3)%CHARS()//NEW_LINE('A') + !< CLOSE(SCRATCH) + !< CALL ASTRING%READ_FILE(FILE='READ_FILE_TEST.TMP', FORM='UNFORMATTED', IOSTAT=IOSTAT, IOMSG=IOMSG) + !< CALL ASTRING%SPLIT(TOKENS=STRINGS, SEP=NEW_LINE('A')) + !< TEST_PASSED(5) = (SIZE(STRINGS, DIM=1)==SIZE(LINE, DIM=1)) + !< DO L=1, SIZE(STRINGS, DIM=1) + !< TEST_PASSED(L+5) = (STRINGS(L)==LINE(L)) + !< ENDDO + !< OPEN(NEWUNIT=SCRATCH, FILE='READ_FILE_TEST.TMP', FORM='UNFORMATTED', ACCESS='STREAM') + !< CLOSE(SCRATCH, STATUS='DELETE') + !< CALL ASTRING%READ_FILE(FILE='READ_FILE_TEST.TMP', IOSTAT=IOSTAT) + !< TEST_PASSED(9) = (IOSTAT/=0) + !< PRINT '(L1)', ALL(TEST_PASSED) + !<``` + !=> T <<< + CLASS(STRING), INTENT(INOUT) :: SELF !< THE STRING. + CHARACTER(LEN=*), INTENT(IN) :: FILE !< FILE NAME. + LOGICAL, INTENT(IN), OPTIONAL :: IS_FAST !< FLAG TO ENABLE (SUPER) FAST FILE READING. + CHARACTER(LEN=*), INTENT(IN), OPTIONAL :: FORM !< FORMAT OF UNIT. + INTEGER, INTENT(OUT), OPTIONAL :: IOSTAT !< IO STATUS CODE. + CHARACTER(LEN=*), INTENT(INOUT), OPTIONAL :: IOMSG !< IO STATUS MESSAGE. + LOGICAL :: IS_FAST_ !< FLAG TO ENABLE (SUPER) FAST FILE READING, LOCAL VARIABLE. + TYPE(STRING) :: FORM_ !< FORMAT OF UNIT, LOCAL VARIABLE. + INTEGER :: IOSTAT_ !< IO STATUS CODE, LOCAL VARIABLE. + CHARACTER(LEN=:), ALLOCATABLE :: IOMSG_ !< IO STATUS MESSAGE, LOCAL VARIABLE. + INTEGER :: UNIT !< LOGICAL UNIT. + LOGICAL :: DOES_EXIST !< CHECK IF FILE EXIST. + INTEGER(I4P) :: FILESIZE !< SIZE OF THE FILE FOR FAST READING. + + IOMSG_ = REPEAT(' ', 99) ; IF (PRESENT(IOMSG)) IOMSG_ = IOMSG + INQUIRE(FILE=FILE, IOMSG=IOMSG_, IOSTAT=IOSTAT_, EXIST=DOES_EXIST) + IF (DOES_EXIST) THEN + IS_FAST_ = .FALSE. ; IF (PRESENT(IS_FAST)) IS_FAST_ = IS_FAST + IF (IS_FAST_) THEN + OPEN(NEWUNIT=UNIT, FILE=FILE, ACCESS='STREAM', FORM='UNFORMATTED', IOMSG=IOMSG_, IOSTAT=IOSTAT_) + INQUIRE(FILE=FILE, SIZE=FILESIZE) + IF (ALLOCATED(SELF%RAW)) DEALLOCATE(SELF%RAW) + ALLOCATE(CHARACTER(LEN=FILESIZE):: SELF%RAW) + READ(UNIT=UNIT, IOSTAT=IOSTAT_, IOMSG=IOMSG_) SELF%RAW + CLOSE(UNIT) + ELSE + FORM_ = 'FORMATTED' ; IF (PRESENT(FORM)) FORM_ = FORM ; FORM_ = FORM_%UPPER() + SELECT CASE(FORM_%CHARS()) + CASE('FORMATTED') + OPEN(NEWUNIT=UNIT, FILE=FILE, STATUS='OLD', ACTION='READ', IOMSG=IOMSG_, IOSTAT=IOSTAT_, ERR=10) + CASE('UNFORMATTED') + OPEN(NEWUNIT=UNIT, FILE=FILE, STATUS='OLD', ACTION='READ', FORM='UNFORMATTED', ACCESS='STREAM', & + IOMSG=IOMSG_, IOSTAT=IOSTAT_, ERR=10) + ENDSELECT + CALL SELF%READ_LINES(UNIT=UNIT, FORM=FORM, IOMSG=IOMSG_, IOSTAT=IOSTAT_) + 10 CLOSE(UNIT) + ENDIF + ELSE + IOSTAT_ = 1 + IOMSG_ = 'FILE NOT FOUND' + ENDIF + IF (PRESENT(IOSTAT)) IOSTAT = IOSTAT_ + IF (PRESENT(IOMSG)) IOMSG = IOMSG_ + ENDSUBROUTINE READ_FILE + + SUBROUTINE READ_LINE(SELF, UNIT, FORM, IOSTAT, IOMSG) + !< READ LINE (RECORD) FROM A CONNECTED UNIT. + !< + !< THE LINE IS READ AS AN ASCII STREAM READ UNTIL THE EOR IS REACHED. + !< + !< @NOTE FOR UNFORMATTED READ ONLY `ACCESS='STREAM'` IS SUPPORTED WITH NEW_LINE AS LINE TERMINATOR. + !< + !<```FORTRAN + !< TYPE(STRING) :: ASTRING + !< TYPE(STRING) :: LINE(3) + !< INTEGER :: IOSTAT + !< CHARACTER(LEN=99) :: IOMSG + !< INTEGER :: SCRATCH + !< INTEGER :: L + !< LOGICAL :: TEST_PASSED(6) + !< LINE(1) = ' HELLO WORLD! ' + !< LINE(2) = 'HOW ARE YOU? ' + !< LINE(3) = ' ALL SAY: "FINE THANKS"' + !< OPEN(NEWUNIT=SCRATCH, STATUS='SCRATCH') + !< WRITE(SCRATCH, "(A)") LINE(1)%CHARS() + !< WRITE(SCRATCH, "(A)") LINE(2)%CHARS() + !< WRITE(SCRATCH, "(A)") LINE(3)%CHARS() + !< REWIND(SCRATCH) + !< L = 0 + !< IOSTAT = 0 + !< DO + !< L = L + 1 + !< CALL ASTRING%READ_LINE(UNIT=SCRATCH, IOSTAT=IOSTAT, IOMSG=IOMSG) + !< IF (IOSTAT/=0.AND..NOT.IS_IOSTAT_EOR(IOSTAT)) THEN + !< EXIT + !< ELSE + !< TEST_PASSED(L) = (ASTRING==LINE(L)) + !< ENDIF + !< ENDDO + !< CLOSE(SCRATCH) + !< OPEN(NEWUNIT=SCRATCH, STATUS='SCRATCH', FORM='UNFORMATTED', ACCESS='STREAM') + !< WRITE(SCRATCH) LINE(1)%CHARS()//NEW_LINE('A') + !< WRITE(SCRATCH) LINE(2)%CHARS()//NEW_LINE('A') + !< WRITE(SCRATCH) LINE(3)%CHARS()//NEW_LINE('A') + !< REWIND(SCRATCH) + !< L = 0 + !< IOSTAT = 0 + !< DO + !< L = L + 1 + !< CALL ASTRING%READ_LINE(UNIT=SCRATCH, IOSTAT=IOSTAT, IOMSG=IOMSG, FORM='UNFORMATTED') + !< IF (IOSTAT/=0.AND..NOT.IS_IOSTAT_EOR(IOSTAT)) THEN + !< EXIT + !< ELSE + !< TEST_PASSED(L+3) = (ASTRING==LINE(L)) + !< ENDIF + !< ENDDO + !< CLOSE(SCRATCH) + !< PRINT '(L1)', ALL(TEST_PASSED) + !<``` + !=> T <<< + CLASS(STRING), INTENT(INOUT) :: SELF !< THE STRING. + INTEGER, INTENT(IN) :: UNIT !< LOGICAL UNIT. + CHARACTER(LEN=*), INTENT(IN), OPTIONAL :: FORM !< FORMAT OF UNIT. + INTEGER, INTENT(OUT), OPTIONAL :: IOSTAT !< IO STATUS CODE. + CHARACTER(LEN=*), INTENT(INOUT), OPTIONAL :: IOMSG !< IO STATUS MESSAGE. + TYPE(STRING) :: FORM_ !< FORMAT OF UNIT, LOCAL VARIABLE. + INTEGER :: IOSTAT_ !< IO STATUS CODE, LOCAL VARIABLE. + CHARACTER(LEN=:), ALLOCATABLE :: IOMSG_ !< IO STATUS MESSAGE, LOCAL VARIABLE. + CHARACTER(KIND=CK, LEN=:), ALLOCATABLE :: LINE !< LINE STORAGE. + CHARACTER(KIND=CK, LEN=1) :: CH !< CHARACTER STORAGE. + + FORM_ = 'FORMATTED' ; IF (PRESENT(FORM)) FORM_ = FORM ; FORM_ = FORM_%UPPER() + IOMSG_ = REPEAT(' ', 99) ; IF (PRESENT(IOMSG)) IOMSG_ = IOMSG + LINE = '' + SELECT CASE(FORM_%CHARS()) + CASE('FORMATTED') + DO + READ(UNIT, "(A)", ADVANCE='NO', IOSTAT=IOSTAT_, IOMSG=IOMSG_, ERR=10, END=10, EOR=10) CH + LINE = LINE//CH + ENDDO + CASE('UNFORMATTED') + DO + READ(UNIT, IOSTAT=IOSTAT_, IOMSG=IOMSG_, ERR=10, END=10) CH + IF (CH==NEW_LINE('A')) THEN + IOSTAT_ = IOSTAT_EOR + EXIT + ENDIF + LINE = LINE//CH + ENDDO + ENDSELECT + 10 IF (LINE/='') SELF%RAW = LINE + IF (PRESENT(IOSTAT)) IOSTAT = IOSTAT_ + IF (PRESENT(IOMSG)) IOMSG = IOMSG_ + ENDSUBROUTINE READ_LINE + + SUBROUTINE READ_LINES(SELF, UNIT, FORM, IOSTAT, IOMSG) + !< READ (ALL) LINES (RECORDS) FROM A CONNECTED UNIT AS A SINGLE ASCII STREAM. + !< + !< @NOTE ALL THE LINES ARE STORED INTO THE STRING SELF AS A SINGLE ASCII STREAM. EACH LINE (RECORD) IS SEPARATED BY A `NEW_LINE` + !< CHARACTER. THE LINE IS READ AS AN ASCII STREAM READ UNTIL THE EOR IS REACHED. + !< + !< @NOTE THE CONNECTED UNIT IS REWINDED. AT A SUCCESSFUL EXIT CURRENT RECORD IS AT EOF, AT THE BEGINNING OTHERWISE. + !< + !< @NOTE FOR UNFORMATTED READ ONLY `ACCESS='STREAM'` IS SUPPORTED WITH NEW_LINE AS LINE TERMINATOR. + !< + !<```FORTRAN + !< TYPE(STRING) :: ASTRING + !< TYPE(STRING), ALLOCATABLE :: STRINGS(:) + !< TYPE(STRING) :: LINE(3) + !< INTEGER :: IOSTAT + !< CHARACTER(LEN=99) :: IOMSG + !< INTEGER :: SCRATCH + !< INTEGER :: L + !< LOGICAL :: TEST_PASSED(8) + !< + !< LINE(1) = ' HELLO WORLD! ' + !< LINE(2) = 'HOW ARE YOU? ' + !< LINE(3) = ' ALL SAY: "FINE THANKS"' + !< OPEN(NEWUNIT=SCRATCH, STATUS='SCRATCH') + !< WRITE(SCRATCH, "(A)") LINE(1)%CHARS() + !< WRITE(SCRATCH, "(A)") LINE(2)%CHARS() + !< WRITE(SCRATCH, "(A)") LINE(3)%CHARS() + !< CALL ASTRING%READ_LINES(UNIT=SCRATCH, IOSTAT=IOSTAT, IOMSG=IOMSG) + !< CALL ASTRING%SPLIT(TOKENS=STRINGS, SEP=NEW_LINE('A')) + !< TEST_PASSED(1) = (SIZE(STRINGS, DIM=1)==SIZE(LINE, DIM=1)) + !< DO L=1, SIZE(STRINGS, DIM=1) + !< TEST_PASSED(L+1) = (STRINGS(L)==LINE(L)) + !< ENDDO + !< CLOSE(SCRATCH) + !< OPEN(NEWUNIT=SCRATCH, STATUS='SCRATCH', FORM='UNFORMATTED', ACCESS='STREAM') + !< WRITE(SCRATCH) LINE(1)%CHARS()//NEW_LINE('A') + !< WRITE(SCRATCH) LINE(2)%CHARS()//NEW_LINE('A') + !< WRITE(SCRATCH) LINE(3)%CHARS()//NEW_LINE('A') + !< CALL ASTRING%READ_LINES(UNIT=SCRATCH, FORM='UNFORMATTED', IOSTAT=IOSTAT, IOMSG=IOMSG) + !< CALL ASTRING%SPLIT(TOKENS=STRINGS, SEP=NEW_LINE('A')) + !< TEST_PASSED(5) = (SIZE(STRINGS, DIM=1)==SIZE(LINE, DIM=1)) + !< DO L=1, SIZE(STRINGS, DIM=1) + !< TEST_PASSED(L+5) = (STRINGS(L)==LINE(L)) + !< ENDDO + !< CLOSE(SCRATCH) + !< PRINT '(L1)', ALL(TEST_PASSED) + !<``` + !=> T <<< + CLASS(STRING), INTENT(INOUT) :: SELF !< THE STRING. + INTEGER, INTENT(IN) :: UNIT !< LOGICAL UNIT. + CHARACTER(LEN=*), INTENT(IN), OPTIONAL :: FORM !< FORMAT OF UNIT. + INTEGER, INTENT(OUT), OPTIONAL :: IOSTAT !< IO STATUS CODE. + CHARACTER(LEN=*), INTENT(INOUT), OPTIONAL :: IOMSG !< IO STATUS MESSAGE. + INTEGER :: IOSTAT_ !< IO STATUS CODE, LOCAL VARIABLE. + CHARACTER(LEN=:), ALLOCATABLE :: IOMSG_ !< IO STATUS MESSAGE, LOCAL VARIABLE. + TYPE(STRING) :: LINES !< LINES STORAGE. + TYPE(STRING) :: LINE !< LINE STORAGE. + + IOMSG_ = REPEAT(' ', 99) ; IF (PRESENT(IOMSG)) IOMSG_ = IOMSG + REWIND(UNIT) + IOSTAT_ = 0 + LINES%RAW = '' + DO + LINE%RAW = '' + CALL LINE%READ_LINE(UNIT=UNIT, FORM=FORM, IOSTAT=IOSTAT_, IOMSG=IOMSG_) + IF (IOSTAT_/=0.AND..NOT.IS_IOSTAT_EOR(IOSTAT_)) THEN + EXIT + ELSEIF (LINE/='') THEN + LINES%RAW = LINES%RAW//LINE%RAW//NEW_LINE('A') + ENDIF + ENDDO + IF (LINES%RAW/='') SELF%RAW = LINES%RAW + IF (PRESENT(IOSTAT)) IOSTAT = IOSTAT_ + IF (PRESENT(IOMSG)) IOMSG = IOMSG_ + ENDSUBROUTINE READ_LINES + + ELEMENTAL FUNCTION REPLACE(SELF, OLD, NEW, COUNT) RESULT(REPLACED) + !< RETURN A STRING WITH ALL OCCURRENCES OF SUBSTRING OLD REPLACED BY NEW. + !< + !<```FORTRAN + !< TYPE(STRING) :: ASTRING + !< LOGICAL :: TEST_PASSED(3) + !< ASTRING = 'WHEN YOU ARE SAD YOU SHOULD THINK TO ME :-)' + !< TEST_PASSED(1) = (ASTRING%REPLACE(OLD='YOU', NEW='THEY')//''=='WHEN THEY ARE SAD THEY SHOULD THINK TO ME :-)') + !< TEST_PASSED(2) = (ASTRING%REPLACE(OLD='YOU', NEW='THEY', COUNT=1)//''=='WHEN THEY ARE SAD YOU SHOULD THINK TO ME :-)') + !< ASTRING = REPEAT(NEW_LINE('A')//'ABCD', 20) + !< ASTRING = ASTRING%REPLACE(OLD=NEW_LINE('A'), NEW='|CR|') + !< ASTRING = ASTRING%REPLACE(OLD='|CR|', NEW=NEW_LINE('A')//' ') + !< TEST_PASSED(3) = (ASTRING//''==REPEAT(NEW_LINE('A')//' '//'ABCD', 20)) + !< PRINT '(L1)', ALL(TEST_PASSED) + !<``` + !=> T <<< + CLASS(STRING), INTENT(IN) :: SELF !< THE STRING. + CHARACTER(KIND=CK, LEN=*), INTENT(IN) :: OLD !< OLD SUBSTRING. + CHARACTER(KIND=CK, LEN=*), INTENT(IN) :: NEW !< NEW SUBSTRING. + INTEGER, INTENT(IN), OPTIONAL :: COUNT !< NUMBER OF OLD OCCURENCES TO BE REPLACED. + TYPE(STRING) :: REPLACED !< THE STRING WITH OLD REPLACED BY NEW. + INTEGER :: R !< COUNTER. + + IF (ALLOCATED(SELF%RAW)) THEN + REPLACED = SELF + R = 0 + DO + IF (INDEX(REPLACED%RAW, OLD)>0) THEN + REPLACED = REPLACED%REPLACE_ONE_OCCURRENCE(OLD=OLD, NEW=NEW) + R = R + 1 + IF (PRESENT(COUNT)) THEN + IF (R>=COUNT) EXIT + ENDIF + ELSE + EXIT + ENDIF + ENDDO + ENDIF + ENDFUNCTION REPLACE + + ELEMENTAL FUNCTION REVERSE(SELF) RESULT(REVERSED) + !< RETURN A REVERSED STRING. + !< + !<```FORTRAN + !< TYPE(STRING) :: ASTRING + !< LOGICAL :: TEST_PASSED(2) + !< ASTRING = 'ABCDEFGHILMNOPQRSTUVZ' + !< TEST_PASSED(1) = (ASTRING%REVERSE()//''=='ZVUTSRQPONMLIHGFEDCBA') + !< ASTRING = '0123456789' + !< TEST_PASSED(2) = (ASTRING%REVERSE()//''=='9876543210') + !< PRINT '(L1)', ALL(TEST_PASSED) + !<``` + !=> T <<< + CLASS(STRING), INTENT(IN) :: SELF !< THE STRING. + TYPE(STRING) :: REVERSED !< THE REVERSED STRING. + INTEGER :: LENGTH !< LENGTH OF THE STRING. + INTEGER :: C !< COUNTER. + + IF (ALLOCATED(SELF%RAW)) THEN + REVERSED = SELF + LENGTH = LEN(SELF%RAW) + DO C=1, LENGTH + REVERSED%RAW(C:C) = SELF%RAW(LENGTH-C+1:LENGTH-C+1) + ENDDO + ENDIF + ENDFUNCTION REVERSE + + FUNCTION SEARCH(SELF, TAG_START, TAG_END, IN_STRING, IN_CHARACTER, ISTART, IEND) RESULT(TAG) + !< SEARCH FOR *TAGGED* RECORD INTO STRING, RETURN THE FIRST RECORD FOUND (IF ANY) MATCHING THE TAGS. + !< + !< OPTIONALLY, RETURNS THE INDEXES OF TAG START/END, THUS THIS IS NOT AN `ELEMENTAL` FUNCTION. + !< + !< @NOTE THE TAGGED RECORD IS SEARCHED INTO SELF IF ALLOCATED OTHERWISE INTO `IN_STRING` IF PASSED OR, EVENTUALLY, INTO + !< `IN_CHARACTER` IS PASSED. IF TAG IS NOT FOUND THE RETURN STRING IS NOT ALLOCATED AND THE START/END INDEXES (IF REQUESTED) ARE + !< ZERO. + !< + !<```FORTRAN + !< TYPE(STRING) :: ASTRING + !< TYPE(STRING) :: ANOTHERSTRING + !< CHARACTER(LEN=:), ALLOCATABLE :: ACHARACTER + !< INTEGER :: ISTART + !< INTEGER :: IEND + !< LOGICAL :: TEST_PASSED(5) + !< ASTRING = '<TEST> <FIRST> HELLO </FIRST> <FIRST> NOT THE FIRST </FIRST> </TEST>' + !< ANOTHERSTRING = ASTRING%SEARCH(TAG_START='<FIRST>', TAG_END='</FIRST>') + !< TEST_PASSED(1) = ANOTHERSTRING//''=='<FIRST> HELLO </FIRST>' + !< ASTRING = '<TEST> <A> <A> <A> THE NESTED A </A> </A> </A> </TEST>' + !< ANOTHERSTRING = ASTRING%SEARCH(TAG_START='<A>', TAG_END='</A>') + !< TEST_PASSED(2) = ANOTHERSTRING//''=='<A> <A> <A> THE NESTED A </A> </A> </A>' + !< CALL ASTRING%FREE + !< ANOTHERSTRING = '<TEST> <A> <A> <A> THE NESTED A </A> </A> </A> </TEST>' + !< ASTRING = ASTRING%SEARCH(IN_STRING=ANOTHERSTRING, TAG_START='<A>', TAG_END='</A>') + !< TEST_PASSED(3) = ASTRING//''=='<A> <A> <A> THE NESTED A </A> </A> </A>' + !< CALL ASTRING%FREE + !< ACHARACTER = '<TEST> <A> <A> <A> THE NESTED A </A> </A> </A> </TEST>' + !< ASTRING = ASTRING%SEARCH(IN_CHARACTER=ACHARACTER, TAG_START='<A>', TAG_END='</A>') + !< TEST_PASSED(4) = ASTRING//''=='<A> <A> <A> THE NESTED A </A> </A> </A>' + !< ACHARACTER = '<TEST> <FIRST> HELLO </FIRST> <SEC> <SEC>NOT THE FIRST</SEC> </SEC> </TEST>' + !< ASTRING = ASTRING%SEARCH(IN_CHARACTER=ACHARACTER, TAG_START='<SEC>', TAG_END='</SEC>', ISTART=ISTART, IEND=IEND) + !< TEST_PASSED(5) = ASTRING//''==ACHARACTER(31:67) + !< PRINT '(L1)', ALL(TEST_PASSED) + !<``` + !=> T <<< + CLASS(STRING), INTENT(IN) :: SELF !< THE STRING. + CHARACTER(KIND=CK, LEN=*), INTENT(IN) :: TAG_START !< START TAG. + CHARACTER(KIND=CK, LEN=*), INTENT(IN) :: TAG_END !< END TAG. + TYPE(STRING), INTENT(IN), OPTIONAL :: IN_STRING !< SEARCH INTO THIS STRING. + CHARACTER(KIND=CK, LEN=*), INTENT(IN), OPTIONAL :: IN_CHARACTER !< SEARCH INTO THIS CHARACTER STRING. + INTEGER, INTENT(OUT), OPTIONAL :: ISTART !< STARTING INDEX OF TAG INSIDE THE STRING. + INTEGER, INTENT(OUT), OPTIONAL :: IEND !< ENDING INDEX OF TAG INSIDE THE STRING. + TYPE(STRING) :: TAG !< FIRST TAG FOUND. + CHARACTER(KIND=CK, LEN=:), ALLOCATABLE :: RAW !< RAW STRING INTO WHICH SEARCH THE TAG. + INTEGER :: ISTART_ !< STARTING INDEX OF TAG INSIDE THE STRING, LOCAL VARIABLE. + INTEGER :: IEND_ !< ENDING INDEX OF TAG INSIDE THE STRING, LOCAL VARIABLE. + INTEGER :: NESTED_TAGS !< NUMBER OF NESTED TAGS INSIDE TAG. + INTEGER :: T !< COUNTER. + + RAW = '' + IF (PRESENT(IN_STRING)) THEN + RAW = IN_STRING%RAW + ELSEIF (PRESENT(IN_CHARACTER)) THEN + RAW = IN_CHARACTER + ELSE + IF (ALLOCATED(SELF%RAW)) RAW = SELF%RAW + ENDIF + ISTART_ = 0 + IEND_ = 0 + IF (RAW/='') THEN + ISTART_ = INDEX(RAW, TAG_START) + IEND_ = INDEX(RAW, TAG_END) + IF (ISTART_>0.AND.IEND_>0) THEN + IEND_ = IEND_ + LEN(TAG_END) - 1 + TAG%RAW = RAW(ISTART_:IEND_) + NESTED_TAGS = TAG%COUNT(TAG_START) + IF (NESTED_TAGS>1) THEN + DO T=2, NESTED_TAGS + IEND_ = IEND_ + LEN(TAG_END) - 1 + INDEX(RAW(IEND_+1:), TAG_END) + ENDDO + TAG%RAW = RAW(ISTART_:IEND_) + ENDIF + ENDIF + ENDIF + IF (PRESENT(ISTART)) ISTART = ISTART_ + IF (PRESENT(IEND)) IEND = IEND_ + ENDFUNCTION SEARCH + + PURE FUNCTION SLICE(SELF, ISTART, IEND) RESULT(RAW) + !< RETURN THE RAW CHARACTERS DATA SLICED. + !< + !<```FORTRAN + !< TYPE(STRING) :: ASTRING + !< ASTRING = 'THE QUICK BROWN FOX JUMPS OVER THE LAZY DOG.' + !< PRINT "(A)", ASTRING%SLICE(11,25) + !<``` + !=> BROWN FOX JUMPS <<< + CLASS(STRING), INTENT(IN) :: SELF !< THE STRING. + INTEGER, INTENT(IN) :: ISTART !< SLICE START INDEX. + INTEGER, INTENT(IN) :: IEND !< SLICE END INDEX. + CHARACTER(KIND=CK, LEN=:), ALLOCATABLE :: RAW !< RAW CHARACTERS DATA. + + IF (ALLOCATED(SELF%RAW)) THEN + RAW = SELF%RAW(ISTART:IEND) + ELSE + RAW = '' + ENDIF + ENDFUNCTION SLICE + + ELEMENTAL FUNCTION SNAKECASE(SELF, SEP) + !< RETURN A STRING WITH ALL WORDS LOWERCASE SEPARATED BY "_". + !< + !< @NOTE MULTIPLE SUBSEQUENT SEPARATORS ARE COLLAPSED TO ONE OCCURENCE. + !< + !<```FORTRAN + !< TYPE(STRING) :: ASTRING + !< LOGICAL :: TEST_PASSED(1) + !< ASTRING = 'THE QUICK BROWN FOX JUMPS OVER THE LAZY DOG.' + !< TEST_PASSED(1) = ASTRING%SNAKECASE()//''=='THE_QUICK_BROWN_FOX_JUMPS_OVER_THE_LAZY_DOG.' + !< PRINT '(L1)', ALL(TEST_PASSED) + !<``` + !=> T <<< + CLASS(STRING), INTENT(IN) :: SELF !< THE STRING. + CHARACTER(KIND=CK, LEN=*), INTENT(IN), OPTIONAL :: SEP !< SEPARATOR. + TYPE(STRING) :: SNAKECASE !< SNAKE CASE STRING. + TYPE(STRING), ALLOCATABLE :: TOKENS(:) !< STRING TOKENS. + + IF (ALLOCATED(SELF%RAW)) THEN + CALL SELF%SPLIT(TOKENS=TOKENS, SEP=SEP) + TOKENS = TOKENS%LOWER() + SNAKECASE = SNAKECASE%JOIN(ARRAY=TOKENS, SEP='_') + ENDIF + ENDFUNCTION SNAKECASE + + PURE SUBROUTINE SPLIT(SELF, TOKENS, SEP, MAX_TOKENS) + !< RETURN A LIST OF SUBSTRING IN THE STRING, USING SEP AS THE DELIMITER STRING. + !< + !< @NOTE MULTIPLE SUBSEQUENT SEPARATORS ARE COLLAPSED TO ONE OCCURRENCE. + !< + !< @NOTE IF `MAX_TOKENS` IS PASSED THE RETURNED NUMBER OF TOKENS IS EITHER `MAX_TOKENS` OR `MAX_TOKENS + 1`. + !< + !<```FORTRAN + !< TYPE(STRING) :: ASTRING + !< TYPE(STRING), ALLOCATABLE :: STRINGS(:) + !< LOGICAL :: TEST_PASSED(11) + !< ASTRING = '+AB-++CRE-++CRE-AB+' + !< CALL ASTRING%SPLIT(TOKENS=STRINGS, SEP='+') + !< TEST_PASSED(1) = (STRINGS(1)//''=='AB-'.AND.STRINGS(2)//''=='CRE-'.AND.STRINGS(3)//''=='CRE-AB') + !< ASTRING = 'AB-++CRE-++CRE-AB+' + !< CALL ASTRING%SPLIT(TOKENS=STRINGS, SEP='+') + !< TEST_PASSED(2) = (STRINGS(1)//''=='AB-'.AND.STRINGS(2)//''=='CRE-'.AND.STRINGS(3)//''=='CRE-AB') + !< ASTRING = 'AB-++CRE-++CRE-AB' + !< CALL ASTRING%SPLIT(TOKENS=STRINGS, SEP='+') + !< TEST_PASSED(3) = (STRINGS(1)//''=='AB-'.AND.STRINGS(2)//''=='CRE-'.AND.STRINGS(3)//''=='CRE-AB') + !< ASTRING = 'HELLO '//NEW_LINE('A')//'WORLD!' + !< CALL ASTRING%SPLIT(TOKENS=STRINGS, SEP=NEW_LINE('A')) + !< TEST_PASSED(4) = (STRINGS(1)//''=='HELLO '.AND.STRINGS(2)//''=='WORLD!') + !< ASTRING = 'HELLO WORLD!' + !< CALL ASTRING%SPLIT(TOKENS=STRINGS) + !< TEST_PASSED(5) = (STRINGS(1)//''=='HELLO'.AND.STRINGS(2)//''=='WORLD!') + !< ASTRING = '+AB-' + !< CALL ASTRING%SPLIT(TOKENS=STRINGS, SEP='+') + !< TEST_PASSED(6) = (STRINGS(1)//''=='AB-') + !< ASTRING = '+AB-' + !< CALL ASTRING%SPLIT(TOKENS=STRINGS, SEP='-') + !< TEST_PASSED(7) = (STRINGS(1)//''=='+AB') + !< ASTRING = '+AB-+CD-' + !< CALL ASTRING%SPLIT(TOKENS=STRINGS, SEP='+') + !< TEST_PASSED(8) = (STRINGS(1)//''=='AB-'.AND.STRINGS(2)//''=='CD-') + !< ASTRING = 'AB-+CD-+' + !< CALL ASTRING%SPLIT(TOKENS=STRINGS, SEP='+') + !< TEST_PASSED(9) = (STRINGS(1)//''=='AB-'.AND.STRINGS(2)//''=='CD-') + !< ASTRING = '+AB-+CD-+' + !< CALL ASTRING%SPLIT(TOKENS=STRINGS, SEP='+') + !< TEST_PASSED(10) = (STRINGS(1)//''=='AB-'.AND.STRINGS(2)//''=='CD-') + !< ASTRING = '1-2-3-4-5-6-7-8' + !< CALL ASTRING%SPLIT(TOKENS=STRINGS, SEP='-', MAX_TOKENS=3) + !< TEST_PASSED(11) = (STRINGS(1)//''=='1'.AND.STRINGS(2)//''=='2'.AND.STRINGS(3)//''=='3'.AND.STRINGS(4)//''=='4-5-6-7-8') + !< PRINT '(L1)', ALL(TEST_PASSED) + !<``` + !=> T <<< + CLASS(STRING), INTENT(IN) :: SELF !< THE STRING. + TYPE(STRING), ALLOCATABLE, INTENT(OUT) :: TOKENS(:) !< TOKENS SUBSTRING. + CHARACTER(KIND=CK, LEN=*), INTENT(IN), OPTIONAL :: SEP !< SEPARATOR. + INTEGER, INTENT(IN), OPTIONAL :: MAX_TOKENS !< FIX THE MAXIMUM NUMBER OF RETURNED TOKENS. + CHARACTER(KIND=CK, LEN=:), ALLOCATABLE :: SEP_ !< SEPARATOR, DEFAULT VALUE. + INTEGER :: NO !< NUMBER OF OCCURRENCES OF SEP. + INTEGER :: T !< CHARACTER COUNTER. + TYPE(STRING) :: TEMPORARY !< TEMPORARY STORAGE. + TYPE(STRING), ALLOCATABLE :: TEMP_TOKS(:,:) !< TEMPORARY TOKENS SUBSTRING. + + IF (ALLOCATED(SELF%RAW)) THEN + SEP_ = SPACE ; IF (PRESENT(SEP)) SEP_ = SEP + + TEMPORARY = SELF%UNIQUE(SEP_) + NO = TEMPORARY%COUNT(SEP_) + + IF (NO>0) THEN + IF (PRESENT(MAX_TOKENS)) THEN + IF (MAX_TOKENS < NO.AND.MAX_TOKENS > 0) NO = MAX_TOKENS + ENDIF + ALLOCATE(TEMP_TOKS(3, NO)) + TEMP_TOKS(:, 1) = TEMPORARY%PARTITION(SEP_) + IF (NO>1) THEN + DO T=2, NO + TEMP_TOKS(:, T) = TEMP_TOKS(3, T-1)%PARTITION(SEP_) + ENDDO + ENDIF + + IF (TEMP_TOKS(1, 1)%RAW/=''.AND.TEMP_TOKS(3, NO)%RAW/='') THEN + ALLOCATE(TOKENS(NO+1)) + DO T=1, NO + IF (T==NO) THEN + TOKENS(T ) = TEMP_TOKS(1, T) + TOKENS(T+1) = TEMP_TOKS(3, T) + ELSE + TOKENS(T) = TEMP_TOKS(1, T) + ENDIF + ENDDO + ELSEIF (TEMP_TOKS(1, 1)%RAW/='') THEN + ALLOCATE(TOKENS(NO)) + DO T=1, NO + TOKENS(T) = TEMP_TOKS(1, T) + ENDDO + ELSEIF (TEMP_TOKS(3, NO)%RAW/='') THEN + ALLOCATE(TOKENS(NO)) + DO T=1, NO-1 + TOKENS(T) = TEMP_TOKS(1, T+1) + ENDDO + TOKENS(NO) = TEMP_TOKS(3, NO) + ELSE + ALLOCATE(TOKENS(NO-1)) + DO T=2, NO + TOKENS(T-1) = TEMP_TOKS(1, T) + ENDDO + ENDIF + + ELSE + ALLOCATE(TOKENS(1)) + TOKENS(1) = SELF + ENDIF + ENDIF + ENDSUBROUTINE SPLIT + + PURE SUBROUTINE SPLIT_CHUNKED(SELF, TOKENS, CHUNKS, SEP) + !< RETURN A LIST OF SUBSTRING IN THE STRING, USING SEP AS THE DELIMITER STRING, CHUNKED (MEMORY-EFFICIENT) ALGORITHM. + !< + !< @NOTE MULTIPLE SUBSEQUENT SEPARATORS ARE COLLAPSED TO ONE OCCURRENCE. + !< + !< @NOTE THE SPLIT IS PERFORMED IN CHUNKS OF `#CHUNKS` TO AVOID EXCESSIVE MEMORY CONSUMPTION. + !< + !<```FORTRAN + !< TYPE(STRING) :: ASTRING + !< TYPE(STRING), ALLOCATABLE :: STRINGS(:) + !< LOGICAL :: TEST_PASSED(1) + !< ASTRING = '-1-2-3-4-5-6-7-8-' + !< CALL ASTRING%SPLIT_CHUNKED(TOKENS=STRINGS, SEP='-', CHUNKS=3) + !< TEST_PASSED(1) = (STRINGS(1)//''=='1'.AND.STRINGS(2)//''=='2'.AND.STRINGS(3)//''=='3'.AND.STRINGS(4)//''=='4'.AND. & + !< STRINGS(5)//''=='5'.AND.STRINGS(6)//''=='6'.AND.STRINGS(7)//''=='7'.AND.STRINGS(8)//''=='8') + !< PRINT '(L1)', ALL(TEST_PASSED) + !<``` + !=> T <<< + CLASS(STRING), INTENT(IN) :: SELF !< THE STRING. + TYPE(STRING), ALLOCATABLE, INTENT(OUT) :: TOKENS(:) !< TOKENS SUBSTRING. + INTEGER, INTENT(IN) :: CHUNKS !< NUMBER OF CHUNKS. + CHARACTER(KIND=CK, LEN=*), INTENT(IN), OPTIONAL :: SEP !< SEPARATOR. + CHARACTER(KIND=CK, LEN=:), ALLOCATABLE :: SEP_ !< SEPARATOR, DEFAULT VALUE. + INTEGER :: NT !< NUMBER OF ACTUAL TOKENS. + INTEGER :: T !< COUNTER. + LOGICAL :: ISOK + + IF (ALLOCATED(SELF%RAW)) THEN + SEP_ = SPACE ; IF (PRESENT(SEP)) SEP_ = SEP + + NT = SELF%COUNT(SEP_) + IF (SELF%START_WITH(PREFIX=SEP_)) NT = NT - 1 + IF (SELF%END_WITH(SUFFIX=SEP_)) NT = NT - 1 + T = 0 + CALL SELF%SPLIT(TOKENS=TOKENS, SEP=SEP_, MAX_TOKENS=CHUNKS) + DO + T = SIZE(TOKENS, DIM=1) + IF (T > NT) EXIT + CALL SPLIT_LAST_TOKEN(TOKENS=TOKENS, MAX_TOKENS=CHUNKS,ISOK=ISOK) + IF(ISOK)THEN + ELSE + EXIT + ENDIF + ENDDO + + T = SIZE(TOKENS, DIM=1) + IF (TOKENS(T)%COUNT(SEP_) > 0) THEN + CALL SPLIT_LAST_TOKEN(TOKENS=TOKENS,ISOK=ISOK) + ENDIF + ENDIF + + CONTAINS + PURE SUBROUTINE SPLIT_LAST_TOKEN(TOKENS, MAX_TOKENS,ISOK) + !< SPLIT LAST TOKEN. + TYPE(STRING), ALLOCATABLE, INTENT(INOUT) :: TOKENS(:) !< TOKENS SUBSTRING. + INTEGER, INTENT(IN), OPTIONAL :: MAX_TOKENS !< MAX TOKENS RETURNED. + TYPE(STRING), ALLOCATABLE :: TOKENS_(:) !< TEMPORARY TOKENS. + TYPE(STRING), ALLOCATABLE :: TOKENS_SWAP(:) !< SWAP TOKENS. + INTEGER :: NT_ !< NUMBER OF LAST CREATED TOKENS. + LOGICAL,INTENT(OUT) :: ISOK + + ISOK=.TRUE. + CALL TOKENS(T)%SPLIT(TOKENS=TOKENS_, SEP=SEP_, MAX_TOKENS=MAX_TOKENS) + IF (ALLOCATED(TOKENS_)) THEN + NT_ = SIZE(TOKENS_, DIM=1) + IF (NT_ >= 1) THEN + ALLOCATE(TOKENS_SWAP(1:T-1+NT_)) + TOKENS_SWAP(1:T-1) = TOKENS(1:T-1) + TOKENS_SWAP(T:) = TOKENS_(:) + CALL MOVE_ALLOC(FROM=TOKENS_SWAP, TO=TOKENS) + ENDIF + IF (NT_ == 1) THEN + ISOK=.FALSE. + END IF + DEALLOCATE(TOKENS_) + ENDIF + ENDSUBROUTINE SPLIT_LAST_TOKEN + ENDSUBROUTINE SPLIT_CHUNKED + + ELEMENTAL FUNCTION STARTCASE(SELF, SEP) + !< RETURN A STRING WITH ALL WORDS CAPITALIZED, E.G. TITLE CASE. + !< + !< @NOTE MULTIPLE SUBSEQUENT SEPARATORS ARE COLLAPSED TO ONE OCCURENCE. + !< + !<```FORTRAN + !< TYPE(STRING) :: ASTRING + !< LOGICAL :: TEST_PASSED(1) + !< ASTRING = 'THE QUICK BROWN FOX JUMPS OVER THE LAZY DOG.' + !< TEST_PASSED(1) = ASTRING%STARTCASE()//''=='THE QUICK BROWN FOX JUMPS OVER THE LAZY DOG.' + !< PRINT '(L1)', ALL(TEST_PASSED) + !<``` + !=> T <<< + CLASS(STRING), INTENT(IN) :: SELF !< THE STRING. + CHARACTER(KIND=CK, LEN=*), INTENT(IN), OPTIONAL :: SEP !< SEPARATOR. + TYPE(STRING) :: STARTCASE !< START CASE STRING. + CHARACTER(KIND=CK, LEN=:), ALLOCATABLE :: SEP_ !< SEPARATOR, DEFAULT VALUE. + TYPE(STRING), ALLOCATABLE :: TOKENS(:) !< STRING TOKENS. + + IF (ALLOCATED(SELF%RAW)) THEN + SEP_ = SPACE ; IF (PRESENT(SEP)) SEP_ = SEP + CALL SELF%SPLIT(TOKENS=TOKENS, SEP=SEP_) + TOKENS = TOKENS%CAPITALIZE() + STARTCASE = STARTCASE%JOIN(ARRAY=TOKENS, SEP=SEP_) + ENDIF + ENDFUNCTION STARTCASE + + ELEMENTAL FUNCTION STRIP(SELF, REMOVE_NULLS) + !< RETURN A COPY OF THE STRING WITH THE LEADING AND TRAILING CHARACTERS REMOVED. + !< + !< @NOTE MULTIPLE SUBSEQUENT SEPARATORS ARE COLLAPSED TO ONE OCCURENCE. + !< + !<```FORTRAN + !< TYPE(STRING) :: ASTRING + !< LOGICAL :: TEST_PASSED(1) + !< ASTRING = ' HELLO WORLD! ' + !< TEST_PASSED(1) = ASTRING%STRIP()//''=='HELLO WORLD!' + !< PRINT '(L1)', ALL(TEST_PASSED) + !<``` + !=> T <<< + CLASS(STRING), INTENT(IN) :: SELF !< THE STRING. + LOGICAL, INTENT(IN), OPTIONAL :: REMOVE_NULLS !< REMOVE NULL CHARACTERS AT THE END. + TYPE(STRING) :: STRIP !< THE STRIPPED STRING. + INTEGER :: C !< COUNTER. + + IF (ALLOCATED(SELF%RAW)) THEN + STRIP = SELF%ADJUSTL() + STRIP = STRIP%TRIM() + IF (PRESENT(REMOVE_NULLS)) THEN + IF (REMOVE_NULLS) THEN + C = INDEX(SELF%RAW, CHAR(0)) + IF (C>0) STRIP%RAW = STRIP%RAW(1:C-1) + ENDIF + ENDIF + ENDIF + ENDFUNCTION STRIP + + ELEMENTAL FUNCTION SWAPCASE(SELF) + !< RETURN A COPY OF THE STRING WITH UPPERCASE CHARACTERS CONVERTED TO LOWERCASE AND VICE VERSA. + !< + !<```FORTRAN + !< TYPE(STRING) :: ASTRING + !< LOGICAL :: TEST_PASSED(1) + !< ASTRING = ' HELLO WORLD! ' + !< TEST_PASSED(1) = ASTRING%SWAPCASE()//''==' HELLO WORLD! ' + !< PRINT '(L1)', ALL(TEST_PASSED) + !<``` + !=> T <<< + CLASS(STRING), INTENT(IN) :: SELF !< THE STRING. + TYPE(STRING) :: SWAPCASE !< UPPER CASE STRING. + INTEGER :: N1 !< CHARACTERS COUNTER. + INTEGER :: N2 !< CHARACTERS COUNTER. + + IF (ALLOCATED(SELF%RAW)) THEN + SWAPCASE = SELF + DO N1=1, LEN(SELF%RAW) + N2 = INDEX(UPPER_ALPHABET, SELF%RAW(N1:N1)) + IF (N2>0) THEN + SWAPCASE%RAW(N1:N1) = LOWER_ALPHABET(N2:N2) + ELSE + N2 = INDEX(LOWER_ALPHABET, SELF%RAW(N1:N1)) + IF (N2>0) SWAPCASE%RAW(N1:N1) = UPPER_ALPHABET(N2:N2) + ENDIF + ENDDO + ENDIF + ENDFUNCTION SWAPCASE + + FUNCTION TEMPNAME(SELF, IS_FILE, PREFIX, PATH) + !< RETURN A SAFE TEMPORARY NAME SUITABLE FOR TEMPORARY FILE OR DIRECTORIES. + !< + !<```FORTRAN + !< TYPE(STRING) :: ASTRING + !< CHARACTER(LEN=:), ALLOCATABLE :: TMPNAME + !< LOGICAL :: TEST_PASSED(5) + !< TMPNAME = ASTRING%TEMPNAME() + !< INQUIRE(FILE=TMPNAME, EXIST=TEST_PASSED(1)) + !< TEST_PASSED(1) = .NOT.TEST_PASSED(1) + !< TMPNAME = ASTRING%TEMPNAME(IS_FILE=.FALSE.) + !< INQUIRE(FILE=TMPNAME, EXIST=TEST_PASSED(2)) + !< TEST_PASSED(2) = .NOT.TEST_PASSED(2) + !< TMPNAME = ASTRING%TEMPNAME(PATH='./') + !< INQUIRE(FILE=TMPNAME, EXIST=TEST_PASSED(3)) + !< TEST_PASSED(3) = .NOT.TEST_PASSED(3) + !< ASTRING = 'ME-' + !< TMPNAME = ASTRING%TEMPNAME() + !< INQUIRE(FILE=TMPNAME, EXIST=TEST_PASSED(4)) + !< TEST_PASSED(4) = .NOT.TEST_PASSED(4) + !< TMPNAME = ASTRING%TEMPNAME(PREFIX='YOU-') + !< INQUIRE(FILE=TMPNAME, EXIST=TEST_PASSED(5)) + !< TEST_PASSED(5) = .NOT.TEST_PASSED(5) + !< PRINT '(L1)', ALL(TEST_PASSED) + !<``` + !=> T <<< + CLASS(STRING), INTENT(IN) :: SELF !< THE STRING. + LOGICAL, INTENT(IN), OPTIONAL :: IS_FILE !< TRUE IF TEMPNAME SHOULD BE USED FOR FILE (THE DEFAULT). + CHARACTER(*), INTENT(IN), OPTIONAL :: PREFIX !< NAME PREFIX, OTHERWISE SELF IS USED (IF ALLOCATED). + CHARACTER(*), INTENT(IN), OPTIONAL :: PATH !< PATH WHERE FILE/DIRECTORY SHOULD BE USED, DEFAULT `./`. + CHARACTER(LEN=:), ALLOCATABLE :: TEMPNAME !< SAFE (UNIQUE) TEMPORARY NAME. + LOGICAL :: IS_FILE_ !< TRUE IF TEMPNAME SHOULD BE USED FOR FILE (THE DEFAULT). + CHARACTER(LEN=:), ALLOCATABLE :: PREFIX_ !< NAME PREFIX, OTHERWISE SELF IS USED (IF ALLOCATED). + CHARACTER(LEN=:), ALLOCATABLE :: PATH_ !< PATH WHERE FILE/DIRECTORY SHOULD BE USED, DEFAULT `./`. + LOGICAL, SAVE :: IS_INITIALIZED=.FALSE. !< STATUS OF RANDOM SEED INITIALIZATION. + REAL(R4P) :: RANDOM_REAL !< RANDOM NUMBER (REAL). + INTEGER(I4P) :: RANDOM_INTEGER !< RANDOM NUMBER (INTEGER). + LOGICAL :: IS_HOLD !< FLAG TO CHECK IF A SAFE TEMPNAME HAS BEEN FOUND. + + IS_FILE_ = .TRUE. ; IF (PRESENT(IS_FILE)) IS_FILE_ = IS_FILE + PATH_ = '' ; IF (PRESENT(PATH)) PATH_ = PATH + PREFIX_ = '' + IF (PRESENT(PREFIX)) THEN + PREFIX_ = PREFIX + ELSEIF (ALLOCATED(SELF%RAW)) THEN + PREFIX_ = SELF%RAW + ENDIF + IF (.NOT.IS_INITIALIZED) THEN + CALL RANDOM_SEED + IS_INITIALIZED = .TRUE. + ENDIF + TEMPNAME = REPEAT(' ', LEN(PATH_) + LEN(PREFIX_) + 10) ! [PATH_] + [PREFIX_] + 6 RANDOM CHARS + [.TMP] + DO + CALL RANDOM_NUMBER(RANDOM_REAL) + RANDOM_INTEGER = TRANSFER(RANDOM_REAL, RANDOM_INTEGER) + RANDOM_INTEGER = IAND(RANDOM_INTEGER, 16777215_I4P) + IF (IS_FILE_) THEN + WRITE(TEMPNAME, '(A,Z6.6,A)') PATH_//PREFIX_, RANDOM_INTEGER, '.TMP' + ELSE + WRITE(TEMPNAME, '(A,Z6.6)') PATH_//PREFIX_, RANDOM_INTEGER + TEMPNAME = TRIM(TEMPNAME) + ENDIF + INQUIRE(FILE=TEMPNAME, EXIST=IS_HOLD) + IF (.NOT.IS_HOLD) EXIT + ENDDO + ENDFUNCTION TEMPNAME + + ELEMENTAL FUNCTION TO_INTEGER_I1P(SELF, KIND) RESULT(TO_NUMBER) + !< CAST STRING TO INTEGER (I1P). + !< + !<```FORTRAN + !< USE PENF + !< TYPE(STRING) :: ASTRING + !< INTEGER(I1P) :: INTEGER_ + !< LOGICAL :: TEST_PASSED(1) + !< ASTRING = '127' + !< INTEGER_ = ASTRING%TO_NUMBER(KIND=1_I1P) + !< TEST_PASSED(1) = INTEGER_==127_I1P + !< PRINT '(L1)', ALL(TEST_PASSED) + !<``` + !=> T <<< + CLASS(STRING), INTENT(IN) :: SELF !< THE STRING. + INTEGER(I1P), INTENT(IN) :: KIND !< MOLD PARAMETER FOR KIND DETECTION. + INTEGER(I1P) :: TO_NUMBER !< THE NUMBER INTO THE STRING. + + IF (ALLOCATED(SELF%RAW)) THEN + IF (SELF%IS_INTEGER()) READ(SELF%RAW, *) TO_NUMBER + ENDIF + ENDFUNCTION TO_INTEGER_I1P + +#ifndef _NVF + ELEMENTAL FUNCTION TO_INTEGER_I2P(SELF, KIND) RESULT(TO_NUMBER) + !< CAST STRING TO INTEGER (I2P). + !< + !<```FORTRAN + !< USE PENF + !< TYPE(STRING) :: ASTRING + !< INTEGER(I2P) :: INTEGER_ + !< LOGICAL :: TEST_PASSED(1) + !< ASTRING = '127' + !< INTEGER_ = ASTRING%TO_NUMBER(KIND=1_I2P) + !< TEST_PASSED(1) = INTEGER_==127_I2P + !< PRINT '(L1)', ALL(TEST_PASSED) + !<``` + !=> T <<< + CLASS(STRING), INTENT(IN) :: SELF !< THE STRING. + INTEGER(I2P), INTENT(IN) :: KIND !< MOLD PARAMETER FOR KIND DETECTION. + INTEGER(I2P) :: TO_NUMBER !< THE NUMBER INTO THE STRING. + + IF (ALLOCATED(SELF%RAW)) THEN + IF (SELF%IS_INTEGER()) READ(SELF%RAW, *) TO_NUMBER + ENDIF + ENDFUNCTION TO_INTEGER_I2P +#endif + + ELEMENTAL FUNCTION TO_INTEGER_I4P(SELF, KIND) RESULT(TO_NUMBER) + !< CAST STRING TO INTEGER (I4P). + !< + !<```FORTRAN + !< USE PENF + !< TYPE(STRING) :: ASTRING + !< INTEGER(I4P) :: INTEGER_ + !< LOGICAL :: TEST_PASSED(1) + !< ASTRING = '127' + !< INTEGER_ = ASTRING%TO_NUMBER(KIND=1_I4P) + !< TEST_PASSED(1) = INTEGER_==127_I4P + !< PRINT '(L1)', ALL(TEST_PASSED) + !<``` + !=> T <<< + CLASS(STRING), INTENT(IN) :: SELF !< THE STRING. + INTEGER(I4P), INTENT(IN) :: KIND !< MOLD PARAMETER FOR KIND DETECTION. + INTEGER(I4P) :: TO_NUMBER !< THE NUMBER INTO THE STRING. + + IF (ALLOCATED(SELF%RAW)) THEN + IF (SELF%IS_INTEGER()) READ(SELF%RAW, *) TO_NUMBER + ENDIF + ENDFUNCTION TO_INTEGER_I4P + + ELEMENTAL FUNCTION TO_INTEGER_I8P(SELF, KIND) RESULT(TO_NUMBER) + !< CAST STRING TO INTEGER (I8P). + !< + !<```FORTRAN + !< USE PENF + !< TYPE(STRING) :: ASTRING + !< INTEGER(I8P) :: INTEGER_ + !< LOGICAL :: TEST_PASSED(1) + !< ASTRING = '127' + !< INTEGER_ = ASTRING%TO_NUMBER(KIND=1_I8P) + !< TEST_PASSED(1) = INTEGER_==127_I8P + !< PRINT '(L1)', ALL(TEST_PASSED) + !<``` + !=> T <<< + CLASS(STRING), INTENT(IN) :: SELF !< THE STRING. + INTEGER(I8P), INTENT(IN) :: KIND !< MOLD PARAMETER FOR KIND DETECTION. + INTEGER(I8P) :: TO_NUMBER !< THE NUMBER INTO THE STRING. + + IF (ALLOCATED(SELF%RAW)) THEN + IF (SELF%IS_INTEGER()) READ(SELF%RAW, *) TO_NUMBER + ENDIF + ENDFUNCTION TO_INTEGER_I8P + + ELEMENTAL FUNCTION TO_REAL_R4P(SELF, KIND) RESULT(TO_NUMBER) + !< CAST STRING TO REAL (R4P). + !< + !<```FORTRAN + !< USE PENF + !< TYPE(STRING) :: ASTRING + !< REAL(R4P) :: REAL_ + !< LOGICAL :: TEST_PASSED(1) + !< ASTRING = '3.4E9' + !< REAL_ = ASTRING%TO_NUMBER(KIND=1._R4P) + !< TEST_PASSED(1) = REAL_==3.4E9_R4P + !< PRINT '(L1)', ALL(TEST_PASSED) + !<``` + !=> T <<< + CLASS(STRING), INTENT(IN) :: SELF !< THE STRING. + REAL(R4P), INTENT(IN) :: KIND !< MOLD PARAMETER FOR KIND DETECTION. + REAL(R4P) :: TO_NUMBER !< THE NUMBER INTO THE STRING. + + IF (ALLOCATED(SELF%RAW)) THEN + IF (SELF%IS_REAL()) READ(SELF%RAW, *) TO_NUMBER + ENDIF + ENDFUNCTION TO_REAL_R4P + + ELEMENTAL FUNCTION TO_REAL_R8P(SELF, KIND) RESULT(TO_NUMBER) + !< CAST STRING TO REAL (R8P). + !< + !<```FORTRAN + !< USE PENF + !< TYPE(STRING) :: ASTRING + !< REAL(R8P) :: REAL_ + !< LOGICAL :: TEST_PASSED(1) + !< ASTRING = '3.4E9' + !< REAL_ = ASTRING%TO_NUMBER(KIND=1._R8P) + !< TEST_PASSED(1) = REAL_==3.4E9_R8P + !< PRINT '(L1)', ALL(TEST_PASSED) + !<``` + !=> T <<< + CLASS(STRING), INTENT(IN) :: SELF !< THE STRING. + REAL(R8P), INTENT(IN) :: KIND !< MOLD PARAMETER FOR KIND DETECTION. + REAL(R8P) :: TO_NUMBER !< THE NUMBER INTO THE STRING. + + IF (ALLOCATED(SELF%RAW)) THEN + IF (SELF%IS_REAL()) READ(SELF%RAW, *) TO_NUMBER + ENDIF + ENDFUNCTION TO_REAL_R8P + + ELEMENTAL FUNCTION TO_REAL_R16P(SELF, KIND) RESULT(TO_NUMBER) + !< CAST STRING TO REAL (R16P). + !< + !<```FORTRAN + !< USE PENF + !< TYPE(STRING) :: ASTRING + !< REAL(R16P) :: REAL_ + !< LOGICAL :: TEST_PASSED(1) + !< ASTRING = '3.4E9' + !< REAL_ = ASTRING%TO_NUMBER(KIND=1._R16P) + !< TEST_PASSED(1) = REAL_==3.4E9_R16P + !< PRINT '(L1)', ALL(TEST_PASSED) + !<``` + !=> T <<< + CLASS(STRING), INTENT(IN) :: SELF !< THE STRING. + REAL(R16P), INTENT(IN) :: KIND !< MOLD PARAMETER FOR KIND DETECTION. + REAL(R16P) :: TO_NUMBER !< THE NUMBER INTO THE STRING. + + IF (ALLOCATED(SELF%RAW)) THEN + IF (SELF%IS_REAL()) READ(SELF%RAW, *) TO_NUMBER + ENDIF + ENDFUNCTION TO_REAL_R16P + + ELEMENTAL FUNCTION UNESCAPE(SELF, TO_UNESCAPE, UNESC) RESULT(UNESCAPED) + !< UNESCAPE DOUBLE BACKSLASHES (OR CUSTOM ESCAPED CHARACTER). + !< + !<```FORTRAN + !< TYPE(STRING) :: ASTRING + !< LOGICAL :: TEST_PASSED(2) + !< ASTRING = '^\\S \\D+\\S*' + !< TEST_PASSED(1) = (ASTRING%UNESCAPE(TO_UNESCAPE='\')//''=='^\S \D+\S*') + !< TEST_PASSED(2) = (ASTRING%UNESCAPE(TO_UNESCAPE='S')//''=='^\S \\D+\S*') + !< PRINT '(L1)', ALL(TEST_PASSED) + !<``` + !=> T <<< + CLASS(STRING), INTENT(IN) :: SELF !< THE STRING. + CHARACTER(KIND=CK, LEN=1), INTENT(IN) :: TO_UNESCAPE !< CHARACTER TO BE UNESCAPED. + CHARACTER(KIND=CK, LEN=*), INTENT(IN), OPTIONAL :: UNESC !< CHARACTER USED TO UNESCAPE. + TYPE(STRING) :: UNESCAPED !< ESCAPED STRING. + CHARACTER(KIND=CK, LEN=:), ALLOCATABLE :: UNESC_ !< CHARACTER TO UNESCAPE, LOCAL VARIABLE. + INTEGER :: C !< CHARACTER COUNTER. + + IF (ALLOCATED(SELF%RAW)) THEN + UNESC_ = '' ; IF (PRESENT(UNESC)) UNESC_ = UNESC + UNESCAPED%RAW = '' + C = 1 + DO + IF (C>LEN(SELF%RAW)) EXIT + IF (C==LEN(SELF%RAW)) THEN + UNESCAPED%RAW = UNESCAPED%RAW//SELF%RAW(C:C) + EXIT + ELSE + IF (SELF%RAW(C:C+1)==BACKSLASH//TO_UNESCAPE) THEN + UNESCAPED%RAW = UNESCAPED%RAW//TO_UNESCAPE + C = C + 2 + ELSE + UNESCAPED%RAW = UNESCAPED%RAW//SELF%RAW(C:C) + C = C + 1 + ENDIF + ENDIF + ENDDO + ENDIF + ENDFUNCTION UNESCAPE + + ELEMENTAL FUNCTION UNIQUE(SELF, SUBSTRING) RESULT(UNIQ) + !< REDUCE TO ONE (UNIQUE) MULTIPLE (SEQUENTIAL) OCCURRENCES OF A SUBSTRING INTO A STRING. + !< + !< FOR EXAMPLE THE STRING ' AB-CRE-CRE-AB' IS REDUCE TO 'AB-CRE-AB' IF THE SUBSTRING IS '-CRE'. + !< @NOTE EVENTUAL MULTIPLE TRAILING WHITE SPACE ARE NOT REDUCED TO ONE OCCURRENCE. + !< + !<```FORTRAN + !< TYPE(STRING) :: ASTRING + !< LOGICAL :: TEST_PASSED(1) + !< ASTRING = '+++AB-++CRE-++CRE-AB+++++' + !< TEST_PASSED(1) = ASTRING%UNIQUE(SUBSTRING='+')//''=='+AB-+CRE-+CRE-AB+' + !< PRINT '(L1)', ALL(TEST_PASSED) + !<``` + !=> T <<< + CLASS(STRING), INTENT(IN) :: SELF !< THE STRING. + CHARACTER(KIND=CK, LEN=*), INTENT(IN), OPTIONAL :: SUBSTRING !< SUBSTRING WHICH MULTIPLE OCCURENCES MUST BE REDUCED TO ONE. + CHARACTER(KIND=CK, LEN=:), ALLOCATABLE :: SUBSTRING_ !< SUBSTRING, DEFAULT VALUE. + TYPE(STRING) :: UNIQ !< STRING PARSED. +#ifdef _NVF + CHARACTER(9999) :: NVF_BUG !< WORK AROUND FOR NVFORTRAN BUG. +#endif + + IF (ALLOCATED(SELF%RAW)) THEN + SUBSTRING_ = SPACE ; IF (PRESENT(SUBSTRING)) SUBSTRING_ = SUBSTRING + + UNIQ = SELF + DO +#ifdef _NVF + NVF_BUG = SUBSTRING_ + IF (.NOT.UNIQ%INDEX(REPEAT(TRIM(NVF_BUG), 2))>0) EXIT + UNIQ = UNIQ%REPLACE(OLD=REPEAT(TRIM(NVF_BUG), 2), NEW=SUBSTRING_) +#else + IF (.NOT.UNIQ%INDEX(REPEAT(SUBSTRING_, 2))>0) EXIT + UNIQ = UNIQ%REPLACE(OLD=REPEAT(SUBSTRING_, 2), NEW=SUBSTRING_) +#endif + ENDDO + ENDIF + ENDFUNCTION UNIQUE + + ELEMENTAL FUNCTION UPPER(SELF) + !< RETURN A STRING WITH ALL UPPERCASE CHARACTERS. + !< + !<```FORTRAN + !< TYPE(STRING) :: ASTRING + !< LOGICAL :: TEST_PASSED(1) + !< ASTRING = 'HELLO WORLD!' + !< TEST_PASSED(1) = ASTRING%UPPER()//''=='HELLO WORLD!' + !< PRINT '(L1)', ALL(TEST_PASSED) + !<``` + !=> T <<< + CLASS(STRING), INTENT(IN) :: SELF !< THE STRING. + TYPE(STRING) :: UPPER !< UPPER CASE STRING. + INTEGER :: N1 !< CHARACTERS COUNTER. + INTEGER :: N2 !< CHARACTERS COUNTER. + + IF (ALLOCATED(SELF%RAW)) THEN + UPPER = SELF + DO N1=1, LEN(SELF%RAW) + N2 = INDEX(LOWER_ALPHABET, SELF%RAW(N1:N1)) + IF (N2>0) UPPER%RAW(N1:N1) = UPPER_ALPHABET(N2:N2) + ENDDO + ENDIF + ENDFUNCTION UPPER + + SUBROUTINE WRITE_FILE(SELF, FILE, FORM, IOSTAT, IOMSG) + !< WRITE A SINGLE STRING STREAM INTO FILE. + !< + !< @NOTE FOR UNFORMATTED READ ONLY `ACCESS='STREAM'` IS SUPPORTED WITH NEW_LINE AS LINE TERMINATOR. + !< + !<```FORTRAN + !< TYPE(STRING) :: ASTRING + !< TYPE(STRING) :: ANOTHERSTRING + !< TYPE(STRING), ALLOCATABLE :: STRINGS(:) + !< TYPE(STRING) :: LINE(3) + !< INTEGER :: IOSTAT + !< CHARACTER(LEN=99) :: IOMSG + !< INTEGER :: SCRATCH + !< INTEGER :: L + !< LOGICAL :: TEST_PASSED(8) + !< LINE(1) = ' HELLO WORLD! ' + !< LINE(2) = 'HOW ARE YOU? ' + !< LINE(3) = ' ALL SAY: "FINE THANKS"' + !< ANOTHERSTRING = ANOTHERSTRING%JOIN(ARRAY=LINE, SEP=NEW_LINE('A')) + !< CALL ANOTHERSTRING%WRITE_FILE(FILE='WRITE_FILE_TEST.TMP', IOSTAT=IOSTAT, IOMSG=IOMSG) + !< CALL ASTRING%READ_FILE(FILE='WRITE_FILE_TEST.TMP', IOSTAT=IOSTAT, IOMSG=IOMSG) + !< CALL ASTRING%SPLIT(TOKENS=STRINGS, SEP=NEW_LINE('A')) + !< TEST_PASSED(1) = (SIZE(STRINGS, DIM=1)==SIZE(LINE, DIM=1)) + !< DO L=1, SIZE(STRINGS, DIM=1) + !< TEST_PASSED(L+1) = (STRINGS(L)==LINE(L)) + !< ENDDO + !< CALL ANOTHERSTRING%WRITE_FILE(FILE='WRITE_FILE_TEST.TMP', FORM='UNFORMATTED', IOSTAT=IOSTAT, IOMSG=IOMSG) + !< CALL ASTRING%READ_FILE(FILE='WRITE_FILE_TEST.TMP', FORM='UNFORMATTED', IOSTAT=IOSTAT, IOMSG=IOMSG) + !< CALL ASTRING%SPLIT(TOKENS=STRINGS, SEP=NEW_LINE('A')) + !< TEST_PASSED(5) = (SIZE(STRINGS, DIM=1)==SIZE(LINE, DIM=1)) + !< DO L=1, SIZE(STRINGS, DIM=1) + !< TEST_PASSED(L+5) = (STRINGS(L)==LINE(L)) + !< ENDDO + !< OPEN(NEWUNIT=SCRATCH, FILE='WRITE_FILE_TEST.TMP') + !< CLOSE(UNIT=SCRATCH, STATUS='DELETE') + !< PRINT '(L1)', ALL(TEST_PASSED) + !<``` + !=> T <<< + CLASS(STRING), INTENT(IN) :: SELF !< THE STRING. + CHARACTER(LEN=*), INTENT(IN) :: FILE !< FILE NAME. + CHARACTER(LEN=*), INTENT(IN), OPTIONAL :: FORM !< FORMAT OF UNIT. + INTEGER, INTENT(OUT), OPTIONAL :: IOSTAT !< IO STATUS CODE. + CHARACTER(LEN=*), INTENT(INOUT), OPTIONAL :: IOMSG !< IO STATUS MESSAGE. + TYPE(STRING) :: FORM_ !< FORMAT OF UNIT, LOCAL VARIABLE. + INTEGER :: IOSTAT_ !< IO STATUS CODE, LOCAL VARIABLE. + CHARACTER(LEN=:), ALLOCATABLE :: IOMSG_ !< IO STATUS MESSAGE, LOCAL VARIABLE. + INTEGER :: UNIT !< LOGICAL UNIT. + + IOMSG_ = REPEAT(' ', 99) ; IF (PRESENT(IOMSG)) IOMSG_ = IOMSG + FORM_ = 'FORMATTED' ; IF (PRESENT(FORM)) FORM_ = FORM ; FORM_ = FORM_%UPPER() + SELECT CASE(FORM_%CHARS()) + CASE('FORMATTED') + OPEN(NEWUNIT=UNIT, FILE=FILE, ACTION='WRITE', IOMSG=IOMSG_, IOSTAT=IOSTAT_, ERR=10) + CASE('UNFORMATTED') + OPEN(NEWUNIT=UNIT, FILE=FILE, ACTION='WRITE', FORM='UNFORMATTED', ACCESS='STREAM', IOMSG=IOMSG_, IOSTAT=IOSTAT_, ERR=10) + ENDSELECT + CALL SELF%WRITE_LINES(UNIT=UNIT, FORM=FORM, IOMSG=IOMSG_, IOSTAT=IOSTAT_) + 10 CLOSE(UNIT) + IF (PRESENT(IOSTAT)) IOSTAT = IOSTAT_ + IF (PRESENT(IOMSG)) IOMSG = IOMSG_ + ENDSUBROUTINE WRITE_FILE + + SUBROUTINE WRITE_LINE(SELF, UNIT, FORM, IOSTAT, IOMSG) + !< WRITE LINE (RECORD) TO A CONNECTED UNIT. + !< + !< @NOTE IF THE CONNECTED UNIT IS UNFORMATTED A `NEW_LINE()` CHARACTER IS ADDED AT THE END (IF NECESSARY) TO MARK THE END OF LINE. + !< + !< @NOTE THERE IS NO DOCTESTS, THIS BEING TESTED BY MEANS OF [[STRING:WRITE_FILE]] DOCTESTS. + CLASS(STRING), INTENT(IN) :: SELF !< THE STRING. + INTEGER, INTENT(IN) :: UNIT !< LOGICAL UNIT. + CHARACTER(LEN=*), INTENT(IN), OPTIONAL :: FORM !< FORMAT OF UNIT. + INTEGER, INTENT(OUT), OPTIONAL :: IOSTAT !< IO STATUS CODE. + CHARACTER(LEN=*), INTENT(INOUT), OPTIONAL :: IOMSG !< IO STATUS MESSAGE. + TYPE(STRING) :: FORM_ !< FORMAT OF UNIT, LOCAL VARIABLE. + INTEGER :: IOSTAT_ !< IO STATUS CODE, LOCAL VARIABLE. + CHARACTER(LEN=:), ALLOCATABLE :: IOMSG_ !< IO STATUS MESSAGE, LOCAL VARIABLE. + + IOSTAT_ = 0 + IOMSG_ = REPEAT(' ', 99) ; IF (PRESENT(IOMSG)) IOMSG_ = IOMSG + IF (ALLOCATED(SELF%RAW)) THEN + FORM_ = 'FORMATTED' ; IF (PRESENT(FORM)) FORM_ = FORM ; FORM_ = FORM_%UPPER() + SELECT CASE(FORM_%CHARS()) + CASE('FORMATTED') + WRITE(UNIT, "(A)", IOSTAT=IOSTAT_, IOMSG=IOMSG_) SELF%RAW + CASE('UNFORMATTED') + IF (SELF%END_WITH(NEW_LINE('A'))) THEN + WRITE(UNIT, IOSTAT=IOSTAT_, IOMSG=IOMSG_) SELF%RAW + ELSE + WRITE(UNIT, IOSTAT=IOSTAT_, IOMSG=IOMSG_) SELF%RAW//NEW_LINE('A') + ENDIF + ENDSELECT + ENDIF + IF (PRESENT(IOSTAT)) IOSTAT = IOSTAT_ + IF (PRESENT(IOMSG)) IOMSG = IOMSG_ + ENDSUBROUTINE WRITE_LINE + + SUBROUTINE WRITE_LINES(SELF, UNIT, FORM, IOSTAT, IOMSG) + !< WRITE LINES (RECORDS) TO A CONNECTED UNIT. + !< + !< THIS METHOD CHECKS IF SELF CONTAINS MORE THAN ONE LINE (RECORDS) AND WRITES THEM AS LINES (RECORDS). + !< + !< @NOTE IF THE CONNECTED UNIT IS UNFORMATTED A `NEW_LINE()` CHARACTER IS ADDED AT THE END (IF NECESSARY) TO MARK THE END OF LINE. + !< + !< @NOTE THERE IS NO DOCTESTS, THIS BEING TESTED BY MEANS OF [[STRING:WRITE_FILE]] DOCTESTS. + CLASS(STRING), INTENT(IN) :: SELF !< THE STRING. + INTEGER, INTENT(IN) :: UNIT !< LOGICAL UNIT. + CHARACTER(LEN=*), INTENT(IN), OPTIONAL :: FORM !< FORMAT OF UNIT. + INTEGER, INTENT(OUT), OPTIONAL :: IOSTAT !< IO STATUS CODE. + CHARACTER(LEN=*), INTENT(INOUT), OPTIONAL :: IOMSG !< IO STATUS MESSAGE. + TYPE(STRING), ALLOCATABLE :: LINES(:) !< LINES. + INTEGER :: L !< COUNTER. + + IF (ALLOCATED(SELF%RAW)) THEN + CALL SELF%SPLIT(TOKENS=LINES, SEP=NEW_LINE('A')) + DO L=1, SIZE(LINES, DIM=1) + CALL LINES(L)%WRITE_LINE(UNIT=UNIT, FORM=FORM, IOSTAT=IOSTAT, IOMSG=IOMSG) + ENDDO + ENDIF + ENDSUBROUTINE WRITE_LINES + + ! INQUIRE + ELEMENTAL FUNCTION END_WITH(SELF, SUFFIX, START, END, IGNORE_NULL_EOF) + !< RETURN TRUE IF A STRING ENDS WITH A SPECIFIED SUFFIX. + !< + !<```FORTRAN + !< TYPE(STRING) :: ASTRING + !< LOGICAL :: TEST_PASSED(5) + !< ASTRING = 'HELLO WORLD!' + !< TEST_PASSED(1) = ASTRING%END_WITH(SUFFIX='LD!').EQV..TRUE. + !< TEST_PASSED(2) = ASTRING%END_WITH(SUFFIX='LD!').EQV..FALSE. + !< TEST_PASSED(3) = ASTRING%END_WITH(SUFFIX='ORLD!', START=5).EQV..TRUE. + !< TEST_PASSED(4) = ASTRING%END_WITH(SUFFIX='ORLD!', START=8, END=12).EQV..TRUE. + !< TEST_PASSED(5) = ASTRING%END_WITH(SUFFIX='!').EQV..TRUE. + !< PRINT '(L1)', ALL(TEST_PASSED) + !<``` + !=> T <<< + CLASS(STRING), INTENT(IN) :: SELF !< THE STRING. + CHARACTER(KIND=CK, LEN=*), INTENT(IN) :: SUFFIX !< SEARCHED SUFFIX. + INTEGER, INTENT(IN), OPTIONAL :: START !< START POSITION INTO THE STRING. + INTEGER, INTENT(IN), OPTIONAL :: END !< END POSITION INTO THE STRING. + LOGICAL, INTENT(IN), OPTIONAL :: IGNORE_NULL_EOF !< IGNORE NULL CHARACTER AT THE END OF FILE. + LOGICAL :: END_WITH !< RESULT OF THE TEST. + INTEGER :: START_ !< START POSITION INTO THE STRING, LOCAL VARIABLE. + INTEGER :: END_ !< END POSITION INTO THE STRING, LOCAL VARIABLE. + LOGICAL :: IGNORE_NULL_EOF_ !< IGNORE NULL CHARACTER AT THE END OF FILE, LOCAL VARIABLE. + + END_WITH = .FALSE. + IF (ALLOCATED(SELF%RAW)) THEN + START_ = 1 ; IF (PRESENT(START)) START_ = START + END_ = LEN(SELF%RAW) ; IF (PRESENT(END)) END_ = END + IGNORE_NULL_EOF_ = .FALSE. ; IF (PRESENT(IGNORE_NULL_EOF)) IGNORE_NULL_EOF_ = IGNORE_NULL_EOF + IF (IGNORE_NULL_EOF_.AND.(SELF%RAW(END_:END_) == CHAR(0))) END_ = END_ - 1 + IF (LEN(SUFFIX) <= LEN(SELF%RAW(START_:END_))) THEN + END_WITH = SELF%RAW(END_-LEN(SUFFIX)+1:END_) == SUFFIX + ENDIF + ENDIF + ENDFUNCTION END_WITH + + ELEMENTAL FUNCTION IS_ALLOCATED(SELF) + !< RETURN TRUE IF THE STRING IS ALLOCATED. + !< + !<```FORTRAN + !< TYPE(STRING) :: ASTRING + !< LOGICAL :: TEST_PASSED(2) + !< TEST_PASSED(1) = ASTRING%IS_ALLOCATED().EQV..FALSE. + !< ASTRING = 'HELLO' + !< TEST_PASSED(2) = ASTRING%IS_ALLOCATED().EQV..TRUE. + !< PRINT '(L1)', ALL(TEST_PASSED) + !<``` + !=> T <<< + CLASS(STRING), INTENT(IN) :: SELF !< THE STRING. + LOGICAL :: IS_ALLOCATED !< RESULT OF THE TEST. + + IS_ALLOCATED = ALLOCATED(SELF%RAW) + ENDFUNCTION IS_ALLOCATED + + ELEMENTAL FUNCTION IS_DIGIT(SELF) + !< RETURN TRUE IF ALL CHARACTERS IN THE STRING ARE DIGITS. + !< + !<```FORTRAN + !< TYPE(STRING) :: ASTRING + !< LOGICAL :: TEST_PASSED(2) + !< ASTRING = ' -1212112.3 ' + !< TEST_PASSED(1) = ASTRING%IS_DIGIT().EQV..FALSE. + !< ASTRING = '12121123' + !< TEST_PASSED(2) = ASTRING%IS_DIGIT().EQV..TRUE. + !< PRINT '(L1)', ALL(TEST_PASSED) + !<``` + !=> T <<< + CLASS(STRING), INTENT(IN) :: SELF !< THE STRING. + LOGICAL :: IS_DIGIT !< RESULT OF THE TEST. + INTEGER :: C !< CHARACTER COUNTER. + + IS_DIGIT = .FALSE. + IF (ALLOCATED(SELF%RAW)) THEN + DO C=1, LEN(SELF%RAW) + SELECT CASE (SELF%RAW(C:C)) + CASE ('0':'9') + IS_DIGIT = .TRUE. + CASE DEFAULT + IS_DIGIT = .FALSE. + EXIT + END SELECT + ENDDO + ENDIF + ENDFUNCTION IS_DIGIT + + ELEMENTAL FUNCTION IS_INTEGER(SELF, ALLOW_SPACES) + !< RETURN TRUE IF THE STRING CONTAINS AN INTEGER. + !< + !< THE REGULAR EXPRESSION IS `\S*[\+\-]?\D+([EE]\+?\D+)?\S*`. THE PARSE ALGORITHM IS DONE IN STAGES: + !< + !< | S0 | S1 | S2 | S3 | S4 | S5 | S6 | + !< |-----|---------|-----|------|-----|-----|-----| + !< |`\S*`|`[\+\-]?`|`\D+`|`[EE]`|`\+?`|`\D+`|`\S*`| + !< + !< EXIT ON STAGES-PARSING RESULTS IN: + !< + !< | S0 | S1 | S2 | S3 | S4 | S5 | S6 | + !< |----|----|----|----|----|----|----| + !< | F | F | T | F | F | T | T | + !< + !< @NOTE THIS IMPLEMENTATION IS COURTESY OF + !< [TOMEDUNN](HTTPS://GITHUB.COM/TOMEDUNN/FORTRAN-STRING-UTILITY-MODULE/BLOB/MASTER/SRC/STRING_UTILITY_MODULE.F90#L294) + !< + !<```FORTRAN + !< TYPE(STRING) :: ASTRING + !< LOGICAL :: TEST_PASSED(6) + !< ASTRING = ' -1212112 ' + !< TEST_PASSED(1) = ASTRING%IS_INTEGER().EQV..TRUE. + !< ASTRING = ' -1212112' + !< TEST_PASSED(2) = ASTRING%IS_INTEGER(ALLOW_SPACES=.FALSE.).EQV..FALSE. + !< ASTRING = '-1212112 ' + !< TEST_PASSED(3) = ASTRING%IS_INTEGER(ALLOW_SPACES=.FALSE.).EQV..FALSE. + !< ASTRING = '+2E20' + !< TEST_PASSED(4) = ASTRING%IS_INTEGER().EQV..TRUE. + !< ASTRING = ' -2E13 ' + !< TEST_PASSED(5) = ASTRING%IS_INTEGER().EQV..TRUE. + !< ASTRING = ' -2 E13 ' + !< TEST_PASSED(6) = ASTRING%IS_INTEGER().EQV..FALSE. + !< PRINT '(L1)', ALL(TEST_PASSED) + !<``` + !=> T <<< + CLASS(STRING), INTENT(IN) :: SELF !< THE STRING. + LOGICAL, INTENT(IN), OPTIONAL :: ALLOW_SPACES !< ALLOW LEADING-TRAILING SPACES. + LOGICAL :: IS_INTEGER !< RESULT OF THE TEST. + LOGICAL :: ALLOW_SPACES_ !< ALLOW LEADING-TRAILING SPACES, LOCAL VARIABLE. + INTEGER :: STAGE !< STAGES COUNTER. + INTEGER :: C !< CHARACTER COUNTER. + + IF (ALLOCATED(SELF%RAW)) THEN + ALLOW_SPACES_ = .TRUE. ; IF (PRESENT(ALLOW_SPACES)) ALLOW_SPACES_ = ALLOW_SPACES + STAGE = 0 + IS_INTEGER = .TRUE. + DO C=1, LEN(SELF%RAW) + SELECT CASE(SELF%RAW(C:C)) + CASE(SPACE, TAB) + SELECT CASE(STAGE) + CASE(0, 6) + IS_INTEGER = ALLOW_SPACES_ + CASE(2, 5) + IS_INTEGER = ALLOW_SPACES_ + STAGE = 6 + CASE DEFAULT + IS_INTEGER = .FALSE. + ENDSELECT + CASE('-') + SELECT CASE(STAGE) + CASE(0) + STAGE = 1 + CASE DEFAULT + IS_INTEGER = .FALSE. + END SELECT + CASE('+') + SELECT CASE(STAGE) + CASE(0) + STAGE = 1 + CASE(3) + STAGE = 4 + CASE DEFAULT + IS_INTEGER = .FALSE. + ENDSELECT + CASE('0':'9') + SELECT CASE(STAGE) + CASE(0:1) + STAGE = 2 + CASE(3:4) + STAGE = 5 + CASE DEFAULT + CONTINUE + ENDSELECT + CASE ('e','E') + SELECT CASE(STAGE) + CASE(2) + STAGE = 3 + CASE DEFAULT + IS_INTEGER = .FALSE. + ENDSELECT + CASE DEFAULT + IS_INTEGER = .FALSE. + ENDSELECT + IF (.NOT.IS_INTEGER) EXIT + ENDDO + ENDIF + IF (IS_INTEGER) THEN + SELECT CASE(STAGE) + CASE(2, 5, 6) + IS_INTEGER = .TRUE. + CASE DEFAULT + IS_INTEGER = .FALSE. + END SELECT + ENDIF + ENDFUNCTION IS_INTEGER + + ELEMENTAL FUNCTION IS_LOWER(SELF) + !< RETURN TRUE IF ALL CHARACTERS IN THE STRING ARE LOWERCASE. + !< + !<```FORTRAN + !< TYPE(STRING) :: ASTRING + !< LOGICAL :: TEST_PASSED(3) + !< ASTRING = ' HELLO WORLD' + !< TEST_PASSED(1) = ASTRING%IS_LOWER().EQV..FALSE. + !< ASTRING = ' HELLO WORLD' + !< TEST_PASSED(2) = ASTRING%IS_LOWER().EQV..FALSE. + !< ASTRING = ' HELLO WORLD' + !< TEST_PASSED(3) = ASTRING%IS_LOWER().EQV..TRUE. + !< PRINT '(L1)', ALL(TEST_PASSED) + !<``` + !=> T <<< + CLASS(STRING), INTENT(IN) :: SELF !< THE STRING. + LOGICAL :: IS_LOWER !< RESULT OF THE TEST. + INTEGER :: C !< CHARACTER COUNTER. + + IS_LOWER = .FALSE. + IF (ALLOCATED(SELF%RAW)) THEN + IS_LOWER = .TRUE. + DO C=1, LEN(SELF%RAW) + IF (INDEX(UPPER_ALPHABET, SELF%RAW(C:C))>0) THEN + IS_LOWER = .FALSE. + EXIT + ENDIF + ENDDO + ENDIF + ENDFUNCTION IS_LOWER + + ELEMENTAL FUNCTION IS_NUMBER(SELF, ALLOW_SPACES) + !< RETURN TRUE IF THE STRING CONTAINS A NUMBER (REAL OR INTEGER). + !< + !<```FORTRAN + !< TYPE(STRING) :: ASTRING + !< LOGICAL :: TEST_PASSED(7) + !< ASTRING = ' -1212112 ' + !< TEST_PASSED(1) = ASTRING%IS_NUMBER().EQV..TRUE. + !< ASTRING = ' -121.2112 ' + !< TEST_PASSED(2) = ASTRING%IS_NUMBER().EQV..TRUE. + !< ASTRING = ' -1212112' + !< TEST_PASSED(3) = ASTRING%IS_NUMBER(ALLOW_SPACES=.FALSE.).EQV..FALSE. + !< ASTRING = '-12121.12 ' + !< TEST_PASSED(4) = ASTRING%IS_NUMBER(ALLOW_SPACES=.FALSE.).EQV..FALSE. + !< ASTRING = '+2E20' + !< TEST_PASSED(5) = ASTRING%IS_NUMBER().EQV..TRUE. + !< ASTRING = ' -2.4E13 ' + !< TEST_PASSED(6) = ASTRING%IS_NUMBER().EQV..TRUE. + !< ASTRING = ' -2 E13 ' + !< TEST_PASSED(7) = ASTRING%IS_NUMBER().EQV..FALSE. + !< PRINT '(L1)', ALL(TEST_PASSED) + !<``` + !=> T <<< + CLASS(STRING), INTENT(IN) :: SELF !< THE STRING. + LOGICAL, INTENT(IN), OPTIONAL :: ALLOW_SPACES !< ALLOW LEADING-TRAILING SPACES. + LOGICAL :: IS_NUMBER !< RESULT OF THE TEST. + + IS_NUMBER = (SELF%IS_INTEGER(ALLOW_SPACES=ALLOW_SPACES).OR.SELF%IS_REAL(ALLOW_SPACES=ALLOW_SPACES)) + ENDFUNCTION IS_NUMBER + + ELEMENTAL FUNCTION IS_REAL(SELF, ALLOW_SPACES) + !< RETURN TRUE IF THE STRING CONTAINS A REAL. + !< + !< THE REGULAR EXPRESSION IS `\S*[\+\-]?\D*(|\.?\D*([DEDE][\+\-]?\D+)?)\S*`. THE PARSE ALGORITHM IS DONE IN STAGES: + !< + !< | S0 | S1 | S2 | S3 | S4 | S5 | S6 | S7 | S8 | + !< |-----|---------|-----|-----|-----|--------|---------|-----|-----| + !< |`\S*`|`[\+\-]?`|`\D*`|`\.?`|`\D*`|`[DEDE]`|`[\+\-]?`|`\D*`|`\S*`| + !< + !< EXIT ON STAGES-PARSING RESULTS IN: + !< + !< | S0 | S1 | S2 | S3 | S4 | S5 | S6 | S7 | S8 | + !< |----|----|----|----|----|----|----|----|----| + ! | F | F | T | T | T | F | F | T | T | + !< + !< @NOTE THIS IMPLEMENTATION IS COURTESY OF + !< [TOMEDUNN](HTTPS://GITHUB.COM/TOMEDUNN/FORTRAN-STRING-UTILITY-MODULE/BLOB/MASTER/SRC/STRING_UTILITY_MODULE.F90#L614) + !< + !<```FORTRAN + !< TYPE(STRING) :: ASTRING + !< LOGICAL :: TEST_PASSED(6) + !< ASTRING = ' -1212112.D0 ' + !< TEST_PASSED(1) = ASTRING%IS_REAL().EQV..TRUE. + !< ASTRING = ' -1212112.D0' + !< TEST_PASSED(2) = ASTRING%IS_REAL(ALLOW_SPACES=.FALSE.).EQV..FALSE. + !< ASTRING = '-1212112.D0 ' + !< TEST_PASSED(3) = ASTRING%IS_REAL(ALLOW_SPACES=.FALSE.).EQV..FALSE. + !< ASTRING = '+2.E20' + !< TEST_PASSED(4) = ASTRING%IS_REAL().EQV..TRUE. + !< ASTRING = ' -2.01E13 ' + !< TEST_PASSED(5) = ASTRING%IS_REAL().EQV..TRUE. + !< ASTRING = ' -2.01 E13 ' + !< TEST_PASSED(6) = ASTRING%IS_REAL().EQV..FALSE. + !< PRINT '(L1)', ALL(TEST_PASSED) + !<``` + !=> T <<< + CLASS(STRING), INTENT(IN) :: SELF !< THE STRING. + LOGICAL, INTENT(IN), OPTIONAL :: ALLOW_SPACES !< ALLOW LEADING-TRAILING SPACES. + LOGICAL :: IS_REAL !< RESULT OF THE TEST. + LOGICAL :: ALLOW_SPACES_ !< ALLOW LEADING-TRAILING SPACES, LOCAL VARIABLE. + LOGICAL :: HAS_LEADING_DIGIT !< CHECK THE PRESENCE OF LEADING DIGITS. + INTEGER :: STAGE !< STAGES COUNTER. + INTEGER :: C !< CHARACTER COUNTER. + + IF (ALLOCATED(SELF%RAW)) THEN + ALLOW_SPACES_ = .TRUE. ; IF (PRESENT(ALLOW_SPACES)) ALLOW_SPACES_ = ALLOW_SPACES + STAGE = 0 + IS_REAL = .TRUE. + HAS_LEADING_DIGIT = .FALSE. + DO C=1, LEN(SELF%RAW) + SELECT CASE(SELF%RAW(C:C)) + CASE(SPACE, TAB) + SELECT CASE(STAGE) + CASE(0, 8) + IS_REAL = ALLOW_SPACES_ + CONTINUE + CASE(2:4, 7) + IS_REAL = ALLOW_SPACES_ + STAGE = 8 + CASE DEFAULT + IS_REAL = .FALSE. + ENDSELECT + CASE('+', '-') + SELECT CASE(STAGE) + CASE(0) + STAGE = 1 + CASE(5) + STAGE = 6 + CASE DEFAULT + IS_REAL = .FALSE. + ENDSELECT + CASE('0':'9') + SELECT CASE(STAGE) + CASE(0:1) + STAGE = 2 + HAS_LEADING_DIGIT = .TRUE. + CASE(3) + STAGE = 4 + CASE(5:6) + STAGE = 7 + CASE DEFAULT + CONTINUE + ENDSELECT + CASE('.') + SELECT CASE(STAGE) + CASE(0:2) + STAGE = 3 + CASE DEFAULT + IS_REAL = .FALSE. + ENDSELECT + CASE('e','E','d','D') + SELECT CASE(STAGE) + CASE(2:4) + STAGE = 5 + CASE DEFAULT + IS_REAL = .FALSE. + ENDSELECT + CASE DEFAULT + IS_REAL = .FALSE. + ENDSELECT + IF (.NOT.IS_REAL) EXIT + ENDDO + ENDIF + IF (IS_REAL) THEN + SELECT CASE(STAGE) + CASE(2, 4, 7, 8) + IS_REAL = .TRUE. + CASE(3) + IS_REAL = HAS_LEADING_DIGIT + CASE DEFAULT + IS_REAL = .FALSE. + ENDSELECT + ENDIF + ENDFUNCTION IS_REAL + + ELEMENTAL FUNCTION IS_UPPER(SELF) + !< RETURN TRUE IF ALL CHARACTERS IN THE STRING ARE UPPERCASE. + !< + !<```FORTRAN + !< TYPE(STRING) :: ASTRING + !< LOGICAL :: TEST_PASSED(3) + !< ASTRING = ' HELLO WORLD' + !< TEST_PASSED(1) = ASTRING%IS_UPPER().EQV..FALSE. + !< ASTRING = ' HELLO WORLD' + !< TEST_PASSED(2) = ASTRING%IS_UPPER().EQV..TRUE. + !< ASTRING = ' HELLO WORLD' + !< TEST_PASSED(3) = ASTRING%IS_UPPER().EQV..FALSE. + !< PRINT '(L1)', ALL(TEST_PASSED) + !<``` + !=> T <<< + CLASS(STRING), INTENT(IN) :: SELF !< THE STRING. + LOGICAL :: IS_UPPER !< RESULT OF THE TEST. + INTEGER :: C !< CHARACTER COUNTER. + + IS_UPPER = .FALSE. + IF (ALLOCATED(SELF%RAW)) THEN + IS_UPPER = .TRUE. + DO C=1, LEN(SELF%RAW) + IF (INDEX(LOWER_ALPHABET, SELF%RAW(C:C))>0) THEN + IS_UPPER = .FALSE. + EXIT + ENDIF + ENDDO + ENDIF + ENDFUNCTION IS_UPPER + + ELEMENTAL FUNCTION START_WITH(SELF, PREFIX, START, END) + !< RETURN TRUE IF A STRING STARTS WITH A SPECIFIED PREFIX. + !< + !<```FORTRAN + !< TYPE(STRING) :: ASTRING + !< LOGICAL :: TEST_PASSED(4) + !< ASTRING = 'HELLO WORLD!' + !< TEST_PASSED(1) = ASTRING%START_WITH(PREFIX='HELLO').EQV..TRUE. + !< TEST_PASSED(2) = ASTRING%START_WITH(PREFIX='HELL').EQV..FALSE. + !< TEST_PASSED(3) = ASTRING%START_WITH(PREFIX='LLO WOR', START=3).EQV..TRUE. + !< TEST_PASSED(4) = ASTRING%START_WITH(PREFIX='LO W', START=4, END=7).EQV..TRUE. + !< PRINT '(L1)', ALL(TEST_PASSED) + !<``` + !=> T <<< + CLASS(STRING), INTENT(IN) :: SELF !< THE STRING. + CHARACTER(KIND=CK, LEN=*), INTENT(IN) :: PREFIX !< SEARCHED PREFIX. + INTEGER, INTENT(IN), OPTIONAL :: START !< START POSITION INTO THE STRING. + INTEGER, INTENT(IN), OPTIONAL :: END !< END POSITION INTO THE STRING. + LOGICAL :: START_WITH !< RESULT OF THE TEST. + INTEGER :: START_ !< START POSITION INTO THE STRING, LOCAL VARIABLE. + INTEGER :: END_ !< END POSITION INTO THE STRING, LOCAL VARIABLE. + + START_WITH = .FALSE. + IF (ALLOCATED(SELF%RAW)) THEN + START_ = 1 ; IF (PRESENT(START)) START_ = START + END_ = LEN(SELF%RAW) ; IF (PRESENT(END)) END_ = END + IF (LEN(PREFIX)<=LEN(SELF%RAW(START_:END_))) THEN + START_WITH = INDEX(SELF%RAW(START_:END_), PREFIX)==1 + ENDIF + ENDIF + ENDFUNCTION START_WITH + + ! PRIVATE METHODS + + ! ASSIGNMENTS + PURE SUBROUTINE STRING_ASSIGN_STRING(LHS, RHS) + !< ASSIGNMENT OPERATOR FROM STRING INPUT. + !< + !<```FORTRAN + !< TYPE(STRING) :: ASTRING + !< TYPE(STRING) :: ANOTHERSTRING + !< LOGICAL :: TEST_PASSED(1) + !< ASTRING = 'HELLO' + !< ANOTHERSTRING = ASTRING + !< TEST_PASSED(1) = ASTRING%CHARS()==ANOTHERSTRING%CHARS() + !< PRINT '(L1)', ALL(TEST_PASSED) + !<``` + !=> T <<< + CLASS(STRING), INTENT(INOUT) :: LHS !< LEFT HAND SIDE. + TYPE(STRING), INTENT(IN) :: RHS !< RIGHT HAND SIDE. + + IF (ALLOCATED(RHS%RAW)) LHS%RAW = RHS%RAW + ENDSUBROUTINE STRING_ASSIGN_STRING + + PURE SUBROUTINE STRING_ASSIGN_CHARACTER(LHS, RHS) + !< ASSIGNMENT OPERATOR FROM CHARACTER INPUT. + !< + !<```FORTRAN + !< TYPE(STRING) :: ASTRING + !< LOGICAL :: TEST_PASSED(1) + !< ASTRING = 'HELLO' + !< TEST_PASSED(1) = ASTRING%CHARS()=='HELLO' + !< PRINT '(L1)', ALL(TEST_PASSED) + !<``` + !=> T <<< + CLASS(STRING), INTENT(INOUT) :: LHS !< LEFT HAND SIDE. + CHARACTER(KIND=CK, LEN=*), INTENT(IN) :: RHS !< RIGHT HAND SIDE. + + LHS%RAW = RHS + ENDSUBROUTINE STRING_ASSIGN_CHARACTER + + PURE SUBROUTINE STRING_ASSIGN_INTEGER_I1P(LHS, RHS) + !< ASSIGNMENT OPERATOR FROM INTEGER INPUT. + !< + !<```FORTRAN + !< USE PENF + !< TYPE(STRING) :: ASTRING + !< LOGICAL :: TEST_PASSED(1) + !< ASTRING = 127_I1P + !< TEST_PASSED(1) = ASTRING%TO_NUMBER(KIND=1_I1P)==127_I1P + !< PRINT '(L1)', ALL(TEST_PASSED) + !<``` + !=> T <<< + CLASS(STRING), INTENT(INOUT) :: LHS !< LEFT HAND SIDE. + INTEGER(I1P), INTENT(IN) :: RHS !< RIGHT HAND SIDE. + + LHS%RAW = TRIM(STR(RHS)) + ENDSUBROUTINE STRING_ASSIGN_INTEGER_I1P + + PURE SUBROUTINE STRING_ASSIGN_INTEGER_I2P(LHS, RHS) + !< ASSIGNMENT OPERATOR FROM INTEGER INPUT. + !< + !<```FORTRAN + !< USE PENF + !< TYPE(STRING) :: ASTRING + !< LOGICAL :: TEST_PASSED(1) + !< ASTRING = 127_I2P + !< TEST_PASSED(1) = ASTRING%TO_NUMBER(KIND=1_I2P)==127_I2P + !< PRINT '(L1)', ALL(TEST_PASSED) + !<``` + !=> T <<< + CLASS(STRING), INTENT(INOUT) :: LHS !< LEFT HAND SIDE. + INTEGER(I2P), INTENT(IN) :: RHS !< RIGHT HAND SIDE. + + LHS%RAW = TRIM(STR(RHS)) + ENDSUBROUTINE STRING_ASSIGN_INTEGER_I2P + + PURE SUBROUTINE STRING_ASSIGN_INTEGER_I4P(LHS, RHS) + !< ASSIGNMENT OPERATOR FROM INTEGER INPUT. + !< + !<```FORTRAN + !< USE PENF + !< TYPE(STRING) :: ASTRING + !< LOGICAL :: TEST_PASSED(1) + !< ASTRING = 127_I4P + !< TEST_PASSED(1) = ASTRING%TO_NUMBER(KIND=1_I4P)==127_I4P + !< PRINT '(L1)', ALL(TEST_PASSED) + !<``` + !=> T <<< + CLASS(STRING), INTENT(INOUT) :: LHS !< LEFT HAND SIDE. + INTEGER(I4P), INTENT(IN) :: RHS !< RIGHT HAND SIDE. + + LHS%RAW = TRIM(STR(RHS)) + ENDSUBROUTINE STRING_ASSIGN_INTEGER_I4P + + PURE SUBROUTINE STRING_ASSIGN_INTEGER_I8P(LHS, RHS) + !< ASSIGNMENT OPERATOR FROM INTEGER INPUT. + !< + !<```FORTRAN + !< USE PENF + !< TYPE(STRING) :: ASTRING + !< LOGICAL :: TEST_PASSED(1) + !< ASTRING = 127_I8P + !< TEST_PASSED(1) = ASTRING%TO_NUMBER(KIND=1_I8P)==127_I8P + !< PRINT '(L1)', ALL(TEST_PASSED) + !<``` + !=> T <<< + CLASS(STRING), INTENT(INOUT) :: LHS !< LEFT HAND SIDE. + INTEGER(I8P), INTENT(IN) :: RHS !< RIGHT HAND SIDE. + + LHS%RAW = TRIM(STR(RHS)) + ENDSUBROUTINE STRING_ASSIGN_INTEGER_I8P + + PURE SUBROUTINE STRING_ASSIGN_REAL_R4P(LHS, RHS) + !< ASSIGNMENT OPERATOR FROM REAL INPUT. + !< + !<```FORTRAN + !< USE PENF + !< TYPE(STRING) :: ASTRING + !< LOGICAL :: TEST_PASSED(1) + !< ASTRING = 3.021E6_R4P + !< TEST_PASSED(1) = ASTRING%TO_NUMBER(KIND=1._R4P)==3.021E6_R4P + !< PRINT '(L1)', ALL(TEST_PASSED) + !<``` + !=> T <<< + CLASS(STRING), INTENT(INOUT) :: LHS !< LEFT HAND SIDE. + REAL(R4P), INTENT(IN) :: RHS !< RIGHT HAND SIDE. + + LHS%RAW = TRIM(STR(RHS)) + ENDSUBROUTINE STRING_ASSIGN_REAL_R4P + + PURE SUBROUTINE STRING_ASSIGN_REAL_R8P(LHS, RHS) + !< ASSIGNMENT OPERATOR FROM REAL INPUT. + !< + !<```FORTRAN + !< USE PENF + !< TYPE(STRING) :: ASTRING + !< LOGICAL :: TEST_PASSED(1) + !< ASTRING = 3.021E6_R8P + !< TEST_PASSED(1) = ASTRING%TO_NUMBER(KIND=1._R8P)==3.021E6_R8P + !< PRINT '(L1)', ALL(TEST_PASSED) + !<``` + !=> T <<< + CLASS(STRING), INTENT(INOUT) :: LHS !< LEFT HAND SIDE. + REAL(R8P), INTENT(IN) :: RHS !< RIGHT HAND SIDE. + + LHS%RAW = TRIM(STR(RHS)) + ENDSUBROUTINE STRING_ASSIGN_REAL_R8P + + PURE SUBROUTINE STRING_ASSIGN_REAL_R16P(LHS, RHS) + !< ASSIGNMENT OPERATOR FROM REAL INPUT. + !< + !<```FORTRAN + !< USE PENF + !< TYPE(STRING) :: ASTRING + !< LOGICAL :: TEST_PASSED(1) + !< ASTRING = 3.021E6_R8P + !< TEST_PASSED(1) = ASTRING%TO_NUMBER(KIND=1._R8P)==3.021E6_R8P + !< PRINT '(L1)', ALL(TEST_PASSED) + !<``` + !=> T <<< + CLASS(STRING), INTENT(INOUT) :: LHS !< LEFT HAND SIDE. + REAL(R16P), INTENT(IN) :: RHS !< RIGHT HAND SIDE. + + LHS%RAW = TRIM(STR(RHS)) + ENDSUBROUTINE STRING_ASSIGN_REAL_R16P + + ! CONTATENATION OPERATORS + PURE FUNCTION STRING_CONCAT_STRING(LHS, RHS) RESULT(CONCAT) + !< CONCATENATION WITH STRING. + !< + !<```FORTRAN + !< TYPE(STRING) :: ASTRING + !< TYPE(STRING) :: ANOTHERSTRING + !< LOGICAL :: TEST_PASSED(1) + !< ASTRING = 'HELLO ' + !< ANOTHERSTRING = 'BYE BYE' + !< TEST_PASSED(1) = ASTRING//ANOTHERSTRING=='HELLO BYE BYE' + !< PRINT '(L1)', ALL(TEST_PASSED) + !<``` + !=> T <<< + CLASS(STRING), INTENT(IN) :: LHS !< LEFT HAND SIDE. + TYPE(STRING), INTENT(IN) :: RHS !< RIGHT HAND SIDE. + CHARACTER(KIND=CK, LEN=:), ALLOCATABLE :: CONCAT !< CONCATENATED STRING. + + CONCAT = '' + IF (ALLOCATED(LHS%RAW)) CONCAT = LHS%RAW + IF (ALLOCATED(RHS%RAW)) CONCAT = CONCAT//RHS%RAW + ENDFUNCTION STRING_CONCAT_STRING + + PURE FUNCTION STRING_CONCAT_CHARACTER(LHS, RHS) RESULT(CONCAT) + !< CONCATENATION WITH CHARACTER. + !< + !<```FORTRAN + !< TYPE(STRING) :: ASTRING + !< CHARACTER(LEN=:), ALLOCATABLE :: ACHARACTER + !< LOGICAL :: TEST_PASSED(1) + !< ASTRING = 'HELLO ' + !< ACHARACTER = 'WORLD!' + !< TEST_PASSED(1) = ASTRING//ACHARACTER=='HELLO WORLD!' + !< PRINT '(L1)', ALL(TEST_PASSED) + !<``` + !=> T <<< + CLASS(STRING), INTENT(IN) :: LHS !< LEFT HAND SIDE. + CHARACTER(KIND=CK, LEN=*), INTENT(IN) :: RHS !< RIGHT HAND SIDE. + CHARACTER(KIND=CK, LEN=:), ALLOCATABLE :: CONCAT !< CONCATENATED STRING. + + IF (ALLOCATED(LHS%RAW)) THEN + CONCAT = LHS%RAW//RHS + ELSE + CONCAT = RHS + ENDIF + ENDFUNCTION STRING_CONCAT_CHARACTER + + PURE FUNCTION CHARACTER_CONCAT_STRING(LHS, RHS) RESULT(CONCAT) + !< CONCATENATION WITH CHARACTER (INVERTED). + !< + !<```FORTRAN + !< TYPE(STRING) :: ASTRING + !< CHARACTER(LEN=:), ALLOCATABLE :: ACHARACTER + !< LOGICAL :: TEST_PASSED(1) + !< ASTRING = 'HELLO ' + !< ACHARACTER = 'WORLD!' + !< TEST_PASSED(1) = ACHARACTER//ASTRING=='WORLD!HELLO ' + !< PRINT '(L1)', ALL(TEST_PASSED) + !<``` + !=> T <<< + CHARACTER(KIND=CK, LEN=*), INTENT(IN) :: LHS !< LEFT HAND SIDE. + CLASS(STRING), INTENT(IN) :: RHS !< RIGHT HAND SIDE. + CHARACTER(KIND=CK, LEN=:), ALLOCATABLE :: CONCAT !< CONCATENATED STRING. + + IF (ALLOCATED(RHS%RAW)) THEN + CONCAT = LHS//RHS%RAW + ELSE + CONCAT = LHS + ENDIF + ENDFUNCTION CHARACTER_CONCAT_STRING + + ELEMENTAL FUNCTION STRING_CONCAT_STRING_STRING(LHS, RHS) RESULT(CONCAT) + !< CONCATENATION WITH STRING. + !< + !<```FORTRAN + !< TYPE(STRING) :: ASTRING + !< TYPE(STRING) :: ANOTHERSTRING + !< TYPE(STRING) :: YETANOTHERSTRING + !< LOGICAL :: TEST_PASSED(1) + !< ASTRING = 'HELLO ' + !< ANOTHERSTRING = 'BYE BYE' + !< YETANOTHERSTRING = ASTRING.CAT.ANOTHERSTRING + !< TEST_PASSED(1) = YETANOTHERSTRING%CHARS()=='HELLO BYE BYE' + !< PRINT '(L1)', ALL(TEST_PASSED) + !<``` + !=> T <<< + CLASS(STRING), INTENT(IN) :: LHS !< LEFT HAND SIDE. + TYPE(STRING), INTENT(IN) :: RHS !< RIGHT HAND SIDE. + TYPE(STRING) :: CONCAT !< CONCATENATED STRING. + CHARACTER(KIND=CK, LEN=:), ALLOCATABLE :: TEMPORARY !< TEMPORARY CONCATENATED STRING. + + TEMPORARY = '' + IF (ALLOCATED(LHS%RAW)) TEMPORARY = LHS%RAW + IF (ALLOCATED(RHS%RAW)) TEMPORARY = TEMPORARY//RHS%RAW + IF (TEMPORARY/='') CONCAT%RAW = TEMPORARY + ENDFUNCTION STRING_CONCAT_STRING_STRING + + ELEMENTAL FUNCTION STRING_CONCAT_CHARACTER_STRING(LHS, RHS) RESULT(CONCAT) + !< CONCATENATION WITH CHARACTER. + !< + !<```FORTRAN + !< TYPE(STRING) :: ASTRING + !< TYPE(STRING) :: YETANOTHERSTRING + !< CHARACTER(LEN=:), ALLOCATABLE :: ACHARACTER + !< LOGICAL :: TEST_PASSED(1) + !< ASTRING = 'HELLO ' + !< ACHARACTER = 'WORLD!' + !< YETANOTHERSTRING = ASTRING.CAT.ACHARACTER + !< TEST_PASSED(1) = YETANOTHERSTRING%CHARS()=='HELLO WORLD!' + !< PRINT '(L1)', ALL(TEST_PASSED) + !<``` + !=> T <<< + CLASS(STRING), INTENT(IN) :: LHS !< LEFT HAND SIDE. + CHARACTER(KIND=CK, LEN=*), INTENT(IN) :: RHS !< RIGHT HAND SIDE. + TYPE(STRING) :: CONCAT !< CONCATENATED STRING. + + IF (ALLOCATED(LHS%RAW)) THEN + CONCAT%RAW = LHS%RAW//RHS + ELSE + CONCAT%RAW = RHS + ENDIF + ENDFUNCTION STRING_CONCAT_CHARACTER_STRING + + ELEMENTAL FUNCTION CHARACTER_CONCAT_STRING_STRING(LHS, RHS) RESULT(CONCAT) + !< CONCATENATION WITH CHARACTER (INVERTED). + !< + !<```FORTRAN + !< TYPE(STRING) :: ASTRING + !< TYPE(STRING) :: YETANOTHERSTRING + !< CHARACTER(LEN=:), ALLOCATABLE :: ACHARACTER + !< LOGICAL :: TEST_PASSED(1) + !< ASTRING = 'HELLO ' + !< ACHARACTER = 'WORLD!' + !< YETANOTHERSTRING = ACHARACTER.CAT.ASTRING + !< TEST_PASSED(1) = YETANOTHERSTRING%CHARS()=='WORLD!HELLO ' + !< PRINT '(L1)', ALL(TEST_PASSED) + !<``` + !=> T <<< + CHARACTER(KIND=CK, LEN=*), INTENT(IN) :: LHS !< LEFT HAND SIDE. + CLASS(STRING), INTENT(IN) :: RHS !< RIGHT HAND SIDE. + TYPE(STRING) :: CONCAT !< CONCATENATED STRING. + + IF (ALLOCATED(RHS%RAW)) THEN + CONCAT%RAW = LHS//RHS%RAW + ELSE + CONCAT%RAW = LHS + ENDIF + ENDFUNCTION CHARACTER_CONCAT_STRING_STRING + + ! LOGICAL OPERATORS + ELEMENTAL FUNCTION STRING_EQ_STRING(LHS, RHS) RESULT(IS_IT) + !< EQUAL TO STRING LOGICAL OPERATOR. + !< + !<```FORTRAN + !< TYPE(STRING) :: ASTRING + !< TYPE(STRING) :: ANOTHERSTRING + !< LOGICAL :: TEST_PASSED(2) + !< ASTRING = ' ONE ' + !< ANOTHERSTRING = 'TWO' + !< TEST_PASSED(1) = ((ASTRING==ANOTHERSTRING).EQV..FALSE.) + !< ASTRING = 'THE SAME ' + !< ANOTHERSTRING = 'THE SAME ' + !< TEST_PASSED(2) = ((ASTRING==ANOTHERSTRING).EQV..TRUE.) + !< PRINT '(L1)', ALL(TEST_PASSED) + !<``` + !=> T <<< + CLASS(STRING), INTENT(IN) :: LHS !< LEFT HAND SIDE. + TYPE(STRING), INTENT(IN) :: RHS !< RIGHT HAND SIDE. + LOGICAL :: IS_IT !< OPREATOR TEST RESULT. + + IS_IT = LHS%RAW == RHS%RAW + ENDFUNCTION STRING_EQ_STRING + + ELEMENTAL FUNCTION STRING_EQ_CHARACTER(LHS, RHS) RESULT(IS_IT) + !< EQUAL TO CHARACTER LOGICAL OPERATOR. + !< + !<```FORTRAN + !< TYPE(STRING) :: ASTRING + !< CHARACTER(LEN=:), ALLOCATABLE :: ACHARACTER + !< LOGICAL :: TEST_PASSED(2) + !< ASTRING = ' ONE ' + !< ACHARACTER = 'THREE' + !< TEST_PASSED(1) = ((ASTRING==ACHARACTER).EQV..FALSE.) + !< ASTRING = 'THE SAME ' + !< ACHARACTER = 'THE SAME ' + !< TEST_PASSED(2) = ((ASTRING==ACHARACTER).EQV..TRUE.) + !< PRINT '(L1)', ALL(TEST_PASSED) + !<``` + !=> T <<< + CLASS(STRING), INTENT(IN) :: LHS !< LEFT HAND SIDE. + CHARACTER(KIND=CK, LEN=*), INTENT(IN) :: RHS !< RIGHT HAND SIDE. + LOGICAL :: IS_IT !< OPREATOR TEST RESULT. + + IS_IT = LHS%RAW == RHS + ENDFUNCTION STRING_EQ_CHARACTER + + ELEMENTAL FUNCTION CHARACTER_EQ_STRING(LHS, RHS) RESULT(IS_IT) + !< EQUAL TO CHARACTER (INVERTED) LOGICAL OPERATOR. + !< + !<```FORTRAN + !< TYPE(STRING) :: ASTRING + !< CHARACTER(LEN=:), ALLOCATABLE :: ACHARACTER + !< LOGICAL :: TEST_PASSED(2) + !< ASTRING = ' ONE ' + !< ACHARACTER = 'THREE' + !< TEST_PASSED(1) = ((ACHARACTER==ASTRING).EQV..FALSE.) + !< ASTRING = 'THE SAME ' + !< ACHARACTER = 'THE SAME ' + !< TEST_PASSED(2) = ((ACHARACTER==ASTRING).EQV..TRUE.) + !< PRINT '(L1)', ALL(TEST_PASSED) + !<``` + !=> T <<< + CHARACTER(KIND=CK, LEN=*), INTENT(IN) :: LHS !< LEFT HAND SIDE. + CLASS(STRING), INTENT(IN) :: RHS !< RIGHT HAND SIDE. + LOGICAL :: IS_IT !< OPREATOR TEST RESULT. + + IS_IT = RHS%RAW == LHS + ENDFUNCTION CHARACTER_EQ_STRING + + ELEMENTAL FUNCTION STRING_NE_STRING(LHS, RHS) RESULT(IS_IT) + !< NOT EQUAL TO STRING LOGICAL OPERATOR. + !< + !<```FORTRAN + !< TYPE(STRING) :: ASTRING + !< TYPE(STRING) :: ANOTHERSTRING + !< LOGICAL :: TEST_PASSED(2) + !< ASTRING = ' ONE ' + !< ANOTHERSTRING = 'TWO' + !< TEST_PASSED(1) = ((ASTRING/=ANOTHERSTRING).EQV..TRUE.) + !< ASTRING = 'THE SAME ' + !< ANOTHERSTRING = 'THE SAME ' + !< TEST_PASSED(2) = ((ASTRING/=ANOTHERSTRING).EQV..FALSE.) + !< PRINT '(L1)', ALL(TEST_PASSED) + !<``` + !=> T <<< + CLASS(STRING), INTENT(IN) :: LHS !< LEFT HAND SIDE. + TYPE(STRING), INTENT(IN) :: RHS !< RIGHT HAND SIDE. + LOGICAL :: IS_IT !< OPREATOR TEST RESULT. + + IS_IT = LHS%RAW /= RHS%RAW + ENDFUNCTION STRING_NE_STRING + + ELEMENTAL FUNCTION STRING_NE_CHARACTER(LHS, RHS) RESULT(IS_IT) + !< NOT EQUAL TO CHARACTER LOGICAL OPERATOR. + !< + !<```FORTRAN + !< TYPE(STRING) :: ASTRING + !< CHARACTER(LEN=:), ALLOCATABLE :: ACHARACTER + !< LOGICAL :: TEST_PASSED(2) + !< ASTRING = ' ONE ' + !< ACHARACTER = 'THREE' + !< TEST_PASSED(1) = ((ASTRING/=ACHARACTER).EQV..TRUE.) + !< ASTRING = 'THE SAME ' + !< ACHARACTER = 'THE SAME ' + !< TEST_PASSED(2) = ((ASTRING/=ACHARACTER).EQV..FALSE.) + !< PRINT '(L1)', ALL(TEST_PASSED) + !<``` + !=> T <<< + CLASS(STRING), INTENT(IN) :: LHS !< LEFT HAND SIDE. + CHARACTER(KIND=CK, LEN=*), INTENT(IN) :: RHS !< RIGHT HAND SIDE. + LOGICAL :: IS_IT !< OPREATOR TEST RESULT. + + IS_IT = LHS%RAW /= RHS + ENDFUNCTION STRING_NE_CHARACTER + + ELEMENTAL FUNCTION CHARACTER_NE_STRING(LHS, RHS) RESULT(IS_IT) + !< NOT EQUAL TO CHARACTER (INVERTED) LOGICAL OPERATOR. + !< + !<```FORTRAN + !< TYPE(STRING) :: ASTRING + !< CHARACTER(LEN=:), ALLOCATABLE :: ACHARACTER + !< LOGICAL :: TEST_PASSED(2) + !< ASTRING = ' ONE ' + !< ACHARACTER = 'THREE' + !< TEST_PASSED(1) = ((ACHARACTER/=ASTRING).EQV..TRUE.) + !< ASTRING = 'THE SAME ' + !< ACHARACTER = 'THE SAME ' + !< TEST_PASSED(2) = ((ACHARACTER/=ASTRING).EQV..FALSE.) + !< PRINT '(L1)', ALL(TEST_PASSED) + !<``` + !=> T <<< + CHARACTER(KIND=CK, LEN=*), INTENT(IN) :: LHS !< LEFT HAND SIDE. + CLASS(STRING), INTENT(IN) :: RHS !< RIGHT HAND SIDE. + LOGICAL :: IS_IT !< OPREATOR TEST RESULT. + + IS_IT = RHS%RAW /= LHS + ENDFUNCTION CHARACTER_NE_STRING + + ELEMENTAL FUNCTION STRING_LT_STRING(LHS, RHS) RESULT(IS_IT) + !< LOWER THAN TO STRING LOGICAL OPERATOR. + !< + !<```FORTRAN + !< TYPE(STRING) :: ASTRING + !< TYPE(STRING) :: ANOTHERSTRING + !< LOGICAL :: TEST_PASSED(2) + !< ASTRING = 'ONE' + !< ANOTHERSTRING = 'ONE' + !< TEST_PASSED(1) = ((ASTRING<ANOTHERSTRING).EQV..FALSE.) + !< ASTRING = 'ONE' + !< ANOTHERSTRING = 'ONE' + !< TEST_PASSED(2) = ((ASTRING<ANOTHERSTRING).EQV..TRUE.) + !< PRINT '(L1)', ALL(TEST_PASSED) + !<``` + !=> T <<< + CLASS(STRING), INTENT(IN) :: LHS !< LEFT HAND SIDE. + TYPE(STRING), INTENT(IN) :: RHS !< RIGHT HAND SIDE. + LOGICAL :: IS_IT !< OPREATOR TEST RESULT. + + IS_IT = LHS%RAW < RHS%RAW + ENDFUNCTION STRING_LT_STRING + + ELEMENTAL FUNCTION STRING_LT_CHARACTER(LHS, RHS) RESULT(IS_IT) + !< LOWER THAN TO CHARACTER LOGICAL OPERATOR. + !< + !<```FORTRAN + !< TYPE(STRING) :: ASTRING + !< CHARACTER(LEN=:), ALLOCATABLE :: ACHARACTER + !< LOGICAL :: TEST_PASSED(2) + !< ASTRING = 'ONE' + !< ACHARACTER = 'ONE' + !< TEST_PASSED(1) = ((ASTRING<ACHARACTER).EQV..FALSE.) + !< ASTRING = 'ONE' + !< ACHARACTER = 'ONE' + !< TEST_PASSED(2) = ((ASTRING<ACHARACTER).EQV..TRUE.) + !< PRINT '(L1)', ALL(TEST_PASSED) + !<``` + !=> T <<< + CLASS(STRING), INTENT(IN) :: LHS !< LEFT HAND SIDE. + CHARACTER(KIND=CK, LEN=*), INTENT(IN) :: RHS !< RIGHT HAND SIDE. + LOGICAL :: IS_IT !< OPREATOR TEST RESULT. + + IS_IT = LHS%RAW < RHS + ENDFUNCTION STRING_LT_CHARACTER + + ELEMENTAL FUNCTION CHARACTER_LT_STRING(LHS, RHS) RESULT(IS_IT) + !< LOWER THAN TO CHARACTER (INVERTED) LOGICAL OPERATOR. + !< + !<```FORTRAN + !< TYPE(STRING) :: ASTRING + !< CHARACTER(LEN=:), ALLOCATABLE :: ACHARACTER + !< LOGICAL :: TEST_PASSED(2) + !< ASTRING = 'ONE' + !< ACHARACTER = 'ONE' + !< TEST_PASSED(1) = ((ACHARACTER<ASTRING).EQV..TRUE.) + !< ASTRING = 'ONE' + !< ACHARACTER = 'ONE' + !< TEST_PASSED(2) = ((ACHARACTER<ASTRING).EQV..FALSE.) + !< PRINT '(L1)', ALL(TEST_PASSED) + !<``` + !=> T <<< + CHARACTER(KIND=CK, LEN=*), INTENT(IN) :: LHS !< LEFT HAND SIDE. + CLASS(STRING), INTENT(IN) :: RHS !< RIGHT HAND SIDE. + LOGICAL :: IS_IT !< OPREATOR TEST RESULT. + + IS_IT = LHS < RHS%RAW + ENDFUNCTION CHARACTER_LT_STRING + + ELEMENTAL FUNCTION STRING_LE_STRING(LHS, RHS) RESULT(IS_IT) + !< LOWER EQUAL THAN TO STRING LOGICAL OPERATOR. + !< + !<```FORTRAN + !< TYPE(STRING) :: ASTRING + !< TYPE(STRING) :: ANOTHERSTRING + !< LOGICAL :: TEST_PASSED(3) + !< ASTRING = 'ONE' + !< ANOTHERSTRING = 'ONE' + !< TEST_PASSED(1) = ((ASTRING<=ANOTHERSTRING).EQV..FALSE.) + !< ASTRING = 'ONE' + !< ANOTHERSTRING = 'ONE' + !< TEST_PASSED(2) = ((ASTRING<=ANOTHERSTRING).EQV..TRUE.) + !< ASTRING = 'ONE' + !< ANOTHERSTRING = 'ONE' + !< TEST_PASSED(3) = ((ASTRING<=ANOTHERSTRING).EQV..TRUE.) + !< PRINT '(L1)', ALL(TEST_PASSED) + !<``` + !=> T <<< + CLASS(STRING), INTENT(IN) :: LHS !< LEFT HAND SIDE. + TYPE(STRING), INTENT(IN) :: RHS !< RIGHT HAND SIDE. + LOGICAL :: IS_IT !< OPREATOR TEST RESULT. + + IS_IT = LHS%RAW <= RHS%RAW + ENDFUNCTION STRING_LE_STRING + + ELEMENTAL FUNCTION STRING_LE_CHARACTER(LHS, RHS) RESULT(IS_IT) + !< LOWER EQUAL THAN TO CHARACTER LOGICAL OPERATOR. + !< + !<```FORTRAN + !< TYPE(STRING) :: ASTRING + !< CHARACTER(LEN=:), ALLOCATABLE :: ACHARACTER + !< LOGICAL :: TEST_PASSED(3) + !< ASTRING = 'ONE' + !< ACHARACTER = 'ONE' + !< TEST_PASSED(1) = ((ASTRING<=ACHARACTER).EQV..FALSE.) + !< ASTRING = 'ONE' + !< ACHARACTER = 'ONE' + !< TEST_PASSED(2) = ((ASTRING<=ACHARACTER).EQV..TRUE.) + !< ASTRING = 'ONE' + !< ACHARACTER = 'ONE' + !< TEST_PASSED(3) = ((ASTRING<=ACHARACTER).EQV..TRUE.) + !< PRINT '(L1)', ALL(TEST_PASSED) + !<``` + !=> T <<< + CLASS(STRING), INTENT(IN) :: LHS !< LEFT HAND SIDE. + CHARACTER(KIND=CK, LEN=*), INTENT(IN) :: RHS !< RIGHT HAND SIDE. + LOGICAL :: IS_IT !< OPREATOR TEST RESULT. + + IS_IT = LHS%RAW <= RHS + ENDFUNCTION STRING_LE_CHARACTER + + ELEMENTAL FUNCTION CHARACTER_LE_STRING(LHS, RHS) RESULT(IS_IT) + !< LOWER EQUAL THAN TO CHARACTER (INVERTED) LOGICAL OPERATOR. + !< + !<```FORTRAN + !< TYPE(STRING) :: ASTRING + !< CHARACTER(LEN=:), ALLOCATABLE :: ACHARACTER + !< LOGICAL :: TEST_PASSED(3) + !< ASTRING = 'ONE' + !< ACHARACTER = 'ONE' + !< TEST_PASSED(1) = ((ACHARACTER<=ASTRING).EQV..TRUE.) + !< ASTRING = 'ONE' + !< ACHARACTER = 'ONE' + !< TEST_PASSED(2) = ((ACHARACTER<=ASTRING).EQV..FALSE.) + !< ASTRING = 'ONE' + !< ACHARACTER = 'ONE' + !< TEST_PASSED(3) = ((ACHARACTER<=ASTRING).EQV..TRUE.) + !< PRINT '(L1)', ALL(TEST_PASSED) + !<``` + !=> T <<< + CHARACTER(KIND=CK, LEN=*), INTENT(IN) :: LHS !< LEFT HAND SIDE. + CLASS(STRING), INTENT(IN) :: RHS !< RIGHT HAND SIDE. + LOGICAL :: IS_IT !< OPREATOR TEST RESULT. + + IS_IT = LHS <= RHS%RAW + ENDFUNCTION CHARACTER_LE_STRING + + ELEMENTAL FUNCTION STRING_GE_STRING(LHS, RHS) RESULT(IS_IT) + !< GREATER EQUAL THAN TO STRING LOGICAL OPERATOR. + !< + !<```FORTRAN + !< TYPE(STRING) :: ASTRING + !< TYPE(STRING) :: ANOTHERSTRING + !< LOGICAL :: TEST_PASSED(3) + !< ASTRING = 'ONE' + !< ANOTHERSTRING = 'ONE' + !< TEST_PASSED(1) = ((ASTRING>=ANOTHERSTRING).EQV..TRUE.) + !< ASTRING = 'ONE' + !< ANOTHERSTRING = 'ONE' + !< TEST_PASSED(2) = ((ASTRING>=ANOTHERSTRING).EQV..FALSE.) + !< ASTRING = 'ONE' + !< ANOTHERSTRING = 'ONE' + !< TEST_PASSED(3) = ((ASTRING>=ANOTHERSTRING).EQV..TRUE.) + !< PRINT '(L1)', ALL(TEST_PASSED) + !<``` + !=> T <<< + CLASS(STRING), INTENT(IN) :: LHS !< LEFT HAND SIDE. + TYPE(STRING), INTENT(IN) :: RHS !< RIGHT HAND SIDE. + LOGICAL :: IS_IT !< OPREATOR TEST RESULT. + + IS_IT = LHS%RAW >= RHS%RAW + ENDFUNCTION STRING_GE_STRING + + ELEMENTAL FUNCTION STRING_GE_CHARACTER(LHS, RHS) RESULT(IS_IT) + !< GREATER EQUAL THAN TO CHARACTER LOGICAL OPERATOR. + !< + !<```FORTRAN + !< TYPE(STRING) :: ASTRING + !< CHARACTER(LEN=:), ALLOCATABLE :: ACHARACTER + !< LOGICAL :: TEST_PASSED(3) + !< ASTRING = 'ONE' + !< ACHARACTER = 'ONE' + !< TEST_PASSED(1) = ((ASTRING>=ACHARACTER).EQV..TRUE.) + !< ASTRING = 'ONE' + !< ACHARACTER = 'ONE' + !< TEST_PASSED(2) = ((ASTRING>=ACHARACTER).EQV..FALSE.) + !< ASTRING = 'ONE' + !< ACHARACTER = 'ONE' + !< TEST_PASSED(3) = ((ASTRING>=ACHARACTER).EQV..TRUE.) + !< PRINT '(L1)', ALL(TEST_PASSED) + !<``` + !=> T <<< + CLASS(STRING), INTENT(IN) :: LHS !< LEFT HAND SIDE. + CHARACTER(KIND=CK, LEN=*), INTENT(IN) :: RHS !< RIGHT HAND SIDE. + LOGICAL :: IS_IT !< OPREATOR TEST RESULT. + + IS_IT = LHS%RAW >= RHS + ENDFUNCTION STRING_GE_CHARACTER + + ELEMENTAL FUNCTION CHARACTER_GE_STRING(LHS, RHS) RESULT(IS_IT) + !< GREATER EQUAL THAN TO CHARACTER (INVERTED) LOGICAL OPERATOR. + !< + !<```FORTRAN + !< TYPE(STRING) :: ASTRING + !< CHARACTER(LEN=:), ALLOCATABLE :: ACHARACTER + !< LOGICAL :: TEST_PASSED(3) + !< ASTRING = 'ONE' + !< ACHARACTER = 'ONE' + !< TEST_PASSED(1) = ((ACHARACTER>=ASTRING).EQV..FALSE.) + !< ASTRING = 'ONE' + !< ACHARACTER = 'ONE' + !< TEST_PASSED(2) = ((ACHARACTER>=ASTRING).EQV..TRUE.) + !< ASTRING = 'ONE' + !< ACHARACTER = 'ONE' + !< TEST_PASSED(3) = ((ACHARACTER>=ASTRING).EQV..TRUE.) + !< PRINT '(L1)', ALL(TEST_PASSED) + !<``` + !=> T <<< + CHARACTER(KIND=CK, LEN=*), INTENT(IN) :: LHS !< LEFT HAND SIDE. + CLASS(STRING), INTENT(IN) :: RHS !< RIGHT HAND SIDE. + LOGICAL :: IS_IT !< OPREATOR TEST RESULT. + + IS_IT = LHS >= RHS%RAW + ENDFUNCTION CHARACTER_GE_STRING + + ELEMENTAL FUNCTION STRING_GT_STRING(LHS, RHS) RESULT(IS_IT) + !< GREATER THAN TO STRING LOGICAL OPERATOR. + !< + !<```FORTRAN + !< TYPE(STRING) :: ASTRING + !< TYPE(STRING) :: ANOTHERSTRING + !< LOGICAL :: TEST_PASSED(2) + !< ASTRING = 'ONE' + !< ANOTHERSTRING = 'ONE' + !< TEST_PASSED(1) = ((ASTRING>ANOTHERSTRING).EQV..TRUE.) + !< ASTRING = 'ONE' + !< ANOTHERSTRING = 'ONE' + !< TEST_PASSED(2) = ((ASTRING>ANOTHERSTRING).EQV..FALSE.) + !< PRINT '(L1)', ALL(TEST_PASSED) + !<``` + !=> T <<< + CLASS(STRING), INTENT(IN) :: LHS !< LEFT HAND SIDE. + TYPE(STRING), INTENT(IN) :: RHS !< RIGHT HAND SIDE. + LOGICAL :: IS_IT !< OPREATOR TEST RESULT. + + IS_IT = LHS%RAW > RHS%RAW + ENDFUNCTION STRING_GT_STRING + + ELEMENTAL FUNCTION STRING_GT_CHARACTER(LHS, RHS) RESULT(IS_IT) + !< GREATER THAN TO CHARACTER LOGICAL OPERATOR. + !< + !<```FORTRAN + !< TYPE(STRING) :: ASTRING + !< CHARACTER(LEN=:), ALLOCATABLE :: ACHARACTER + !< LOGICAL :: TEST_PASSED(2) + !< ASTRING = 'ONE' + !< ACHARACTER = 'ONE' + !< TEST_PASSED(1) = ((ASTRING>ACHARACTER).EQV..TRUE.) + !< ASTRING = 'ONE' + !< ACHARACTER = 'ONE' + !< TEST_PASSED(2) = ((ASTRING>ACHARACTER).EQV..FALSE.) + !< PRINT '(L1)', ALL(TEST_PASSED) + !<``` + !=> T <<< + CLASS(STRING), INTENT(IN) :: LHS !< LEFT HAND SIDE. + CHARACTER(KIND=CK, LEN=*), INTENT(IN) :: RHS !< RIGHT HAND SIDE. + LOGICAL :: IS_IT !< OPREATOR TEST RESULT. + + IS_IT = LHS%RAW > RHS + ENDFUNCTION STRING_GT_CHARACTER + + ELEMENTAL FUNCTION CHARACTER_GT_STRING(LHS, RHS) RESULT(IS_IT) + !< GREATER THAN TO CHARACTER (INVERTED) LOGICAL OPERATOR. + !< + !<```FORTRAN + !< TYPE(STRING) :: ASTRING + !< CHARACTER(LEN=:), ALLOCATABLE :: ACHARACTER + !< LOGICAL :: TEST_PASSED(2) + !< ASTRING = 'ONE' + !< ACHARACTER = 'ONE' + !< TEST_PASSED(1) = ((ACHARACTER>ASTRING).EQV..FALSE.) + !< ASTRING = 'ONE' + !< ACHARACTER = 'ONE' + !< TEST_PASSED(2) = ((ACHARACTER>ASTRING).EQV..TRUE.) + !< PRINT '(L1)', ALL(TEST_PASSED) + !<``` + !=> T <<< + CHARACTER(KIND=CK, LEN=*), INTENT(IN) :: LHS !< LEFT HAND SIDE. + CLASS(STRING), INTENT(IN) :: RHS !< RIGHT HAND SIDE. + LOGICAL :: IS_IT !< OPREATOR TEST RESULT. + + IS_IT = LHS > RHS%RAW + ENDFUNCTION CHARACTER_GT_STRING + + ! IO + SUBROUTINE READ_FORMATTED(DTV, UNIT, IOTYPE, V_LIST, IOSTAT, IOMSG) + !< FORMATTED INPUT. + !< + !< @BUG CHANGE TEMPORARY ACKS: FIND A MORE PRECISE LENGTH OF THE INPUT STRING AND AVOID THE TRIMMING! + !< + !< @BUG READ LISTDIRECTED WITH AND WITHOUT DELIMITERS DOES NOT WORK. + CLASS(STRING), INTENT(INOUT) :: DTV !< THE STRING. + INTEGER, INTENT(IN) :: UNIT !< LOGICAL UNIT. + CHARACTER(LEN=*), INTENT(IN) :: IOTYPE !< EDIT DESCRIPTOR. + INTEGER, INTENT(IN) :: V_LIST(:) !< EDIT DESCRIPTOR LIST. + INTEGER, INTENT(OUT) :: IOSTAT !< IO STATUS CODE. + CHARACTER(LEN=*), INTENT(INOUT) :: IOMSG !< IO STATUS MESSAGE. + CHARACTER(LEN=LEN(IOMSG)) :: LOCAL_IOMSG !< LOCAL VARIANT OF IOMSG, SO IT DOESN'T GET INAPPROPRIATELY REDEFINED. + CHARACTER(KIND=CK, LEN=1) :: DELIM !< STRING DELIMITER, IF ANY. + CHARACTER(KIND=CK, LEN=100) :: TEMPORARY !< TEMPORARY STORAGE STRING. + + IF (IOTYPE == 'LISTDIRECTED') THEN + CALL GET_NEXT_NON_BLANK_CHARACTER_ANY_RECORD(UNIT=UNIT, CH=DELIM, IOSTAT=IOSTAT, IOMSG=IOMSG) + IF (IOSTAT/=0) RETURN + IF (DELIM=='"'.OR.DELIM=="'") THEN + CALL DTV%READ_DELIMITED(UNIT=UNIT, DELIM=DELIM, IOSTAT=IOSTAT, IOMSG=LOCAL_IOMSG) + ELSE + ! STEP BACK BEFORE THE NON-BLANK + READ(UNIT, "(TL1)", IOSTAT=IOSTAT, IOMSG=IOMSG) + IF (IOSTAT /= 0) RETURN + CALL DTV%READ_UNDELIMITED_LISTDIRECTED(UNIT=UNIT, IOSTAT=IOSTAT, IOMSG=LOCAL_IOMSG) + ENDIF + IF (IS_IOSTAT_EOR(IOSTAT)) THEN + ! SUPPRESS IOSTAT_EOR + IOSTAT = 0 + ELSEIF (IOSTAT /= 0) THEN + IOMSG = LOCAL_IOMSG + ENDIF + RETURN + ELSE + READ(UNIT, "(A)", IOSTAT=IOSTAT, IOMSG=IOMSG)TEMPORARY + DTV%RAW = TRIM(TEMPORARY) + ENDIF + ENDSUBROUTINE READ_FORMATTED + + SUBROUTINE READ_DELIMITED(DTV, UNIT, DELIM, IOSTAT, IOMSG) + !< READ A DELIMITED STRING FROM A UNIT CONNECTED FOR FORMATTED INPUT. + !< + !< IF THE CLOSING DELIMITER IS FOLLOWED BY END OF RECORD, THEN WE RETURN END OF RECORD. + !< + !< @NOTE THIS DOES NOT NEED A DOCTEST, IT BEING TESTED BY [[STRING::READ_FORMATTED]]. + CLASS(STRING), INTENT(OUT) :: DTV !< THE STRING. + INTEGER, INTENT(IN) :: UNIT !< LOGICAL UNIT. + CHARACTER(KIND=CK, LEN=1), INTENT(IN) :: DELIM !< STRING DELIMITER. + INTEGER, INTENT(OUT) :: IOSTAT !< IO STATUS CODE. + CHARACTER(KIND=CK, LEN=*), INTENT(INOUT) :: IOMSG !< IO STATUS MESSAGE. + CHARACTER(KIND=CK, LEN=1) :: CH !< A CHARACTER READ. + LOGICAL :: WAS_DELIM !< INDICATES THAT THE LAST CHARACTER READ WAS A DELIMITER. + + WAS_DELIM = .FALSE. + DTV%RAW = '' + DO + READ(UNIT, "(A)", IOSTAT=IOSTAT, IOMSG=IOMSG) CH + IF (IS_IOSTAT_EOR(IOSTAT)) THEN + IF (WAS_DELIM) THEN + ! END OF DELIMITED STRING FOLLOWED BY END OF RECORD IS END OF THE STRING. PASS BACK THE + ! END OF RECORD CONDITION TO THE CALLER + RETURN + ELSE + ! END OF RECORD WITHOUT TERMINATING DELIMITER - MOVE ALONG + CYCLE + ENDIF + ELSEIF (IOSTAT /= 0) THEN + RETURN + ENDIF + IF (CH == DELIM) THEN + IF (WAS_DELIM) THEN + ! DOUBLED DELIMITER IS ONE DELIMITER IN THE VALUE + DTV%RAW = DTV%RAW // CH + WAS_DELIM = .FALSE. + ELSE + ! NEED TO TEST NEXT CHARACTER TO SEE WHAT IS HAPPENING + WAS_DELIM = .TRUE. + ENDIF + ELSEIF (WAS_DELIM) THEN + ! THE PREVIOUS CHARACTER WAS ACTUALLY THE DELIMITER FOR THE END OF THE STRING. PUT BACK THIS CHARACTER + READ(UNIT, "(TL1)", IOSTAT=IOSTAT, IOMSG=IOMSG) + RETURN + ELSE + DTV%RAW = DTV%RAW // CH + ENDIF + ENDDO + ENDSUBROUTINE READ_DELIMITED + + SUBROUTINE READ_UNDELIMITED_LISTDIRECTED(DTV, UNIT, IOSTAT, IOMSG) + !< READ AN UNDELIMITED (NO LEADING APOSTROPHE OR DOUBLE QUOTE) CHARACTER VALUE ACCORDING TO THE RULES FOR LIST DIRECTED INPUT. + !< + !< A BLANK, COMMA/SEMICOLON (DEPENDING ON THE DECIMAL MODE), SLASH OR END OF RECORD TERMINATES THE STRING. + !< + !< IF INPUT IS TERMINATED BY END OF RECORD, THEN THIS PROCEDURE RETURNS AN END-OF-RECORD CONDITION. + CLASS(STRING), INTENT(INOUT) :: DTV !< THE STRING. + INTEGER, INTENT(IN) :: UNIT !< LOGICAL UNIT. + INTEGER, INTENT(OUT) :: IOSTAT !< IO STATUS CODE. + CHARACTER(LEN=*), INTENT(INOUT) :: IOMSG !< IO STATUS MESSAGE. + LOGICAL :: DECIMAL_POINT !<TRUE IF DECIMAL=POINT IN EFFECT. + + CALL GET_DECIMAL_MODE(UNIT=UNIT, DECIMAL_POINT=DECIMAL_POINT, IOSTAT=IOSTAT, IOMSG=IOMSG) + IF (IOSTAT /= 0) RETURN + CALL DTV%READ_UNDELIMITED(UNIT=UNIT, TERMINATORS=' '//'/'//MERGE(CK_',', CK_';', DECIMAL_POINT), IOSTAT=IOSTAT, IOMSG=IOMSG) + ENDSUBROUTINE READ_UNDELIMITED_LISTDIRECTED + + SUBROUTINE READ_UNDELIMITED(DTV, UNIT, TERMINATORS, IOSTAT, IOMSG) + !< READ AN UNDELIMITED STRING UP UNTIL END OF RECORD OR A CHARACTER FROM A SET OF TERMINATORS IS ENCOUNTERED. + !< + !< IF A TERMINATOR IS ENCOUNTERED, THE FILE POSITION WILL BE AT THAT TERMINATING CHARACTER. IF END OF RECORD IS ENCOUNTERED, THE + !< FILE REMAINS AT END OF RECORD. + CLASS(STRING), INTENT(INOUT) :: DTV !< THE STRING. + INTEGER, INTENT(IN) :: UNIT !< LOGICAL UNIT. + CHARACTER(KIND=CK, LEN=*), INTENT(IN) :: TERMINATORS !< CHARACTERS THAT ARE CONSIDERED TO TERMINATE THE STRING. + !< BLANKS IN THIS STRING ARE MEANINGFUL. + INTEGER, INTENT(OUT) :: IOSTAT !< IO STATUS CODE. + CHARACTER(LEN=*), INTENT(INOUT) :: IOMSG !< IO STATUS MESSAGE. + CHARACTER(KIND=CK, LEN=1) :: CH !< A CHARACTER READ. + + DTV%RAW = '' + DO + READ(UNIT, "(A)", IOSTAT=IOSTAT, IOMSG=IOMSG) CH + IF (IS_IOSTAT_EOR(IOSTAT)) THEN + ! END OF RECORD JUST MEANS END OF STRING. WE PASS ON THE CONDITION + RETURN + ELSEIF (IOSTAT /= 0) THEN + ! SOMETHING ODD HAPPENED + RETURN + ENDIF + IF (SCAN(CH, TERMINATORS) /= 0) THEN + ! CHANGE THE FILE POSITION SO THAT THE NEXT READ SEES THE TERMINATOR + READ(UNIT, "(TL1)", IOSTAT=IOSTAT, IOMSG=IOMSG) + IF (IOSTAT /= 0) RETURN + IOSTAT = 0 + RETURN + ENDIF + ! WE GOT A CHARACTER - APPEND IT + DTV%RAW = DTV%RAW // CH + ENDDO + ENDSUBROUTINE READ_UNDELIMITED + + SUBROUTINE WRITE_FORMATTED(DTV, UNIT, IOTYPE, V_LIST, IOSTAT, IOMSG) + !< FORMATTED OUTPUT. + CLASS(STRING), INTENT(IN) :: DTV !< THE STRING. + INTEGER, INTENT(IN) :: UNIT !< LOGICAL UNIT. + CHARACTER(KIND=CK, LEN=*), INTENT(IN) :: IOTYPE !< EDIT DESCRIPTOR. + INTEGER, INTENT(IN) :: V_LIST(:) !< EDIT DESCRIPTOR LIST. + INTEGER, INTENT(OUT) :: IOSTAT !< IO STATUS CODE. + CHARACTER(KIND=CK, LEN=*), INTENT(INOUT) :: IOMSG !< IO STATUS MESSAGE. + + IF (ALLOCATED(DTV%RAW)) THEN + WRITE(UNIT, "(A)", IOSTAT=IOSTAT, IOMSG=IOMSG)DTV%RAW + ELSE + WRITE(UNIT, "(A)", IOSTAT=IOSTAT, IOMSG=IOMSG)'' + ENDIF + ENDSUBROUTINE WRITE_FORMATTED + + SUBROUTINE READ_UNFORMATTED(DTV, UNIT, IOSTAT, IOMSG) + !< UNFORMATTED INPUT. + !< + !< @BUG CHANGE TEMPORARY ACKS: FIND A MORE PRECISE LENGTH OF THE INPUT STRING AND AVOID THE TRIMMING! + CLASS(STRING), INTENT(INOUT) :: DTV !< THE STRING. + INTEGER, INTENT(IN) :: UNIT !< LOGICAL UNIT. + INTEGER, INTENT(OUT) :: IOSTAT !< IO STATUS CODE. + CHARACTER(KIND=CK, LEN=*), INTENT(INOUT) :: IOMSG !< IO STATUS MESSAGE. + CHARACTER(KIND=CK, LEN=100) :: TEMPORARY !< TEMPORARY STORAGE STRING. + + READ(UNIT, IOSTAT=IOSTAT, IOMSG=IOMSG)TEMPORARY + DTV%RAW = TRIM(TEMPORARY) + ENDSUBROUTINE READ_UNFORMATTED + + SUBROUTINE WRITE_UNFORMATTED(DTV, UNIT, IOSTAT, IOMSG) + !< UNFORMATTED OUTPUT. + CLASS(STRING), INTENT(IN) :: DTV !< THE STRING. + INTEGER, INTENT(IN) :: UNIT !< LOGICAL UNIT. + INTEGER, INTENT(OUT) :: IOSTAT !< IO STATUS CODE. + CHARACTER(KIND=CK, LEN=*), INTENT(INOUT) :: IOMSG !< IO STATUS MESSAGE. + + IF (ALLOCATED(DTV%RAW)) THEN + WRITE(UNIT, IOSTAT=IOSTAT, IOMSG=IOMSG)DTV%RAW + ELSE + WRITE(UNIT, IOSTAT=IOSTAT, IOMSG=IOMSG)'' + ENDIF + ENDSUBROUTINE WRITE_UNFORMATTED + + ! MISCELLANEA + ELEMENTAL FUNCTION REPLACE_ONE_OCCURRENCE(SELF, OLD, NEW) RESULT(REPLACED) + !< RETURN A STRING WITH THE FIRST OCCURRENCE OF SUBSTRING OLD REPLACED BY NEW. + !< + !< @NOTE THE DOCTEST IS NOT NECESSARY, THIS BEING TESTED BY [[STRING:REPLACE]]. + CLASS(STRING), INTENT(IN) :: SELF !< THE STRING. + CHARACTER(KIND=CK, LEN=*), INTENT(IN) :: OLD !< OLD SUBSTRING. + CHARACTER(KIND=CK, LEN=*), INTENT(IN) :: NEW !< NEW SUBSTRING. + TYPE(STRING) :: REPLACED !< THE STRING WITH OLD REPLACED BY NEW. + INTEGER :: POS !< POSITION FROM WHICH REPLACE OLD. + + IF (ALLOCATED(SELF%RAW)) THEN + REPLACED = SELF + POS = INDEX(STRING=SELF%RAW, SUBSTRING=OLD) + IF (POS>0) THEN + IF (POS==1) THEN + REPLACED%RAW = NEW//SELF%RAW(LEN(OLD)+1:) + ELSE + REPLACED%RAW = SELF%RAW(1:POS-1)//NEW//SELF%RAW(POS+LEN(OLD):) + ENDIF + ENDIF + ENDIF + ENDFUNCTION REPLACE_ONE_OCCURRENCE + + ! NON TYPE-BOUND-PROCEDURES + SUBROUTINE GET_DELIMITER_MODE(UNIT, DELIM, IOSTAT, IOMSG) + !< GET THE DELIM CHANGEABLE CONNECTION MODE FOR THE GIVEN UNIT. + !< + !< IF THE UNIT IS CONNECTED TO AN INTERNAL FILE, THEN THE DEFAULT VALUE OF NONE IS ALWAYS RETURNED. + USE, INTRINSIC :: ISO_FORTRAN_ENV, ONLY : IOSTAT_INQUIRE_INTERNAL_UNIT + INTEGER, INTENT(IN) :: UNIT !< THE UNIT FOR THE CONNECTION. + CHARACTER(LEN=1, KIND=CK), INTENT(OUT) :: DELIM !< REPRESENTS THE VALUE OF THE DELIM MODE. + INTEGER, INTENT(OUT) :: IOSTAT !< IOSTAT ERROR CODE, NON-ZERO ON ERROR. + CHARACTER(*), INTENT(INOUT) :: IOMSG !< IOMSG EXPLANATORY MESSAGE - ONLY DEFINED IF IOSTAT IS NON-ZERO. + CHARACTER(10) :: DELIM_BUFFER !< BUFFER FOR INQUIRE ABOUT DELIM, SIZED FOR APOSTROHPE. + CHARACTER(LEN(IOMSG)) :: LOCAL_IOMSG !< LOCAL VARIANT OF IOMSG, SO IT DOESN'T GET INAPPROPRIATELY REDEFINED. + + ! GET THE STRING REPRESENTATION OF THE CHANGEABLE MODE + INQUIRE(UNIT, DELIM=DELIM_BUFFER, IOSTAT=IOSTAT, IOMSG=LOCAL_IOMSG) + IF (IOSTAT == IOSTAT_INQUIRE_INTERNAL_UNIT) THEN + ! NO WAY OF DETERMINING THE DELIM MODE FOR AN INTERNAL FILE + IOSTAT = 0 + DELIM = '' + RETURN + ELSEIF (IOSTAT /= 0) THEN + IOMSG = LOCAL_IOMSG + RETURN + ENDIF + ! INTERPRET THE DELIM STRING + IF (DELIM_BUFFER == 'QUOTE') THEN + DELIM = '"' + ELSEIF (DELIM_BUFFER == 'APOSTROPHE') THEN + DELIM = '''' + ELSE + DELIM = '"' + ENDIF + ENDSUBROUTINE GET_DELIMITER_MODE + + SUBROUTINE GET_NEXT_NON_BLANK_CHARACTER_THIS_RECORD(UNIT, CH, IOSTAT, IOMSG) + !< GET THE NEXT NON-BLANK CHARACTER IN THE CURRENT RECORD. + INTEGER, INTENT(IN) :: UNIT !< LOGICAL UNIT. + CHARACTER(KIND=CK, LEN=1), INTENT(OUT) :: CH !< THE NON-BLANK CHARACTER READ. NOT VALID IF IOSTAT IS NON-ZERO. + INTEGER, INTENT(OUT) :: IOSTAT !< IO STATUS CODE. + CHARACTER(KIND=CK, LEN=*), INTENT(INOUT) :: IOMSG !< IO STATUS MESSAGE. + + DO + ! WE SPCIFY NON-ADVANCING, JUST IN CASE WE WANT THIS CALLABLE OUTSIDE THE CONTEXT OF A CHILD INPUT STATEMENT + ! THE PAD SPECIFIER SIMPLY SAVES THE NEED FOR THE READ STATEMENT TO DEFINE CH IF EOR IS HIT + ! READ(UNIT, "(A)", IOSTAT=IOSTAT, IOMSG=IOMSG, ADVANCE='NO') CH + ! ...BUT THAT CAUSES IFORT TO BLOW UP AT RUNTIME + READ(UNIT, "(A)", IOSTAT=IOSTAT, IOMSG=IOMSG, PAD='NO') CH + IF (IOSTAT /= 0) RETURN + IF (CH /= '') EXIT + ENDDO + ENDSUBROUTINE GET_NEXT_NON_BLANK_CHARACTER_THIS_RECORD + + SUBROUTINE GET_NEXT_NON_BLANK_CHARACTER_ANY_RECORD(UNIT, CH, IOSTAT, IOMSG) + !< GET THE NEXT NON-BLANK CHARACTER, ADVANCING RECORDS IF NECESSARY. + INTEGER, INTENT(IN) :: UNIT !< LOGICAL UNIT. + CHARACTER(KIND=CK, LEN=1), INTENT(OUT) :: CH !< THE NON-BLANK CHARACTER READ. NOT VALID IF IOSTAT IS NON-ZERO. + INTEGER, INTENT(OUT) :: IOSTAT !< IO STATUS CODE. + CHARACTER(KIND=CK, LEN=*), INTENT(INOUT) :: IOMSG !< IO STATUS MESSAGE. + CHARACTER(LEN(IOMSG)) :: LOCAL_IOMSG !< LOCAL VARIANT OF IOMSG, SO IT DOESN'T GET INAPPROPRIATELY REDEFINED. + + DO + CALL GET_NEXT_NON_BLANK_CHARACTER_THIS_RECORD(UNIT=UNIT, CH=CH, IOSTAT=IOSTAT, IOMSG=LOCAL_IOMSG) + IF (IS_IOSTAT_EOR(IOSTAT)) THEN + ! TRY AGAIN ON THE NEXT RECORD + READ (UNIT, "(/)", IOSTAT=IOSTAT, IOMSG=IOMSG) + IF (IOSTAT /= 0) RETURN + ELSEIF (IOSTAT /= 0) THEN + ! SOME SORT OF PROBLEM + IOMSG = LOCAL_IOMSG + RETURN + ELSE + ! GOT IT + EXIT + ENDIF + ENDDO + ENDSUBROUTINE GET_NEXT_NON_BLANK_CHARACTER_ANY_RECORD + + SUBROUTINE GET_DECIMAL_MODE(UNIT, DECIMAL_POINT, IOSTAT, IOMSG) + !< GET THE DECIMAL CHANGEABLE CONNECTION MODE FOR THE GIVEN UNIT. + !< + !< IF THE UNIT IS CONNECTED TO AN INTERNAL FILE, THEN THE DEFAULT VALUE OF DECIMAL IS ALWAYS RETURNED. THIS MAY NOT BE THE + !< ACTUAL VALUE IN FORCE AT THE TIME OF THE CALL TO THIS PROCEDURE. + USE, INTRINSIC :: ISO_FORTRAN_ENV, ONLY : IOSTAT_INQUIRE_INTERNAL_UNIT + INTEGER, INTENT(IN) :: UNIT !< LOGICAL UNIT. + LOGICAL, INTENT(OUT) :: DECIMAL_POINT !< TRUE IF THE DECIMAL MODE IS POINT, FALSE OTHERWISE. + INTEGER, INTENT(OUT) :: IOSTAT !< IO STATUS CODE. + CHARACTER(KIND=CK, LEN=*), INTENT(INOUT) :: IOMSG !< IO STATUS MESSAGE. + CHARACTER(5) :: DECIMAL_BUFFER !< BUFFER FOR INQUIRE ABOUT DECIMAL, SIZED FOR POINT OR COMMA. + CHARACTER(LEN(IOMSG)) :: LOCAL_IOMSG !< LOCAL IOMSG, SO IT DOESN'T GET INAPPROPRIATELY REDEFINED. + + INQUIRE(UNIT, DECIMAL=DECIMAL_BUFFER, IOSTAT=IOSTAT, IOMSG=LOCAL_IOMSG) + IF (IOSTAT == IOSTAT_INQUIRE_INTERNAL_UNIT) THEN + ! NO WAY OF DETERMINING THE DECIMAL MODE FOR AN INTERNAL FILE + IOSTAT = 0 + DECIMAL_POINT = .TRUE. + RETURN + ELSE IF (IOSTAT /= 0) THEN + IOMSG = LOCAL_IOMSG + RETURN + ENDIF + DECIMAL_POINT = DECIMAL_BUFFER == 'POINT' + ENDSUBROUTINE GET_DECIMAL_MODE +ENDMODULE STRINGIFOR_STRING_T + + + + +!< STRINGIFOR, STRINGS FORTRAN MANIPULATOR WITH STEROIDS. + +MODULE STRINGIFOR +!< STRINGIFOR, STRINGS FORTRAN MANIPULATOR WITH STEROIDS. +USE PENF, ONLY : I1P, I2P, I4P, I8P, R4P, R8P, R16P +! USE STRINGIFOR_STRING_T, ONLY : ADJUSTL, ADJUSTR, COUNT, INDEX, LEN, LEN_TRIM, REPEAT, SCAN, TRIM, VERIFY, CK, STRING +USE STRINGIFOR_STRING_T, ONLY : ADJUSTL, ADJUSTR, COUNT, INDEX, LEN_TRIM, REPEAT, SCAN, TRIM, VERIFY, CK, GLOB, STRING, STRJOIN + +IMPLICIT NONE +PRIVATE +SAVE +! EXPOSE STINGIFOR OBJECTS +PUBLIC :: CK +PUBLIC :: GLOB +PUBLIC :: STRJOIN +PUBLIC :: STRING +! EXPOSE STINGIFOR OVERLOADED BUILTINS AND OPERATORS +! PUBLIC :: ADJUSTL, ADJUSTR, COUNT, INDEX, LEN, LEN_TRIM, REPEAT, SCAN, TRIM, VERIFY +PUBLIC :: ADJUSTL, ADJUSTR, COUNT, INDEX, LEN_TRIM, REPEAT, SCAN, TRIM, VERIFY +! EXPOSE STINGIFOR NEW PROCEDURES +PUBLIC :: READ_FILE, READ_LINES, WRITE_FILE, WRITE_LINES +! EXPOSE PENF KINDS +PUBLIC :: I1P, I2P, I4P, I8P, R4P, R8P, R16P + +CONTAINS + SUBROUTINE READ_FILE(FILE, LINES, FORM, IOSTAT, IOMSG) + !< READ A FILE AS A SINGLE STRING STREAM. + !< + !< THE LINES ARE RETURNED AS AN ARRAY OF STRINGS THAT ARE READ UNTIL THE EOF IS REACHED. + !< THE LINE IS READ AS AN ASCII STREAM READ UNTIL THE EOR IS REACHED. + !< + !< @NOTE FOR UNFORMATTED READ ONLY `ACCESS='STREAM'` IS SUPPORTED WITH NEW_LINE AS LINE TERMINATOR. + !< + !<```FORTRAN + !< TYPE(STRING) :: ASTRING + !< TYPE(STRING), ALLOCATABLE :: STRINGS(:) + !< TYPE(STRING) :: LINE(3) + !< INTEGER :: IOSTAT + !< CHARACTER(LEN=99) :: IOMSG + !< INTEGER :: SCRATCH + !< INTEGER :: L + !< LOGICAL :: TEST_PASSED(8) + !< LINE(1) = ' HELLO WORLD! ' + !< LINE(2) = 'HOW ARE YOU? ' + !< LINE(3) = ' ALL SAY: "FINE THANKS"' + !< OPEN(NEWUNIT=SCRATCH, FILE='READ_FILE_TEST.TMP') + !< WRITE(SCRATCH, "(A)") LINE(1)%CHARS() + !< WRITE(SCRATCH, "(A)") LINE(2)%CHARS() + !< WRITE(SCRATCH, "(A)") LINE(3)%CHARS() + !< CLOSE(SCRATCH) + !< CALL READ_FILE(FILE='READ_FILE_TEST.TMP', LINES=STRINGS, IOSTAT=IOSTAT, IOMSG=IOMSG) + !< TEST_PASSED(1) = (SIZE(STRINGS, DIM=1)==SIZE(LINE, DIM=1)) + !< DO L=1, SIZE(STRINGS, DIM=1) + !< TEST_PASSED(L+1) = (STRINGS(L)==LINE(L)) + !< ENDDO + !< OPEN(NEWUNIT=SCRATCH, FILE='READ_FILE_TEST.TMP', FORM='UNFORMATTED', ACCESS='STREAM') + !< WRITE(SCRATCH) LINE(1)%CHARS()//NEW_LINE('A') + !< WRITE(SCRATCH) LINE(2)%CHARS()//NEW_LINE('A') + !< WRITE(SCRATCH) LINE(3)%CHARS()//NEW_LINE('A') + !< CLOSE(SCRATCH) + !< CALL READ_FILE(FILE='READ_FILE_TEST.TMP', LINES=STRINGS, FORM='UNFORMATTED', IOSTAT=IOSTAT, IOMSG=IOMSG) + !< TEST_PASSED(5) = (SIZE(STRINGS, DIM=1)==SIZE(LINE, DIM=1)) + !< DO L=1, SIZE(STRINGS, DIM=1) + !< TEST_PASSED(L+5) = (STRINGS(L)==LINE(L)) + !< ENDDO + !< OPEN(NEWUNIT=SCRATCH, FILE='READ_FILE_TEST.TMP', FORM='UNFORMATTED', ACCESS='STREAM') + !< CLOSE(SCRATCH, STATUS='DELETE') + !< PRINT '(L1)', ALL(TEST_PASSED) + !<``` + !=> T <<< + CHARACTER(LEN=*), INTENT(IN) :: FILE !< FILE NAME. + TYPE(STRING), INTENT(OUT), ALLOCATABLE :: LINES(:) !< THE LINES. + CHARACTER(LEN=*), INTENT(IN), OPTIONAL :: FORM !< FORMAT OF UNIT. + INTEGER, INTENT(OUT), OPTIONAL :: IOSTAT !< IO STATUS CODE. + CHARACTER(LEN=*), INTENT(INOUT), OPTIONAL :: IOMSG !< IO STATUS MESSAGE. + TYPE(STRING) :: FORM_ !< FORMAT OF UNIT, LOCAL VARIABLE. + INTEGER :: IOSTAT_ !< IO STATUS CODE, LOCAL VARIABLE. + CHARACTER(LEN=:), ALLOCATABLE :: IOMSG_ !< IO STATUS MESSAGE, LOCAL VARIABLE. + INTEGER :: UNIT !< LOGICAL UNIT. + LOGICAL :: DOES_EXIST !< CHECK IF FILE EXIST. + + IOMSG_ = REPEAT(' ', 99) ; IF (PRESENT(IOMSG)) IOMSG_ = IOMSG + INQUIRE(FILE=FILE, IOMSG=IOMSG_, IOSTAT=IOSTAT_, EXIST=DOES_EXIST) + IF (DOES_EXIST) THEN + FORM_ = 'FORMATTED' ; IF (PRESENT(FORM)) FORM_ = FORM ; FORM_ = FORM_%UPPER() + SELECT CASE(FORM_%CHARS()) + CASE('FORMATTED') + OPEN(NEWUNIT=UNIT, FILE=FILE, STATUS='OLD', ACTION='READ', IOMSG=IOMSG_, IOSTAT=IOSTAT_, ERR=10) + CASE('UNFORMATTED') + OPEN(NEWUNIT=UNIT, FILE=FILE, STATUS='OLD', ACTION='READ', FORM='UNFORMATTED', ACCESS='STREAM', & + IOMSG=IOMSG_, IOSTAT=IOSTAT_, ERR=10) + ENDSELECT + CALL READ_LINES(UNIT=UNIT, LINES=LINES, FORM=FORM, IOMSG=IOMSG_, IOSTAT=IOSTAT_) + 10 CLOSE(UNIT) + ENDIF + IF (PRESENT(IOSTAT)) IOSTAT = IOSTAT_ + IF (PRESENT(IOMSG)) IOMSG = IOMSG_ + ENDSUBROUTINE READ_FILE + + SUBROUTINE READ_LINES(UNIT, LINES, FORM, IOSTAT, IOMSG) + !< READ LINES (RECORDS) FROM A CONNECTED-FORMATTED UNIT. + !< + !< @NOTE THE CONNECTED UNIT IS REWINDED. AT A SUCCESSFUL EXIT CURRENT RECORD IS AT EOF, AT THE BEGINNING OTHERWISE. + !< + !< THE LINES ARE RETURNED AS AN ARRAY OF STRINGS THAT ARE READ UNTIL THE EOF IS REACHED. + !< THE LINE IS READ AS AN ASCII STREAM READ UNTIL THE EOR IS REACHED. + !< + !< @NOTE FOR UNFORMATTED READ ONLY `ACCESS='STREAM'` IS SUPPORTED WITH NEW_LINE AS LINE TERMINATOR. + !< + !< @NOTE THERE IS NO DOCTESTS, THIS BEING TESTED BY MEANS OF [[READ_FILE]] DOCTESTS. + INTEGER, INTENT(IN) :: UNIT !< LOGICAL UNIT. + TYPE(STRING), INTENT(OUT), ALLOCATABLE :: LINES(:) !< THE LINES. + CHARACTER(LEN=*), INTENT(IN), OPTIONAL :: FORM !< FORMAT OF UNIT. + INTEGER, INTENT(OUT), OPTIONAL :: IOSTAT !< IO STATUS CODE. + CHARACTER(LEN=*), INTENT(INOUT), OPTIONAL :: IOMSG !< IO STATUS MESSAGE. + TYPE(STRING) :: FORM_ !< FORMAT OF UNIT, LOCAL VARIABLE. + INTEGER :: IOSTAT_ !< IO STATUS CODE, LOCAL VARIABLE. + CHARACTER(LEN=:), ALLOCATABLE :: IOMSG_ !< IO STATUS MESSAGE, LOCAL VARIABLE. + CHARACTER(KIND=CK, LEN=1) :: CH !< CHARACTER STORAGE. + INTEGER :: L !< COUNTER. + + FORM_ = 'FORMATTED' ; IF (PRESENT(FORM)) FORM_ = FORM ; FORM_ = FORM_%UPPER() + IOMSG_ = REPEAT(' ', 99) ; IF (PRESENT(IOMSG)) IOMSG_ = IOMSG + REWIND(UNIT) + SELECT CASE(FORM_%CHARS()) + CASE('FORMATTED') + L = 0 + DO + READ(UNIT, *, ERR=10, END=10) + L = L + 1 + ENDDO + CASE('UNFORMATTED') + L = 0 + DO + READ(UNIT, ERR=10, END=10) CH + IF (CH==NEW_LINE('A')) L = L + 1 + ENDDO + ENDSELECT + 10 REWIND(UNIT) + IF (L>0) THEN + ALLOCATE(LINES(1:L)) + L = 1 + IOSTAT_ = 0 + DO + CALL LINES(L)%READ_LINE(UNIT=UNIT, FORM=FORM, IOSTAT=IOSTAT_, IOMSG=IOMSG_) + IF ((IOSTAT_/=0.AND..NOT.IS_IOSTAT_EOR(IOSTAT_)).OR.(L>=SIZE(LINES, DIM=1))) THEN + EXIT + ENDIF + L = L + 1 + ENDDO + ENDIF + IF (PRESENT(IOSTAT)) IOSTAT = IOSTAT_ + IF (PRESENT(IOMSG)) IOMSG = IOMSG_ + ENDSUBROUTINE READ_LINES + + SUBROUTINE WRITE_FILE(FILE, LINES, FORM, IOSTAT, IOMSG) + !< WRITE A SINGLE STRING STREAM INTO FILE. + !< + !< @NOTE FOR UNFORMATTED READ ONLY `ACCESS='STREAM'` IS SUPPORTED WITH NEW_LINE AS LINE TERMINATOR. + !< + !<```FORTRAN + !< TYPE(STRING) :: ASTRING + !< TYPE(STRING) :: ANOTHERSTRING + !< TYPE(STRING), ALLOCATABLE :: STRINGS(:) + !< TYPE(STRING) :: LINE(3) + !< INTEGER :: IOSTAT + !< CHARACTER(LEN=99) :: IOMSG + !< INTEGER :: SCRATCH + !< INTEGER :: L + !< LOGICAL :: TEST_PASSED(8) + !< LINE(1) = ' HELLO WORLD! ' + !< LINE(2) = 'HOW ARE YOU? ' + !< LINE(3) = ' ALL SAY: "FINE THANKS"' + !< ANOTHERSTRING = ANOTHERSTRING%JOIN(ARRAY=LINE, SEP=NEW_LINE('A')) + !< CALL WRITE_FILE(FILE='WRITE_FILE_TEST.TMP', LINES=LINE, IOSTAT=IOSTAT, IOMSG=IOMSG) + !< CALL ASTRING%READ_FILE(FILE='WRITE_FILE_TEST.TMP', IOSTAT=IOSTAT, IOMSG=IOMSG) + !< CALL ASTRING%SPLIT(TOKENS=STRINGS, SEP=NEW_LINE('A')) + !< TEST_PASSED(1) = (SIZE(STRINGS, DIM=1)==SIZE(LINE, DIM=1)) + !< DO L=1, SIZE(STRINGS, DIM=1) + !< TEST_PASSED(L+1) = (STRINGS(L)==LINE(L)) + !< ENDDO + !< CALL WRITE_FILE(FILE='WRITE_FILE_TEST.TMP', LINES=LINE, FORM='UNFORMATTED', IOSTAT=IOSTAT, IOMSG=IOMSG) + !< CALL ASTRING%READ_FILE(FILE='WRITE_FILE_TEST.TMP', FORM='UNFORMATTED', IOSTAT=IOSTAT, IOMSG=IOMSG) + !< CALL ASTRING%SPLIT(TOKENS=STRINGS, SEP=NEW_LINE('A')) + !< TEST_PASSED(5) = (SIZE(STRINGS, DIM=1)==SIZE(LINE, DIM=1)) + !< DO L=1, SIZE(STRINGS, DIM=1) + !< TEST_PASSED(L+5) = (STRINGS(L)==LINE(L)) + !< ENDDO + !< OPEN(NEWUNIT=SCRATCH, FILE='WRITE_FILE_TEST.TMP') + !< CLOSE(SCRATCH, STATUS='DELETE') + !< PRINT '(L1)', ALL(TEST_PASSED) + !<``` + !=> T <<< + CHARACTER(LEN=*), INTENT(IN) :: FILE !< FILE NAME. + TYPE(STRING), INTENT(IN) :: LINES(1:) !< THE LINES. + CHARACTER(LEN=*), INTENT(IN), OPTIONAL :: FORM !< FORMAT OF UNIT. + INTEGER, INTENT(OUT), OPTIONAL :: IOSTAT !< IO STATUS CODE. + CHARACTER(LEN=*), INTENT(INOUT), OPTIONAL :: IOMSG !< IO STATUS MESSAGE. + TYPE(STRING) :: FORM_ !< FORMAT OF UNIT, LOCAL VARIABLE. + INTEGER :: IOSTAT_ !< IO STATUS CODE, LOCAL VARIABLE. + CHARACTER(LEN=:), ALLOCATABLE :: IOMSG_ !< IO STATUS MESSAGE, LOCAL VARIABLE. + INTEGER :: UNIT !< LOGICAL UNIT. + + IOMSG_ = REPEAT(' ', 99) ; IF (PRESENT(IOMSG)) IOMSG_ = IOMSG + FORM_ = 'FORMATTED' ; IF (PRESENT(FORM)) FORM_ = FORM ; FORM_ = FORM_%UPPER() + SELECT CASE(FORM_%CHARS()) + CASE('FORMATTED') + OPEN(NEWUNIT=UNIT, FILE=FILE, ACTION='WRITE', IOMSG=IOMSG_, IOSTAT=IOSTAT_, ERR=10) + CASE('UNFORMATTED') + OPEN(NEWUNIT=UNIT, FILE=FILE, ACTION='WRITE', FORM='UNFORMATTED', ACCESS='STREAM', IOMSG=IOMSG_, IOSTAT=IOSTAT_, ERR=10) + ENDSELECT + CALL WRITE_LINES(UNIT=UNIT, LINES=LINES, FORM=FORM, IOMSG=IOMSG_, IOSTAT=IOSTAT_) + 10 CLOSE(UNIT) + IF (PRESENT(IOSTAT)) IOSTAT = IOSTAT_ + IF (PRESENT(IOMSG)) IOMSG = IOMSG_ + ENDSUBROUTINE WRITE_FILE + + SUBROUTINE WRITE_LINES(UNIT, LINES, FORM, IOSTAT, IOMSG) + !< WRITE LINES (RECORDS) TO A CONNECTED-FORMATTED UNIT. + !< + !< @NOTE THERE IS NO DOCTESTS, THIS BEING TESTED BY MEANS OF [[WRITE_FILE]] DOCTESTS. + INTEGER, INTENT(IN) :: UNIT !< LOGICAL UNIT. + TYPE(STRING), INTENT(IN) :: LINES(1:) !< THE LINES. + CHARACTER(LEN=*), INTENT(IN), OPTIONAL :: FORM !< FORMAT OF UNIT. + INTEGER, INTENT(OUT), OPTIONAL :: IOSTAT !< IO STATUS CODE. + CHARACTER(LEN=*), INTENT(INOUT), OPTIONAL :: IOMSG !< IO STATUS MESSAGE. + INTEGER :: L !< COUNTER. + + DO L=1, SIZE(LINES, DIM=1) + CALL LINES(L)%WRITE_LINE(UNIT=UNIT, FORM=FORM, IOSTAT=IOSTAT, IOMSG=IOMSG) + ENDDO + ENDSUBROUTINE WRITE_LINES +ENDMODULE STRINGIFOR + + + + + +!< FOXY XML TAG CLASS. +MODULE FOXY_XML_TAG +!< FOXY XML TAG CLASS. +USE PENF +USE STRINGIFOR + +IMPLICIT NONE +PRIVATE +PUBLIC :: XML_TAG + +TYPE :: XML_TAG + !< XML TAG CLASS. + !< + !< A VALID XML TAG MUST HAVE THE FOLLOWING SYNTAX FOR A TAG WITHOUT A CONTENT (WITH ONLY ATTRIBUTES): + !<```XML + !< <TAG_NAME ATT#1_NAME="ATT#1_VAL" ATT#2_NAME="ATT#2_VAL"... ATT#NT_NAME="ATT#NT_VAL"/> + !<``` + !< WHILE A TAG WITH A CONTENT MUST HAVE THE FOLLOWING SYNTAX: + !<```XML + !< <TAG_NAME ATT#1_NAME="ATT#1_VAL" ATT#2_NAME="ATT#2_VAL"... ATT#NT_NAME="ATT#NT_VAL">TAG_CONTENT</TAG_NAME> + !<``` + !< + !< IT IS WORTH NOTING THAT THE SYNTAX IS CASE SENSITIVE AND THAT THE ATTRIBUTES ARE OPTIONAL. EACH ATTRIBUTE NAME MUST BE FOLLOWED + !< BY '="' WITHOUT ANY ADDITIONAL WHITE SPACES AND ITS VALUE MUST BE TERMINED BY '"'. EACH ATTRIBUTE IS SEPARATED BY ONE OR MORE + !< WHITE SPACES. + PRIVATE + TYPE(STRING) :: TAG_NAME !< TAG NAME. + TYPE(STRING) :: TAG_CONTENT !< TAG CONTENT. + TYPE(STRING), ALLOCATABLE :: ATTRIBUTE(:,:) !< ATTRIBUTES NAMES/VALUES PAIRS, [1:2, 1:]. + INTEGER(I4P) :: ATTRIBUTES_NUMBER=0 !< NUMBER OF DEFINED ATTRIBUTES. + INTEGER(I4P) :: INDENT=0 !< NUMBER OF INDENT-WHITE-SPACES. + LOGICAL :: IS_SELF_CLOSING=.FALSE. !< SELF CLOSING TAG FLAG. + CONTAINS + ! PUBLIC METHODS + GENERIC :: ADD_ATTRIBUTES => & + ADD_SINGLE_ATTRIBUTE, & + ADD_MULTIPLE_ATTRIBUTES, & + ADD_STREAM_ATTRIBUTES !< ADD ATTRIBUTES NAME/VALUE PAIRS. + PROCEDURE, PASS(SELF) :: ATTRIBUTES !< RETURN ATTRIBUTES NAME/VALUE PAIRS AS STRING. + PROCEDURE, PASS(SELF) :: GET_CONTENT !< RETURN TAG CONTENT. + GENERIC :: DELETE_ATTRIBUTES => & + DELETE_SINGLE_ATTRIBUTE, & + DELETE_MULTIPLE_ATTRIBUTES !< DELETE ATTRIBUTES NAME/VALUE PAIRS. + PROCEDURE, PASS(SELF) :: DELETE_CONTENT !< DELETE TAG CONENT. + PROCEDURE, PASS(SELF) :: END_TAG !< RETURN `</TAG_NAME>` END TAG. + PROCEDURE, PASS(SELF) :: FREE !< FREE DYNAMIC MEMORY. + PROCEDURE, PASS(SELF) :: IS_ATTRIBUTE_PRESENT !< RETURN .TRUE. IT THE QUERIED ATTRIBUTE NAME IS DEFINED. + PROCEDURE, PASS(SELF) :: IS_PARSED !< CHECK IS TAG IS CORRECTLY PARSED, I.E. ITS *TAG_NAME* IS ALLOCATED. + PROCEDURE, PASS(SELF) :: NAME !< RETURN TAG NAME. + PROCEDURE, PASS(SELF) :: PARSE !< PARSE THE TAG CONTAINED INTO A SOURCE STRING. + PROCEDURE, PASS(SELF) :: SELF_CLOSING_TAG !< RETURN `<TAG_NAME.../>` SELF CLOSING TAG. + PROCEDURE, PASS(SELF) :: SET !< SET TAG DATA. + PROCEDURE, PASS(SELF) :: START_TAG !< RETURN `<TAG_NAME...>` START TAG. + PROCEDURE, PASS(SELF) :: STRINGIFY !< CONVERT THE WHOLE TAG INTO A STRING. + PROCEDURE, PASS(SELF) :: WRITE => WRITE_TAG !< WRITE TAG TO UNIT FILE. + GENERIC :: ASSIGNMENT(=) => ASSIGN_TAG !< ASSIGNMENT OPERATOR OVERLOADING. + ! PRIVATE METHODS + PROCEDURE, PASS(SELF), PRIVATE :: ADD_SINGLE_ATTRIBUTE !< ADD ONE ATTRIBUTE NAME/VALUE PAIR. + PROCEDURE, PASS(SELF), PRIVATE :: ADD_MULTIPLE_ATTRIBUTES !< ADD LIST OF ATTRIBUTES NAME/VALUE PAIRS. + PROCEDURE, PASS(SELF), PRIVATE :: ADD_STREAM_ATTRIBUTES !< ADD LIST OF ATTRIBUTES NAME/VALUE PAIRS PASSED AS STREAM. + PROCEDURE, PASS(SELF), PRIVATE :: ALLOC_ATTRIBUTES !< ALLOCATE (PREPARE FOR FILLING) DYNAMIC MEMORY OF ATTRIBUTES. + PROCEDURE, PASS(SELF), PRIVATE :: DELETE_SINGLE_ATTRIBUTE !< DELETE ONE ATTRIBUTE NAME/VALUE PAIR. + PROCEDURE, PASS(SELF), PRIVATE :: DELETE_MULTIPLE_ATTRIBUTES !< DELETE LIST OF ATTRIBUTES NAME/VALUE PAIRS. + PROCEDURE, PASS(SELF), PRIVATE :: GET !< GET THE TAG VALUE AND ATTRIBUTES FROM SOURCE. + PROCEDURE, PASS(SELF), PRIVATE :: GET_VALUE !< GET THE TAG VALUE FROM SOURCE AFTER TAG_NAME HAS BEEN SET. + PROCEDURE, PASS(SELF), PRIVATE :: GET_ATTRIBUTES !< GET THE ATTRIBUTES VALUES FROM SOURCE. + PROCEDURE, PASS(SELF), PRIVATE :: PARSE_TAG_NAME !< PARSE THE TAG NAME CONTAINED INTO A STRING. + PROCEDURE, PASS(SELF), PRIVATE :: PARSE_ATTRIBUTES_NAMES !< PARSE THE TAG ATTRIBUTES NAMES CONTAINED INTO A STRING. + PROCEDURE, PASS(SELF), PRIVATE :: SEARCH !< SEARCH TAG NAMED *TAG_NAME* INTO A STRING. + ! OPERATORS + PROCEDURE, PASS(LHS), PRIVATE :: ASSIGN_TAG !< ASSIGNMENT BETWEEN TWO TAGS. +#if (__GNUC__ < 9) + FINAL :: FINALIZE !< FREE DYNAMIC MEMORY WHEN FINALIZING. +#endif +ENDTYPE XML_TAG + +INTERFACE XML_TAG + !< OVERLOAD *XML_TAG* WITH CREATOR PROCEDURES. + MODULE PROCEDURE CREATE_TAG_FLAT, CREATE_TAG_NESTED +ENDINTERFACE +CONTAINS + ! CREATOR PROCEDURES OVERLOADING *XML_TAG* NAME + PURE FUNCTION CREATE_TAG_FLAT(NAME, ATTRIBUTE, ATTRIBUTES, ATTRIBUTES_STREAM, SANITIZE_ATTRIBUTES_VALUE, CONTENT, INDENT, & + IS_CONTENT_INDENTED, IS_SELF_CLOSING) RESULT(TAG) + !< RETURN AN INSTANCE OF XML TAG. + !< + !< ATTRIBUTES ARE PASSED BY ARRAY. + CHARACTER(*), INTENT(IN) :: NAME !< TAG NAME. + CHARACTER(*), INTENT(IN), OPTIONAL :: ATTRIBUTE(1:) !< ATTRIBUTE NAME/VALUE PAIR [1:2]. + CHARACTER(*), INTENT(IN), OPTIONAL :: ATTRIBUTES(1:,1:) !< ATTRIBUTES LIST OF NAME/VALUE PAIRS [1:2,1:]. + CHARACTER(*), INTENT(IN), OPTIONAL :: ATTRIBUTES_STREAM !< ATTRIBUTES LIST OF NAME/VALUE PAIRS AS SINGLE STREAM. + LOGICAL, INTENT(IN), OPTIONAL :: SANITIZE_ATTRIBUTES_VALUE !< SANITIZE ATTRIBUTES VALUE. + CHARACTER(*), INTENT(IN), OPTIONAL :: CONTENT !< TAG VALUE. + INTEGER(I4P), INTENT(IN), OPTIONAL :: INDENT !< NUMBER OF INDENT-WHITE-SPACES. + LOGICAL, INTENT(IN), OPTIONAL :: IS_CONTENT_INDENTED !< ACTIVATE CONTENT INDENTATION. + LOGICAL, INTENT(IN), OPTIONAL :: IS_SELF_CLOSING !< THE TAG IS SELF CLOSING. + TYPE(XML_TAG) :: TAG !< XML TAG. + + CALL TAG%SET(NAME=NAME, ATTRIBUTE=ATTRIBUTE, ATTRIBUTES=ATTRIBUTES, ATTRIBUTES_STREAM=ATTRIBUTES_STREAM, & + SANITIZE_ATTRIBUTES_VALUE=SANITIZE_ATTRIBUTES_VALUE, CONTENT=CONTENT, & + INDENT=INDENT, IS_CONTENT_INDENTED=IS_CONTENT_INDENTED, IS_SELF_CLOSING=IS_SELF_CLOSING) + ENDFUNCTION CREATE_TAG_FLAT + + PURE FUNCTION CREATE_TAG_NESTED(NAME, CONTENT, ATTRIBUTE, ATTRIBUTES, ATTRIBUTES_STREAM, SANITIZE_ATTRIBUTES_VALUE, INDENT, & + IS_CONTENT_INDENTED) RESULT(TAG) + !< RETURN AN INSTANCE OF XML TAG WITH VALUE BEING A NESTED TAG. + !< + !< ATTRIBUTES ARE PASSED BY ARRAY. + CHARACTER(*), INTENT(IN) :: NAME !< TAG NAME. + TYPE(XML_TAG), INTENT(IN) :: CONTENT !< TAG VALUE AS NESTED TAG.. + CHARACTER(*), INTENT(IN), OPTIONAL :: ATTRIBUTE(1:) !< ATTRIBUTE NAME/VALUE PAIR [1:2]. + CHARACTER(*), INTENT(IN), OPTIONAL :: ATTRIBUTES(1:,1:) !< ATTRIBUTES LIST OF NAME/VALUE PAIRS [1:2,1:]. + CHARACTER(*), INTENT(IN), OPTIONAL :: ATTRIBUTES_STREAM !< ATTRIBUTES LIST OF NAME/VALUE PAIRS AS SINGLE STREAM. + LOGICAL, INTENT(IN), OPTIONAL :: SANITIZE_ATTRIBUTES_VALUE !< SANITIZE ATTRIBUTES VALUE. + INTEGER(I4P), INTENT(IN), OPTIONAL :: INDENT !< NUMBER OF INDENT-WHITE-SPACES. + LOGICAL, INTENT(IN), OPTIONAL :: IS_CONTENT_INDENTED !< ACTIVATE VALUE INDENTATION. + TYPE(XML_TAG) :: TAG !< XML TAG. + + CALL TAG%SET(NAME=NAME, ATTRIBUTE=ATTRIBUTE, ATTRIBUTES=ATTRIBUTES, CONTENT=CONTENT%STRINGIFY(), & + SANITIZE_ATTRIBUTES_VALUE=SANITIZE_ATTRIBUTES_VALUE, ATTRIBUTES_STREAM=ATTRIBUTES_STREAM, INDENT=INDENT, & + IS_CONTENT_INDENTED=IS_CONTENT_INDENTED) + ENDFUNCTION CREATE_TAG_NESTED + + ! PUBLIC METHODS + PURE FUNCTION ATTRIBUTES(SELF) RESULT(ATT_) + !< RETURN ATTRIBUTES NAME/VALUE PAIRS AS STRING. + CLASS(XML_TAG), INTENT(IN) :: SELF !< XML TAG. + CHARACTER(LEN=:), ALLOCATABLE :: ATT_ !< THE ATTRIBUTES STRING. + INTEGER(I4P) :: A !< COUNTER. + + IF (SELF%ATTRIBUTES_NUMBER>0) THEN + ATT_ = '' + DO A=1, SELF%ATTRIBUTES_NUMBER + ATT_ = ATT_//' '//SELF%ATTRIBUTE(1, A)//'="'//SELF%ATTRIBUTE(2, A)//'"' + ENDDO + ATT_ = TRIM(ADJUSTL(ATT_)) + ENDIF + ENDFUNCTION ATTRIBUTES + + PURE SUBROUTINE GET_CONTENT(SELF, NAME, CONTENT) + !< RETURN TAG CONTENT OF SELF (OR ITS NESTED TAGS) IF NAMED *NAME*. + !< + !< @NOTE IF THERE IS NO VALUE, THE *CONTENT* STRING IS RETURNED DEALLOCATED. + CLASS(XML_TAG), INTENT(IN) :: SELF !< XML TAG. + CHARACTER(*), INTENT(IN) :: NAME !< SEARCHED TAG NAME. + CHARACTER(LEN=:), ALLOCATABLE, INTENT(OUT) :: CONTENT !< TAG CONTENT. + TYPE(XML_TAG) :: TAG !< DUMMY XML TAG. + + IF (ALLOCATED(CONTENT)) DEALLOCATE(CONTENT) + IF (SELF%TAG_NAME%IS_ALLOCATED()) THEN + IF (SELF%TAG_NAME==NAME) THEN + IF (SELF%TAG_CONTENT%IS_ALLOCATED()) CONTENT = SELF%TAG_CONTENT%CHARS() + ELSE + IF (SELF%TAG_CONTENT%IS_ALLOCATED()) THEN + CALL TAG%SEARCH(TAG_NAME=NAME, SOURCE=SELF%TAG_CONTENT%CHARS()) + IF (TAG%TAG_CONTENT%IS_ALLOCATED()) CONTENT = TAG%TAG_CONTENT%CHARS() + ENDIF + ENDIF + ENDIF + ENDSUBROUTINE GET_CONTENT + + PURE FUNCTION END_TAG(SELF, IS_INDENTED) RESULT(TAG_) + !< RETURN `</TAG_NAME>` END TAG. + CLASS(XML_TAG), INTENT(IN) :: SELF !< XML TAG. + LOGICAL, INTENT(IN), OPTIONAL :: IS_INDENTED !< ACTIVATE CONTENT INDENTATION. + CHARACTER(LEN=:), ALLOCATABLE :: TAG_ !< THE END TAG STRING. + + TAG_ = '</'//SELF%TAG_NAME//'>' + IF (PRESENT(IS_INDENTED)) THEN + IF (IS_INDENTED) TAG_ = REPEAT(' ', SELF%INDENT)//TAG_ + ENDIF + ENDFUNCTION END_TAG + + ELEMENTAL SUBROUTINE FREE(SELF) + !< FREE DYNAMIC MEMORY. + CLASS(XML_TAG), INTENT(INOUT) :: SELF !< XML TAG. + + CALL SELF%TAG_NAME%FREE + CALL SELF%TAG_CONTENT%FREE + IF (ALLOCATED(SELF%ATTRIBUTE)) THEN + CALL SELF%ATTRIBUTE%FREE + DEALLOCATE(SELF%ATTRIBUTE) + ENDIF + SELF%ATTRIBUTES_NUMBER = 0 + SELF%INDENT = 0 + SELF%IS_SELF_CLOSING = .FALSE. + ENDSUBROUTINE FREE + + ELEMENTAL FUNCTION IS_PARSED(SELF) + !< CHECK IS TAG IS CORRECTLY PARSED, I.E. ITS *TAG_NAME* IS ALLOCATED. + CLASS(XML_TAG), INTENT(IN) :: SELF !< XML TAG. + LOGICAL :: IS_PARSED !< RESULT OF CHECK. + + IS_PARSED = SELF%TAG_NAME%IS_ALLOCATED() + ENDFUNCTION IS_PARSED + + PURE FUNCTION NAME(SELF) + !< RETURN TAG NAME. + CLASS(XML_TAG), INTENT(IN) :: SELF !< XML TAG. + CHARACTER(LEN=:), ALLOCATABLE :: NAME !< XML TAG NAME. + + NAME = SELF%TAG_NAME%CHARS() + ENDFUNCTION NAME + + ELEMENTAL SUBROUTINE PARSE(SELF, SOURCE, TSTART, TEND) + !< PARSE THE TAG CONTAINED INTO A SOURCE STRING. + !< + !< IT IS ASSUMED THAT THE FIRST TAG CONTAINED INTO THE SOURCE STRING IS PARSED, THE OTHERS EVENTUALLY PRESENT ARE OMITTED. + !< VALID SYNTAX ARE: + !< + `<TAG_NAME ATT1="ATT1 VAL" ATT2="ATT2 VAL"...>...</TAG_NAME>` + !< + `<TAG_NAME ATT1="ATT1 VAL" ATT2="ATT2 VAL".../>` + !< @NOTE INSIDE THE ATTRIBUTES VALUE THE SYMBOLS `<` AND `>` ARE NOT ALLOWED. + CLASS(XML_TAG), INTENT(INOUT) :: SELF !< XML TAG. + CHARACTER(*), INTENT(IN) :: SOURCE !< STRING CONTAINING THE INPUT. + INTEGER(I4P), OPTIONAL, INTENT(OUT) :: TSTART !< STARTING INDEX OF TAG INSIDE THE STRING. + INTEGER(I4P), OPTIONAL, INTENT(OUT) :: TEND !< ENDING INDEX OF TAG INSIDE THE STRING. + INTEGER(I4P) :: TSTARTD !< STARTING INDEX OF TAG INSIDE THE STRING. + INTEGER(I4P) :: TENDD !< ENDING INDEX OF TAG INSIDE THE STRING. + + TSTARTD = 0 + TENDD = 0 + CALL SELF%PARSE_TAG_NAME(SOURCE=SOURCE, TSTART=TSTARTD, TEND=TENDD) + IF (SELF%TAG_NAME%IS_ALLOCATED()) THEN + IF (INDEX(STRING=SOURCE(TSTARTD:TENDD), SUBSTRING='=')>0) CALL SELF%PARSE_ATTRIBUTES_NAMES(SOURCE=SOURCE(TSTARTD:TENDD)) + IF (INDEX(STRING=SOURCE, SUBSTRING='</'//SELF%TAG_NAME//'>')>0) & + TENDD = INDEX(STRING=SOURCE, SUBSTRING='</'//SELF%TAG_NAME//'>') + LEN('</'//SELF%TAG_NAME//'>') - 1 + CALL SELF%GET(SOURCE=SOURCE(TSTARTD:TENDD)) + ENDIF + IF (PRESENT(TSTART)) TSTART = TSTARTD + IF (PRESENT(TEND )) TEND = TENDD + ENDSUBROUTINE PARSE + + PURE SUBROUTINE SET(SELF, NAME, ATTRIBUTE, ATTRIBUTES, ATTRIBUTES_STREAM, SANITIZE_ATTRIBUTES_VALUE, CONTENT, & + INDENT, IS_CONTENT_INDENTED, IS_SELF_CLOSING) + !< SET TAG DATA. + CLASS(XML_TAG), INTENT(INOUT) :: SELF !< XML TAG. + CHARACTER(*), INTENT(IN), OPTIONAL :: NAME !< TAG NAME. + CHARACTER(*), INTENT(IN), OPTIONAL :: ATTRIBUTE(1:) !< ATTRIBUTE NAME/VALUE PAIR [1:2]. + CHARACTER(*), INTENT(IN), OPTIONAL :: ATTRIBUTES(1:,1:) !< ATTRIBUTES LIST OF NAME/VALUE PAIRS [1:2,1:]. + CHARACTER(*), INTENT(IN), OPTIONAL :: ATTRIBUTES_STREAM !< ATTRIBUTES LIST OF NAME/VALUE PAIRS AS SINGLE STREAM. + LOGICAL, INTENT(IN), OPTIONAL :: SANITIZE_ATTRIBUTES_VALUE !< SANITIZE ATTRIBUTES VALUE. + CHARACTER(*), INTENT(IN), OPTIONAL :: CONTENT !< TAG VALUE. + INTEGER(I4P), INTENT(IN), OPTIONAL :: INDENT !< NUMBER OF INDENT-WHITE-SPACES. + LOGICAL, INTENT(IN), OPTIONAL :: IS_CONTENT_INDENTED !< ACTIVATE VALUE INDENTATION. + LOGICAL, INTENT(IN), OPTIONAL :: IS_SELF_CLOSING !< THE TAG IS SELF CLOSING. + LOGICAL :: IS_CONTENT_INDENTED_ !< ACTIVATE VALUE INDENTATION. + + IF (PRESENT(NAME)) SELF%TAG_NAME = NAME + IF (PRESENT(ATTRIBUTE)) CALL SELF%ADD_SINGLE_ATTRIBUTE(ATTRIBUTE=ATTRIBUTE, SANITIZE_VALUE=SANITIZE_ATTRIBUTES_VALUE) + IF (PRESENT(ATTRIBUTES)) CALL SELF%ADD_MULTIPLE_ATTRIBUTES(ATTRIBUTES=ATTRIBUTES, SANITIZE_VALUES=SANITIZE_ATTRIBUTES_VALUE) + IF (PRESENT(ATTRIBUTES_STREAM)) CALL SELF%ADD_STREAM_ATTRIBUTES(ATTRIBUTES_STREAM=ATTRIBUTES_STREAM, & + SANITIZE_VALUES=SANITIZE_ATTRIBUTES_VALUE) + IF (PRESENT(INDENT)) SELF%INDENT = INDENT + IF (PRESENT(CONTENT)) THEN + IS_CONTENT_INDENTED_ = .FALSE. ; IF (PRESENT(IS_CONTENT_INDENTED)) IS_CONTENT_INDENTED_ = IS_CONTENT_INDENTED + IF (IS_CONTENT_INDENTED_) THEN + SELF%TAG_CONTENT = NEW_LINE('A')//REPEAT(' ', SELF%INDENT+2)//CONTENT//NEW_LINE('A') + ELSE + SELF%TAG_CONTENT = CONTENT + ENDIF + ENDIF + IF (PRESENT(IS_SELF_CLOSING)) SELF%IS_SELF_CLOSING = IS_SELF_CLOSING + ENDSUBROUTINE SET + + PURE FUNCTION SELF_CLOSING_TAG(SELF, IS_INDENTED) RESULT(TAG_) + !< RETURN `<TAG_NAME.../>` SELF CLOSING TAG. + CLASS(XML_TAG), INTENT(IN) :: SELF !< XML TAG. + LOGICAL, INTENT(IN), OPTIONAL :: IS_INDENTED !< FLAG TO CHECK IF TAG IS INDENTED. + CHARACTER(LEN=:), ALLOCATABLE :: TAG_ !< THE SELF CLOSING TAG STRING. + + TAG_ = '<'//SELF%TAG_NAME + IF (SELF%ATTRIBUTES_NUMBER>0) TAG_ = TAG_//' '//SELF%ATTRIBUTES() + TAG_ = TAG_//'/>' + IF (PRESENT(IS_INDENTED)) THEN + IF (IS_INDENTED) TAG_ = REPEAT(' ', SELF%INDENT)//TAG_ + ENDIF + ENDFUNCTION SELF_CLOSING_TAG + + PURE FUNCTION START_TAG(SELF, IS_INDENTED) RESULT(TAG_) + !< RETURN `<TAG_NAME...>` START TAG. + CLASS(XML_TAG), INTENT(IN) :: SELF !< XML TAG. + LOGICAL, INTENT(IN), OPTIONAL :: IS_INDENTED !< FLAG TO CHECK IF TAG IS INDENTED. + CHARACTER(LEN=:), ALLOCATABLE :: TAG_ !< THE START TAG STRING. + + TAG_ = '<'//SELF%TAG_NAME + IF (SELF%ATTRIBUTES_NUMBER>0) TAG_ = TAG_//' '//SELF%ATTRIBUTES() + TAG_ = TAG_//'>' + IF (PRESENT(IS_INDENTED)) THEN + IF (IS_INDENTED) TAG_ = REPEAT(' ', SELF%INDENT)//TAG_ + ENDIF + ENDFUNCTION START_TAG + + PURE FUNCTION STRINGIFY(SELF, IS_INDENTED, IS_CONTENT_INDENTED, ONLY_START, ONLY_CONTENT, ONLY_END) RESULT(STRINGED) + !< CONVERT THE WHOLE TAG INTO A STRING. + CLASS(XML_TAG), INTENT(IN) :: SELF !< XML TAG. + LOGICAL, INTENT(IN), OPTIONAL :: IS_INDENTED !< ACTIVATE CONTENT INDENTATION. + LOGICAL, INTENT(IN), OPTIONAL :: IS_CONTENT_INDENTED !< ACTIVATE CONTENT INDENTATION. + LOGICAL, INTENT(IN), OPTIONAL :: ONLY_START !< WRITE ONLY START TAG. + LOGICAL, INTENT(IN), OPTIONAL :: ONLY_CONTENT !< WRITE ONLY CONTENT. + LOGICAL, INTENT(IN), OPTIONAL :: ONLY_END !< WRITE ONLY END TAG. + CHARACTER(LEN=:), ALLOCATABLE :: STRINGED !< OUTPUT STRING CONTAINING THE WHOLE TAG. + LOGICAL :: IS_CONTENT_INDENTED_ !< ACTIVATE CONTENT INDENTATION. + LOGICAL :: ONLY_START_ !< WRITE ONLY START TAG. + LOGICAL :: ONLY_CONTENT_ !< WRITE ONLY CONTENT. + LOGICAL :: ONLY_END_ !< WRITE ONLY END TAG. + + IS_CONTENT_INDENTED_ = .FALSE. ; IF (PRESENT(IS_CONTENT_INDENTED)) IS_CONTENT_INDENTED_ = IS_CONTENT_INDENTED + ONLY_START_ = .FALSE. ; IF (PRESENT(ONLY_START)) ONLY_START_ = ONLY_START + ONLY_CONTENT_ = .FALSE. ; IF (PRESENT(ONLY_CONTENT)) ONLY_CONTENT_ = ONLY_CONTENT + ONLY_END_ = .FALSE. ; IF (PRESENT(ONLY_END)) ONLY_END_ = ONLY_END + IF (ONLY_START_) THEN + STRINGED = SELF%START_TAG(IS_INDENTED=IS_INDENTED) + ELSEIF (ONLY_CONTENT_) THEN + IF (SELF%TAG_CONTENT%IS_ALLOCATED()) THEN + IF (IS_CONTENT_INDENTED_) THEN + STRINGED = REPEAT(' ', SELF%INDENT+2)//SELF%TAG_CONTENT + ELSE + STRINGED = SELF%TAG_CONTENT%CHARS() + ENDIF + ENDIF + ELSEIF (ONLY_END_) THEN + STRINGED = SELF%END_TAG(IS_INDENTED=IS_INDENTED) + ELSE + STRINGED = '' + IF (SELF%TAG_NAME%IS_ALLOCATED()) THEN + IF (SELF%IS_SELF_CLOSING) THEN + STRINGED = SELF%SELF_CLOSING_TAG(IS_INDENTED=IS_INDENTED) + ELSE + STRINGED = SELF%START_TAG(IS_INDENTED=IS_INDENTED) + IF (SELF%TAG_CONTENT%IS_ALLOCATED()) THEN + IF (IS_CONTENT_INDENTED_) THEN + STRINGED = STRINGED//NEW_LINE('A')//REPEAT(' ', SELF%INDENT+2)//& + SELF%TAG_CONTENT//NEW_LINE('A')//REPEAT(' ', SELF%INDENT) + ELSE + STRINGED = STRINGED//SELF%TAG_CONTENT + ENDIF + ENDIF + STRINGED = STRINGED//SELF%END_TAG() + ENDIF + ENDIF + ENDIF + ENDFUNCTION STRINGIFY + + SUBROUTINE WRITE_TAG(SELF, UNIT, IS_INDENTED, IS_CONTENT_INDENTED, FORM, END_RECORD, ONLY_START, ONLY_CONTENT, ONLY_END, & + IOSTAT, IOMSG) + !< WRITE TAG TO UNIT FILE. + CLASS(XML_TAG), INTENT(IN) :: SELF !< XML TAG. + INTEGER(I4P), INTENT(IN) :: UNIT !< FILE UNIT. + LOGICAL, INTENT(IN), OPTIONAL :: IS_INDENTED !< ACTIVATE CONTENT INDENTATION. + LOGICAL, INTENT(IN), OPTIONAL :: IS_CONTENT_INDENTED !< ACTIVATE CONTENT INDENTATION. + CHARACTER(*), INTENT(IN), OPTIONAL :: FORM !< FORMAT. + CHARACTER(*), INTENT(IN), OPTIONAL :: END_RECORD !< ENDING RECORD. + LOGICAL, INTENT(IN), OPTIONAL :: ONLY_START !< WRITE ONLY START TAG. + LOGICAL, INTENT(IN), OPTIONAL :: ONLY_CONTENT !< WRITE ONLY CONTENT. + LOGICAL, INTENT(IN), OPTIONAL :: ONLY_END !< WRITE ONLY END TAG. + INTEGER(I4P), INTENT(OUT), OPTIONAL :: IOSTAT !< IO STATUS. + CHARACTER(*), INTENT(OUT), OPTIONAL :: IOMSG !< IO MESSAGE. + TYPE(STRING) :: FORM_ !< FORMAT. + TYPE(STRING) :: END_RECORD_ !< ENDING RECORD. + INTEGER(I4P) :: IOSTAT_ !< IO STATUS. + CHARACTER(500) :: IOMSG_ !< IO MESSAGE. + + FORM_ = 'UNFORMATTED' + IF (PRESENT(FORM)) THEN + FORM_ = FORM + FORM_ = FORM_%UPPER() + ENDIF + END_RECORD_ = '' ; IF (PRESENT(END_RECORD)) END_RECORD_ = END_RECORD + SELECT CASE(FORM_%CHARS()) + CASE('UNFORMATTED') + WRITE(UNIT=UNIT, IOSTAT=IOSTAT_, IOMSG=IOMSG_)SELF%STRINGIFY(IS_INDENTED=IS_INDENTED, & + IS_CONTENT_INDENTED=IS_CONTENT_INDENTED, & + ONLY_START=ONLY_START, & + ONLY_CONTENT=ONLY_CONTENT, & + ONLY_END=ONLY_END)//END_RECORD_ + CASE('FORMATTED') + WRITE(UNIT=UNIT, FMT='(A)', IOSTAT=IOSTAT_, IOMSG=IOMSG_)SELF%STRINGIFY(IS_INDENTED=IS_INDENTED, & + IS_CONTENT_INDENTED=IS_CONTENT_INDENTED, & + ONLY_START=ONLY_START, & + ONLY_CONTENT=ONLY_CONTENT, & + ONLY_END=ONLY_END)//END_RECORD_ + ENDSELECT + IF (PRESENT(IOSTAT)) IOSTAT = IOSTAT_ + IF (PRESENT(IOMSG)) IOMSG = IOMSG_ + ENDSUBROUTINE WRITE_TAG + + ! PRIVATE METHODS + PURE FUNCTION IS_ATTRIBUTE_PRESENT(SELF, NAME) RESULT(IS_PRESENT) + !< RETURN .TRUE. IT THE QUERIED ATTRIBUTE NAME IS DEFINED, .FALSE. OTHERWISE. + CLASS(XML_TAG), INTENT(IN) :: SELF !< XML TAG. + CHARACTER(*), INTENT(IN) :: NAME !< ATTRIBUTE NAME. + LOGICAL :: IS_PRESENT !< INQUIRE RESULT. + INTEGER(I4P) :: A !< COUNTER. + + IS_PRESENT = .FALSE. + IF (SELF%ATTRIBUTES_NUMBER>0) THEN + DO A=1, SELF%ATTRIBUTES_NUMBER + IF (SELF%ATTRIBUTE(1, A)==NAME) THEN + IS_PRESENT = .TRUE. + EXIT + ENDIF + ENDDO + ENDIF + ENDFUNCTION IS_ATTRIBUTE_PRESENT + + PURE SUBROUTINE ADD_SINGLE_ATTRIBUTE(SELF, ATTRIBUTE, SANITIZE_VALUE) + !< ADD ONE ATTRIBUTE NAME/VALUE PAIR. + !< + !< @NOTE LEADING AND TRAILING WHITE SPACES ARE TRIMMED OUT BY ATTRIBUTE'S NAME. + CLASS(XML_TAG), INTENT(INOUT) :: SELF !< XML TAG. + CHARACTER(*), INTENT(IN) :: ATTRIBUTE(1:) !< ATTRIBUTE NAME/VALUE PAIR [1:2]. + LOGICAL, INTENT(IN), OPTIONAL :: SANITIZE_VALUE !< SANITIZE ATTRIBUTE VALUE. + TYPE(STRING), ALLOCATABLE :: NEW_ATTRIBUTE(:,:) !< TEMPORARY STORAGE FOR ATTRIBUTES. + LOGICAL :: SANITIZE_VALUE_ !< SANITIZE ATTRIBUTE VALUE. + LOGICAL :: IS_UPDATED !< FLAG TO CHECK IF THE ATTRIBUTE HAS BEEN UPDETED. + INTEGER(I4P) :: A !< COUNTER. + + SANITIZE_VALUE_ = .FALSE. ; IF (PRESENT(SANITIZE_VALUE)) SANITIZE_VALUE_ = SANITIZE_VALUE + IF (SELF%ATTRIBUTES_NUMBER>0) THEN + IS_UPDATED = .FALSE. + UPDATE_IF_ALREADY_PRESENT: DO A=1, SELF%ATTRIBUTES_NUMBER + IF (SELF%ATTRIBUTE(1, A)==ATTRIBUTE(1)) THEN + IF (SANITIZE_VALUE_) THEN + SELF%ATTRIBUTE(2, A) = TRIM(ADJUSTL(ATTRIBUTE(2))) + ELSE + SELF%ATTRIBUTE(2, A) = ATTRIBUTE(2) + ENDIF + IS_UPDATED = .TRUE. + EXIT UPDATE_IF_ALREADY_PRESENT + ENDIF + ENDDO UPDATE_IF_ALREADY_PRESENT + IF (.NOT.IS_UPDATED) THEN + ALLOCATE(NEW_ATTRIBUTE(1:2, 1:SELF%ATTRIBUTES_NUMBER+1)) + NEW_ATTRIBUTE(1:2, 1:SELF%ATTRIBUTES_NUMBER) = SELF%ATTRIBUTE + NEW_ATTRIBUTE(1, SELF%ATTRIBUTES_NUMBER+1) = TRIM(ADJUSTL(ATTRIBUTE(1))) + IF (SANITIZE_VALUE_) THEN + NEW_ATTRIBUTE(2, SELF%ATTRIBUTES_NUMBER+1) = TRIM(ADJUSTL(ATTRIBUTE(2))) + ELSE + NEW_ATTRIBUTE(2, SELF%ATTRIBUTES_NUMBER+1) = ATTRIBUTE(2) + ENDIF + CALL MOVE_ALLOC(FROM=NEW_ATTRIBUTE, TO=SELF%ATTRIBUTE) + SELF%ATTRIBUTES_NUMBER = SELF%ATTRIBUTES_NUMBER + 1 + ENDIF + ELSE + CALL SELF%ALLOC_ATTRIBUTES(NA=1) + SELF%ATTRIBUTE(1, 1) = TRIM(ADJUSTL(ATTRIBUTE(1))) + IF (SANITIZE_VALUE_) THEN + SELF%ATTRIBUTE(2, 1) = TRIM(ADJUSTL(ATTRIBUTE(2))) + ELSE + SELF%ATTRIBUTE(2, 1) = ATTRIBUTE(2) + ENDIF + ENDIF + ENDSUBROUTINE ADD_SINGLE_ATTRIBUTE + + PURE SUBROUTINE ADD_MULTIPLE_ATTRIBUTES(SELF, ATTRIBUTES, SANITIZE_VALUES) + !< ADD LIST OF ATTRIBUTES NAME/VALUE PAIRS. + CLASS(XML_TAG), INTENT(INOUT) :: SELF !< XML TAG. + CHARACTER(*), INTENT(IN) :: ATTRIBUTES(1:,1:) !< ATTRIBUTE NAME/VALUE PAIR LIST [1:2,1:]. + LOGICAL, INTENT(IN), OPTIONAL :: SANITIZE_VALUES !< SANITIZE ATTRIBUTE VALUES. + INTEGER(I4P) :: A !< COUNTER. + + DO A=1, SIZE(ATTRIBUTES, DIM=2) + ! NOT EFFICIENT: MANY REALLOCATION, BUT SAFE + CALL SELF%ADD_SINGLE_ATTRIBUTE(ATTRIBUTE=ATTRIBUTES(1:,A), SANITIZE_VALUE=SANITIZE_VALUES) + ENDDO + ENDSUBROUTINE ADD_MULTIPLE_ATTRIBUTES + + PURE SUBROUTINE ADD_STREAM_ATTRIBUTES(SELF, ATTRIBUTES_STREAM, SANITIZE_VALUES) + !< ADD LIST OF ATTRIBUTES NAME/VALUE PAIRS PASSED AS STREAM. + !< + !< @NOTE THE CHARACTER `=` CANNOT COMPARE INTO THE ATTRIBUTES NAMES OF VALUES. + CLASS(XML_TAG), INTENT(INOUT) :: SELF !< XML TAG. + CHARACTER(*), INTENT(IN) :: ATTRIBUTES_STREAM !< ATTRIBUTE NAME/VALUE PAIR LIST PASSED AS STREAM. + LOGICAL, INTENT(IN), OPTIONAL :: SANITIZE_VALUES !< SANITIZE ATTRIBUTE VALUES. + TYPE(STRING) :: ATTRIBUTES_STRING !< ATTRIBUTE NAME/VALUE PAIR LIST AS STRING. + TYPE(STRING) :: TOKENS(1:3) !< ATTRIBUTES TOKENIZED BY `=`. + TYPE(STRING) :: ATTRIBUTE(1:2) !< ATTRIBUTE NAME/VALUE PAIR. + LOGICAL :: CONTINUE_TO_PARSE !< SENTINEL TO STOP ATTRIBUTES STREAM PARSING. + INTEGER(I4P) :: MAX_CHARS !< COUNTER. + + ATTRIBUTES_STRING = ATTRIBUTES_STREAM + CONTINUE_TO_PARSE = .TRUE. + DO WHILE(CONTINUE_TO_PARSE) + TOKENS = ATTRIBUTES_STRING%PARTITION(SEP='=') + ATTRIBUTE(1) = TRIM(ADJUSTL(TOKENS(1))) + IF (ATTRIBUTE(1)/='') THEN + TOKENS(3) = TOKENS(3)%SLICE(ISTART=TOKENS(3)%INDEX('"')+1, IEND=TOKENS(3)%LEN()) + ATTRIBUTE(2) = TOKENS(3)%SLICE(ISTART=1, IEND=TOKENS(3)%INDEX('"')-1) + TOKENS(3) = TOKENS(3)%SLICE(ISTART=TOKENS(3)%INDEX('"')+1, IEND=TOKENS(3)%LEN()) + MAX_CHARS = MAX(ATTRIBUTE(1)%LEN(), ATTRIBUTE(2)%LEN()) + ATTRIBUTE(1) = ATTRIBUTE(1)%FILL(WIDTH=MAX_CHARS, RIGHT=.TRUE., FILLING_CHAR=' ') + ATTRIBUTE(2) = ATTRIBUTE(2)%FILL(WIDTH=MAX_CHARS, RIGHT=.TRUE., FILLING_CHAR=' ') + CALL SELF%ADD_SINGLE_ATTRIBUTE(ATTRIBUTE=[ATTRIBUTE(1)//'', ATTRIBUTE(2)//''], SANITIZE_VALUE=SANITIZE_VALUES) + IF (TOKENS(3)%INDEX('=')>0) THEN + ATTRIBUTES_STRING = TOKENS(3) + ELSE + CONTINUE_TO_PARSE = .FALSE. + ENDIF + ELSE + CONTINUE_TO_PARSE = .FALSE. + ENDIF + ENDDO + ENDSUBROUTINE ADD_STREAM_ATTRIBUTES + + ELEMENTAL SUBROUTINE ALLOC_ATTRIBUTES(SELF, NA) + !< ALLOCATE (PREPARE FOR FILLING) DYNAMIC MEMORY OF ATTRIBUTES. + CLASS(XML_TAG), INTENT(INOUT) :: SELF !< XML TAG. + INTEGER(I4P), INTENT(IN) :: NA !< NUMBER OF ATTRIBUTES. + + IF (ALLOCATED(SELF%ATTRIBUTE)) THEN + CALL SELF%ATTRIBUTE%FREE + DEALLOCATE(SELF%ATTRIBUTE) + ENDIF + ALLOCATE(SELF%ATTRIBUTE(1:2, 1:NA)) + SELF%ATTRIBUTES_NUMBER = NA + ENDSUBROUTINE ALLOC_ATTRIBUTES + + PURE SUBROUTINE DELETE_CONTENT(SELF) + !< DELETE TAG CONTENT. + CLASS(XML_TAG), INTENT(INOUT) :: SELF !< XML TAG. + + CALL SELF%TAG_CONTENT%FREE + ENDSUBROUTINE DELETE_CONTENT + + PURE SUBROUTINE DELETE_SINGLE_ATTRIBUTE(SELF, NAME) + !< DELETE ONE ATTRIBUTE NAME/VALUE PAIR. + CLASS(XML_TAG), INTENT(INOUT) :: SELF !< XML TAG. + CHARACTER(*), INTENT(IN) :: NAME !< ATTRIBUTE NAME. + TYPE(STRING), ALLOCATABLE :: NEW_ATTRIBUTE(:,:) !< TEMPORARY STORAGE FOR ATTRIBUTES. + INTEGER(I4P) :: A !< COUNTER. + + IF (SELF%ATTRIBUTES_NUMBER>0) THEN + SEARCH_TAG: DO A=1, SELF%ATTRIBUTES_NUMBER + IF (SELF%ATTRIBUTE(1, A)==NAME) THEN + IF (SELF%ATTRIBUTES_NUMBER>1) THEN + ALLOCATE(NEW_ATTRIBUTE(1:2, 1:SELF%ATTRIBUTES_NUMBER-1)) + IF (A==1) THEN + NEW_ATTRIBUTE(:, A:) = SELF%ATTRIBUTE(:, A+1:) + ELSEIF (A==SELF%ATTRIBUTES_NUMBER) THEN + NEW_ATTRIBUTE(:, :A-1) = SELF%ATTRIBUTE(:, :A-1) + ELSE + NEW_ATTRIBUTE(:, :A-1) = SELF%ATTRIBUTE(:, :A-1) + NEW_ATTRIBUTE(:, A:) = SELF%ATTRIBUTE(:, A+1:) + ENDIF + CALL MOVE_ALLOC(FROM=NEW_ATTRIBUTE, TO=SELF%ATTRIBUTE) + ELSE + CALL SELF%ATTRIBUTE%FREE + DEALLOCATE(SELF%ATTRIBUTE) + ENDIF + SELF%ATTRIBUTES_NUMBER = SELF%ATTRIBUTES_NUMBER - 1 + EXIT SEARCH_TAG + ENDIF + ENDDO SEARCH_TAG + ENDIF + ENDSUBROUTINE DELETE_SINGLE_ATTRIBUTE + + PURE SUBROUTINE DELETE_MULTIPLE_ATTRIBUTES(SELF, NAME) + !< DELETE LIST OF ATTRIBUTES NAME/VALUE PAIRS. + CLASS(XML_TAG), INTENT(INOUT) :: SELF !< XML TAG. + CHARACTER(*), INTENT(IN) :: NAME(1:) !< ATTRIBUTES NAMES. + INTEGER(I4P) :: A !< COUNTER. + + DO A=1, SIZE(NAME, DIM=1) + CALL SELF%DELETE_SINGLE_ATTRIBUTE(NAME=NAME(A)) + ENDDO + ENDSUBROUTINE DELETE_MULTIPLE_ATTRIBUTES + + ELEMENTAL SUBROUTINE GET(SELF, SOURCE) + !< GET THE TAG CONTENT AND ATTRIBUTES FROM SOURCE AFTER TAG_NAME AND ATTRIBUTES NAMES HAVE BEEN SET. + CLASS(XML_TAG), INTENT(INOUT) :: SELF !< XML TAG. + CHARACTER(*), INTENT(IN) :: SOURCE !< STRING CONTAINING DATA. + + CALL SELF%GET_VALUE(SOURCE=SOURCE) + CALL SELF%GET_ATTRIBUTES(SOURCE=SOURCE) + ! CALL SELF%GET_NESTED() + ENDSUBROUTINE GET + + ELEMENTAL SUBROUTINE GET_ATTRIBUTES(SELF, SOURCE) + !< GET THE ATTRIBUTES VALUES FROM SOURCE AFTER TAG_NAME AND ATTRIBUTES NAMES HAVE BEEN SET. + CLASS(XML_TAG), INTENT(INOUT) :: SELF !< XML TAG. + CHARACTER(*), INTENT(IN) :: SOURCE !< STRING CONTAINING DATA. + INTEGER :: A !< COUNTER. + INTEGER :: C1 !< COUNTER. + INTEGER :: C2 !< COUNTER. + + IF (INDEX(STRING=SOURCE, SUBSTRING='<'//SELF%TAG_NAME)>0) THEN + IF (SELF%ATTRIBUTES_NUMBER>0) THEN ! PARSING ATTRIBUTES + DO A=1, SELF%ATTRIBUTES_NUMBER + C1 = INDEX(STRING=SOURCE, SUBSTRING=SELF%ATTRIBUTE(1, A)//'="') + SELF%ATTRIBUTE(1, A)%LEN() + 2 + IF (C1>SELF%ATTRIBUTE(1, A)%LEN() + 2) THEN + C2 = INDEX(STRING=SOURCE(C1:), SUBSTRING='"') + IF (C2>0) THEN + SELF%ATTRIBUTE(2, A) = SOURCE(C1:C1+C2-2) + ELSE + CALL SELF%ATTRIBUTE(2, A)%FREE + ENDIF + ELSE + CALL SELF%ATTRIBUTE(2, A)%FREE + ENDIF + ENDDO + ENDIF + ENDIF + ENDSUBROUTINE GET_ATTRIBUTES + + ELEMENTAL SUBROUTINE GET_VALUE(SELF, SOURCE) + !< GET THE TAG VALUE FROM SOURCE AFTER TAG_NAME HAS BEEN SET. + CLASS(XML_TAG), INTENT(INOUT) :: SELF !< XML TAG. + CHARACTER(*), INTENT(IN) :: SOURCE !< STRING CONTAINING DATA. + INTEGER :: C1 !< COUNTER. + INTEGER :: C2 !< COUNTER. + + CALL SELF%TAG_CONTENT%FREE + SELF%IS_SELF_CLOSING = .FALSE. + IF (INDEX(STRING=SOURCE, SUBSTRING='<'//SELF%TAG_NAME)>0) THEN + C2 = INDEX(STRING=SOURCE, SUBSTRING='</'//SELF%TAG_NAME//'>') + IF (C2>0) THEN ! PARSING TAG VALUE + C1 = INDEX(STRING=SOURCE, SUBSTRING='>') + IF (C1+1<C2-1) SELF%TAG_CONTENT = SOURCE(C1+1:C2-1) + ELSE + SELF%IS_SELF_CLOSING = .TRUE. + ENDIF + ENDIF + ENDSUBROUTINE GET_VALUE + + ELEMENTAL SUBROUTINE PARSE_ATTRIBUTES_NAMES(SELF, SOURCE) + !< PARSE THE TAG ATTRIBUTES NAMES CONTAINED INTO A STRING. + !< + !< VALID SYNTAX IS: + !< + `ATT1="ATT1 VAL" ATT2="ATT2 VAL"...` + !< @NOTE INSIDE THE ATTRIBUTES VALUE THE SYMBOLS `<` AND `>` ARE NOT ALLOWED. + CLASS(XML_TAG), INTENT(INOUT) :: SELF !< XML TAG. + CHARACTER(*), INTENT(IN) :: SOURCE !< STRING CONTAINING THE INPUT. + CHARACTER(LEN=:), ALLOCATABLE :: ATT !< DUMMY STRING FOR PARSING FILE. + INTEGER(I4P) :: C !< COUNTER. + INTEGER(I4P) :: S !< COUNTER. + INTEGER(I4P) :: A !< COUNTER. + INTEGER(I4P) :: NA !< COUNTER. + + NA = 0 + C = 1 + ATT_COUNT: DO WHILE(C<=LEN(SOURCE)) + IF (SOURCE(C:C)=='=') NA = NA + 1 + C = C + 1 + ENDDO ATT_COUNT + IF (NA>0) THEN + CALL SELF%ALLOC_ATTRIBUTES(NA=NA) + C = INDEX(STRING=SOURCE, SUBSTRING=' ') + ATT = SOURCE(C:) + C = 1 + A = 1 + ATT_SEARCH: DO WHILE(C<=LEN(ATT)) + IF (ATT(C:C)=='=') THEN + S = MAX(0, INDEX(STRING=ATT, SUBSTRING=' ')) + SELF%ATTRIBUTE(1, A) = TRIM(ADJUSTL(ATT(S+1:C-1))) + ATT = ATT(C+1:) + C = 1 + A = A + 1 + ENDIF + C = C + 1 + ENDDO ATT_SEARCH + ENDIF + ENDSUBROUTINE PARSE_ATTRIBUTES_NAMES + + ELEMENTAL SUBROUTINE PARSE_TAG_NAME(SELF, SOURCE, TSTART, TEND) + !< PARSE THE TAG NAME CONTAINED INTO A STRING. + !< + !< IT IS ASSUMED THAT THE FIRST TAG CONTAINED INTO THE SOURCE IS PARSED, THE OTHERS EVENTUALLY PRESENT ARE OMITTED. + !< VALID SYNTAX ARE: + !< + `<TAG_NAME ATT1="ATT1 VAL" ATT2="ATT2 VAL"...>...</TAG_NAME>` + !< + `<TAG_NAME ATT1="ATT1 VAL" ATT2="ATT2 VAL".../>` + !< @NOTE INSIDE THE ATTRIBUTES VALUE THE SYMBOLS `<` AND `>` ARE NOT ALLOWED. + CLASS(XML_TAG), INTENT(INOUT) :: SELF !< XML TAG. + CHARACTER(*), INTENT(IN) :: SOURCE !< STRING CONTAINING THE INPUT. + INTEGER(I4P), OPTIONAL, INTENT(OUT) :: TSTART !< STARTING INDEX OF TAG INSIDE THE SOURCE. + INTEGER(I4P), OPTIONAL, INTENT(OUT) :: TEND !< ENDING INDEX OF TAG INSIDE THE SOURCE. + INTEGER(I4P) :: TSTARTD !< STARTING INDEX OF TAG INSIDE THE SOURCE. + INTEGER(I4P) :: TENDD !< ENDING INDEX OF TAG INSIDE THE SOURCE. + CHARACTER(LEN=1) :: C1 !< DUMMY STRING FOR PARSING FILE. + CHARACTER(LEN=:), ALLOCATABLE :: C2 !< DUMMY STRING FOR PARSING FILE. + INTEGER(I4P) :: C !< COUNTER. + INTEGER(I4P) :: S !< COUNTER. + + TSTARTD = 0 + TENDD = 0 + C = 1 + TAG_SEARCH: DO WHILE(C<=LEN(SOURCE)) + C1 = SOURCE(C:C) + IF (C1=='<') THEN + TSTARTD = C + C2 = C1 + TAG_NAME: DO WHILE(C<LEN(SOURCE)) + C = C + 1 ; C1 = SOURCE(C:C) + C2 = C2//C1 + IF (C1=='>') THEN + TENDD = C + EXIT TAG_NAME + ENDIF + ENDDO TAG_NAME + S = INDEX(STRING=C2, SUBSTRING=' ') + IF (S>0) THEN ! THERE ARE ATTRIBUTES + SELF%TAG_NAME = C2(2:S-1) + ELSE + IF (INDEX(STRING=C2, SUBSTRING='/>')>0) THEN ! SELF CLOSING TAG + SELF%TAG_NAME = C2(2:LEN(C2)-2) + ELSE + SELF%TAG_NAME = C2(2:LEN(C2)-1) + ENDIF + ENDIF + EXIT TAG_SEARCH + ENDIF + C = C + 1 + ENDDO TAG_SEARCH + IF (PRESENT(TSTART)) TSTART = TSTARTD + IF (PRESENT(TEND )) TEND = TENDD + ENDSUBROUTINE PARSE_TAG_NAME + + ELEMENTAL SUBROUTINE SEARCH(SELF, TAG_NAME, SOURCE, TSTART, TEND) + !< SEARCH TAG NAMED *TAG_NAME* INTO A STRING AND, IN CASE IT IS FOUND, STORE INTO SELF. + !< + !< @NOTE IF *TAG_NAME* IS NOT FOUND, SELF IS RETURNED EMPTY. + CLASS(XML_TAG), INTENT(INOUT) :: SELF !< XML TAG. + CHARACTER(*), INTENT(IN) :: TAG_NAME !< SEARCHED TAG NAME. + CHARACTER(*), INTENT(IN) :: SOURCE !< STRING CONTAINING THE INPUT. + INTEGER(I4P), OPTIONAL, INTENT(OUT) :: TSTART !< STARTING INDEX OF TAG INSIDE THE SOURCE. + INTEGER(I4P), OPTIONAL, INTENT(OUT) :: TEND !< ENDING INDEX OF TAG INSIDE THE SOURCE. + TYPE(XML_TAG) :: TAG !< DUMMY XML TAG. + INTEGER(I4P) :: TSTART_ !< STARTING INDEX OF TAG INSIDE THE SOURCE, LOCAL VARIABLE. + INTEGER(I4P) :: TEND_ !< ENDING INDEX OF TAG INSIDE THE SOURCE, LOCAL VARIABLE. + LOGICAL :: FOUND !< FLAG FOR INQUIRING SEARCH RESULT. + INTEGER(I4P) :: TSTART_C !< STARTING INDEX OF TAG INSIDE THE CURRENT SLICE OF SOURCE. + INTEGER(I4P) :: TEND_C !< STARTING INDEX OF TAG INSIDE THE CURRENT SLICE OF SOURCE. + INTEGER(I4P) :: I + + CALL SELF%FREE + SELF%TAG_NAME = TAG_NAME + TSTART_ = 1 + TEND_ = 0 + FOUND = .FALSE. + TSTART_C = 0 + TEND_C = 0 + TAG_SEARCH: DO + CALL TAG%PARSE(SOURCE=SOURCE(TEND_ + 1:), TSTART=TSTART_C, TEND=TEND_C) + TSTART_ = TSTART_ + TEND_ + TEND_ = TEND_ + TEND_C + IF (TSTART_C==0.AND.TEND_C==0) THEN + EXIT TAG_SEARCH ! NO TAG FOUND + ELSE + IF (TAG%TAG_NAME%IS_ALLOCATED()) THEN + IF (TAG%TAG_NAME==SELF%TAG_NAME) THEN + FOUND = .TRUE. + ENDIF + ENDIF + ENDIF + IF (FOUND) EXIT TAG_SEARCH + ENDDO TAG_SEARCH + IF (FOUND) THEN + SELF = TAG + ELSE + CALL SELF%FREE + ENDIF + IF (PRESENT(TSTART)) TSTART = TSTART_ + IF (PRESENT(TEND )) TEND = TEND_ + ENDSUBROUTINE SEARCH + + ! ASSIGNMENT (=) + ELEMENTAL SUBROUTINE ASSIGN_TAG(LHS, RHS) + !< ASSIGNMENT BETWEEN TWO TAGS. + CLASS(XML_TAG), INTENT(INOUT) :: LHS !< LEFT HAND SIDE. + TYPE(XML_TAG), INTENT(IN) :: RHS !< RIGHT HAND SIDE. + INTEGER(I4P) :: A !< COUNTER. + + CALL LHS%FREE + IF (RHS%TAG_NAME%IS_ALLOCATED()) LHS%TAG_NAME = RHS%TAG_NAME + IF (RHS%TAG_CONTENT%IS_ALLOCATED()) LHS%TAG_CONTENT = RHS%TAG_CONTENT + IF (RHS%ATTRIBUTES_NUMBER>0) THEN + ALLOCATE(LHS%ATTRIBUTE(1:2, 1:RHS%ATTRIBUTES_NUMBER)) + DO A=1, RHS%ATTRIBUTES_NUMBER + LHS%ATTRIBUTE(1:2, A) = RHS%ATTRIBUTE(1:2, A) + ENDDO + ENDIF + LHS%ATTRIBUTES_NUMBER = RHS%ATTRIBUTES_NUMBER + LHS%INDENT = RHS%INDENT + LHS%IS_SELF_CLOSING = RHS%IS_SELF_CLOSING + ENDSUBROUTINE ASSIGN_TAG + + ! FINALIZE + ELEMENTAL SUBROUTINE FINALIZE(TAG) + !< FREE DYNAMIC MEMORY WHEN FINALIZING. + TYPE(XML_TAG), INTENT(INOUT) :: TAG !< XML TAG. + + CALL TAG%FREE + ENDSUBROUTINE FINALIZE +ENDMODULE FOXY_XML_TAG + + + + + + +!< FOXY XML FILE CLASS. +MODULE FOXY_XML_FILE +!< FOXY XML FILE CLASS. +USE FOXY_XML_TAG, ONLY : XML_TAG +USE PENF + +IMPLICIT NONE +PRIVATE + +TYPE, PUBLIC:: XML_FILE + !< XML FILE CLASS. + !< + !< @TODO THE "DELETE" FACILITY IS INCOMPLETE: NESTED TAGS ARE NOT TAKEN INTO ACCOUNT. BETTER SUPPORT WILL WITH THE + !< "DOM" FACILITY. + PRIVATE + INTEGER(I4P) :: NT = 0 !< NUMBER OF XML TAGS. + TYPE(XML_TAG), ALLOCATABLE :: TAG(:) !< XML TAGS ARRAY. + CONTAINS + ! PUBLIC METHODS + PROCEDURE :: FREE !< FREE DYNAMIC MEMORY. + PROCEDURE :: PARSE !< PARSE XML DATA FROM STRING OR FILE. + PROCEDURE :: CONTENT !< RETURN TAG CONTENT OF TAG NAMED *NAME*. + PROCEDURE :: STRINGIFY !< CONVERT THE WHOLE FILE DATA INTO A STRING. + PROCEDURE :: ADD_TAG !< ADD TAG TO XML FILE. + PROCEDURE :: DELETE_TAG !< ADD TAG FROM XML FILE. + FINAL :: FINALIZE !< FREE DYNAMIC MEMORY WHEN FINALIZING. + ! PRIVATE METHODS + PROCEDURE, PRIVATE :: PARSE_FROM_STRING !< PARSE XML DATA FROM STRING. +ENDTYPE XML_FILE +CONTAINS + ! PUBLIC METHODS + ELEMENTAL SUBROUTINE FREE(SELF) + !< FREE DYNAMIC MEMORY. + CLASS(XML_FILE), INTENT(INOUT) :: SELF !< XML FILE. + + IF (ALLOCATED(SELF%TAG)) THEN + CALL SELF%TAG%FREE + DEALLOCATE(SELF%TAG) + SELF%NT = 0 + ENDIF + ENDSUBROUTINE FREE + + SUBROUTINE FINALIZE(FILE) + !< FREE DYNAMIC MEMORY WHEN FINALIZING. + TYPE(XML_FILE), INTENT(INOUT) :: FILE !< XML FILE. + + CALL FILE%FREE + ENDSUBROUTINE FINALIZE + + SUBROUTINE PARSE(SELF, STRING, FILENAME) + !< PARSE XML DATA FROM STRING OR FILE. + !< + !< @NOTE SELF DATA ARE FREE BEFORE TRYING TO PARSE NEW XML DATA: ALL PREVIOUSLY PARSED DATA ARE LOST. + CLASS(XML_FILE), INTENT(INOUT) :: SELF !< XML FILE. + CHARACTER(*), OPTIONAL, INTENT(IN) :: STRING !< STRING CONTAINING XML DATA. + CHARACTER(*), OPTIONAL, INTENT(IN) :: FILENAME !< FILE NAME CONTAINING XML DATA. + CHARACTER(LEN=:), ALLOCATABLE :: SOURCE !< STRING CONTAINING XML DATA. + + CALL SELF%FREE + IF (PRESENT(STRING)) THEN + CALL SELF%PARSE_FROM_STRING(SOURCE_STRING=STRING) + ELSEIF (PRESENT(FILENAME)) THEN + SOURCE = LOAD_FILE_AS_STREAM(FILENAME=FILENAME, FAST_READ=.TRUE.) + CALL SELF%PARSE_FROM_STRING(SOURCE_STRING=SOURCE) + ENDIF + ENDSUBROUTINE PARSE + + PURE FUNCTION CONTENT(SELF, NAME) + !< RETURN TAG CONTENT OF TAG NAMED *NAME*. + !< + !< @NOTE IF THERE IS NO VALUE, THE *TAG_CONTENT* STRING IS RETURNED EMPTY, BUT ALLOCATED. + CLASS(XML_FILE), INTENT(IN) :: SELF !< XML FILE. + CHARACTER(*), INTENT(IN) :: NAME !< TAG NAME. + CHARACTER(LEN=:), ALLOCATABLE :: CONTENT !< TAG CONTENT. + INTEGER(I4P) :: T !< COUNTER. + + IF (ALLOCATED(CONTENT)) DEALLOCATE(CONTENT) + IF (SELF%NT>0) THEN + DO T=1, SELF%NT + CALL SELF%TAG(T)%GET_CONTENT(NAME=NAME, CONTENT=CONTENT) + IF (ALLOCATED(CONTENT)) EXIT + ENDDO + ENDIF + IF (.NOT.ALLOCATED(CONTENT)) CONTENT = '' + ENDFUNCTION CONTENT + + PURE FUNCTION STRINGIFY(SELF) RESULT(STRING) + !< CONVERT THE WHOLE FILE DATA INTO A STRING. + CLASS(XML_FILE), INTENT(IN) :: SELF !< XML FILE. + CHARACTER(LEN=:), ALLOCATABLE :: STRING !< OUTPUT STRING CONTAINING THE WHOLE XML FILE. + CHARACTER(LEN=:), ALLOCATABLE :: TAG_STRING !< OUTPUT STRING CONTAINING THE CURRENT TAG. + INTEGER(I4P) :: T !< COUNTER. + + STRING = '' + IF (SELF%NT>0) THEN + DO T=1, SELF%NT - 1 + TAG_STRING = SELF%TAG(T)%STRINGIFY() + STRING = STRING//TAG_STRING//NEW_LINE('A') + ENDDO + TAG_STRING = SELF%TAG(SELF%NT)%STRINGIFY() + STRING = STRING//TAG_STRING + ENDIF + ENDFUNCTION STRINGIFY + + ELEMENTAL SUBROUTINE ADD_TAG(SELF, TAG) + !< ADD TAG TO XML FILE. + CLASS(XML_FILE), INTENT(INOUT) :: SELF !< XML FILE. + TYPE(XML_TAG), INTENT(IN) :: TAG !< XML TAG. + TYPE(XML_TAG), ALLOCATABLE :: TAG_NEW(:) !< NEW (EXTENDED) TAGS ARRAY. + + IF (SELF%NT>0_I4P) THEN + ALLOCATE(TAG_NEW(1:SELF%NT + 1)) + TAG_NEW(1:SELF%NT) = SELF%TAG(1:SELF%NT) + TAG_NEW(SELF%NT + 1) = TAG + ELSE + ALLOCATE(TAG_NEW(1:1)) + TAG_NEW(1) = TAG + ENDIF + CALL MOVE_ALLOC(FROM=TAG_NEW, TO=SELF%TAG) + SELF%NT = SELF%NT + 1 + ENDSUBROUTINE ADD_TAG + + ELEMENTAL SUBROUTINE DELETE_TAG(SELF, NAME) + !< DELETE TAG FROM XML FILE. + CLASS(XML_FILE), INTENT(INOUT) :: SELF !< XML FILE. + CHARACTER(*), INTENT(IN) :: NAME !< XML TAG NAME. + TYPE(XML_TAG), ALLOCATABLE :: TAG_NEW(:) !< NEW (EXTENDED) TAGS ARRAY. + INTEGER(I4P) :: T !< COUNTER. + + IF (SELF%NT>0_I4P) THEN + DO T=1, SELF%NT + IF (NAME==SELF%TAG(T)%NAME()) THEN + ALLOCATE(TAG_NEW(1:SELF%NT - 1)) + IF (T==1) THEN + TAG_NEW(T:) = SELF%TAG(T+1:) + ELSEIF (T==SELF%NT) THEN + TAG_NEW(:T-1) = SELF%TAG(:T-1) + ELSE + TAG_NEW(:T-1) = SELF%TAG(:T-1) + TAG_NEW(T:) = SELF%TAG(T+1:) + ENDIF + CALL MOVE_ALLOC(FROM=TAG_NEW, TO=SELF%TAG) + SELF%NT = SELF%NT - 1 + EXIT + ENDIF + ENDDO + ENDIF + ENDSUBROUTINE DELETE_TAG + + ! PRIVATE METHODS + SUBROUTINE PARSE_FROM_STRING(SELF, SOURCE_STRING) + !< PARSE XML DATA FROM STRING. + CLASS(XML_FILE), INTENT(INOUT) :: SELF !< XML FILE. + CHARACTER(*), INTENT(IN) :: SOURCE_STRING !< STRING CONTAINING XML DATA. + TYPE(XML_TAG) :: TAG !< DUMMY XML TAG. + INTEGER(I4P) :: TSTART !< COUNTER FOR TRACKING STRING PARSING. + INTEGER(I4P) :: TEND !< COUNTER FOR TRACKING STRING PARSING. + + TSTART = 1 + TEND = 0 + DO WHILE(TSTART<LEN(SOURCE_STRING)) + CALL TAG%FREE + CALL TAG%PARSE(SOURCE=SOURCE_STRING(TSTART:), TEND=TEND) + IF (TEND==0) EXIT + IF (TAG%IS_PARSED()) CALL SELF%ADD_TAG(TAG) + TSTART = TSTART + TEND + ENDDO + ENDSUBROUTINE PARSE_FROM_STRING + + ! NON TBP + FUNCTION LOAD_FILE_AS_STREAM(FILENAME, DELIMITER_START, DELIMITER_END, FAST_READ, IOSTAT, IOMSG) RESULT(STREAM) + !< LOAD FILE CONTENTS AND STORE AS SINGLE CHARACTERS STREAM. + CHARACTER(*), INTENT(IN) :: FILENAME !< FILE NAME. + CHARACTER(*), OPTIONAL, INTENT(IN) :: DELIMITER_START !< DELIMITER FROM WHICH START THE STREAM. + CHARACTER(*), OPTIONAL, INTENT(IN) :: DELIMITER_END !< DELIMITER TO WHICH END THE STREAM. + LOGICAL, OPTIONAL, INTENT(IN) :: FAST_READ !< FLAG FOR ACTIVATING EFFICIENT READING WITH ONE SINGLE READ. + INTEGER(I4P), OPTIONAL, INTENT(OUT) :: IOSTAT !< IO ERROR. + CHARACTER(*), OPTIONAL, INTENT(OUT) :: IOMSG !< IO ERROR MESSAGE. + CHARACTER(LEN=:), ALLOCATABLE :: STREAM !< OUTPUT STRING CONTAINING THE FILE DATA AS A SINGLE STREAM. + LOGICAL :: IS_FILE !< FLAG FOR INQUIRING THE PRESENCE OF THE FILE. + INTEGER(I4P) :: UNIT !< UNIT FILE. + INTEGER(I4P) :: IOSTATD !< IO ERROR. + CHARACTER(500) :: IOMSGD !< IO ERROR MESSAGE. + CHARACTER(1) :: C1 !< SINGLE CHARACTER. + CHARACTER(LEN=:), ALLOCATABLE :: STRING !< DUMMY STRING. + LOGICAL :: CSTART !< FLAG FOR STREAM CAPTURING TRIGGING. + LOGICAL :: CEND !< FLAG FOR STREAM CAPTURING TRIGGING. + LOGICAL :: FAST !< FLAG FOR ACTIVATING EFFICIENT READING WITH ONE SINGLE READ. + INTEGER(I4P) :: FILESIZE !< SIZE OF THE FILE FOR FAST READING. + + FAST = .FALSE. ; IF (PRESENT(FAST_READ)) FAST = FAST_READ + ! INQUIRE FILE EXISTANCE + INQUIRE(FILE=ADJUSTL(TRIM(FILENAME)), EXIST=IS_FILE, IOSTAT=IOSTATD, IOMSG=IOMSGD) + IF (.NOT.IS_FILE) THEN + IF (PRESENT(IOSTAT)) IOSTAT = IOSTATD + IF (PRESENT(IOMSG )) IOMSG = IOMSGD + RETURN + ENDIF + ! OPEN FILE + OPEN(NEWUNIT=UNIT, FILE=ADJUSTL(TRIM(FILENAME)), ACCESS='STREAM', FORM='UNFORMATTED', IOSTAT=IOSTATD, IOMSG=IOMSGD) + IF (IOSTATD/=0) THEN + IF (PRESENT(IOSTAT)) IOSTAT = IOSTATD + IF (PRESENT(IOMSG )) IOMSG = IOMSGD + RETURN + ENDIF + ! LOADG DATA + STREAM = '' + IF (PRESENT(DELIMITER_START).AND.PRESENT(DELIMITER_END)) THEN + ! LOAD ONLY DATA INSIDE DELIMITER_START AND DELIMITER_END + STRING = '' + MAIN_READ_LOOP: DO + READ(UNIT=UNIT, IOSTAT=IOSTATD, IOMSG=IOMSGD, END=10)C1 + IF (C1==DELIMITER_START(1:1)) THEN + CSTART = .TRUE. + STRING = C1 + START_READ_LOOP: DO WHILE(LEN(STRING)<LEN(DELIMITER_START)) + READ(UNIT=UNIT, IOSTAT=IOSTATD, IOMSG=IOMSGD, END=10)C1 + STRING = STRING//C1 + IF (.NOT.(INDEX(STRING=DELIMITER_START, SUBSTRING=STRING)>0)) THEN + CSTART = .FALSE. + EXIT START_READ_LOOP + ENDIF + ENDDO START_READ_LOOP + IF (CSTART) THEN + CEND = .FALSE. + STREAM = STRING + DO WHILE(.NOT.CEND) + READ(UNIT=UNIT, IOSTAT=IOSTATD, IOMSG=IOMSGD, END=10)C1 + IF (C1==DELIMITER_END(1:1)) THEN ! MAYBE THE END + STRING = C1 + END_READ_LOOP: DO WHILE(LEN(STRING)<LEN(DELIMITER_END)) + READ(UNIT=UNIT, IOSTAT=IOSTATD, IOMSG=IOMSGD, END=10)C1 + STRING = STRING//C1 + IF (.NOT.(INDEX(STRING=DELIMITER_END, SUBSTRING=STRING)>0)) THEN + STREAM = STREAM//STRING + EXIT END_READ_LOOP + ELSEIF (LEN(STRING)==LEN(DELIMITER_END)) THEN + CEND = .TRUE. + STREAM = STREAM//STRING + EXIT MAIN_READ_LOOP + ENDIF + ENDDO END_READ_LOOP + ELSE + STREAM = STREAM//C1 + ENDIF + ENDDO + ENDIF + ENDIF + ENDDO MAIN_READ_LOOP + ELSE + ! LOAD ALL DATA + IF (FAST) THEN + ! LOAD FAST + INQUIRE(FILE=ADJUSTL(TRIM(FILENAME)), SIZE=FILESIZE, IOSTAT=IOSTATD, IOMSG=IOMSGD) + IF (IOSTATD==0) THEN + IF (ALLOCATED(STREAM)) DEALLOCATE(STREAM) + ALLOCATE(CHARACTER(LEN=FILESIZE):: STREAM) + READ(UNIT=UNIT, IOSTAT=IOSTATD, IOMSG=IOMSGD, END=10)STREAM + ENDIF + ELSE + ! LOAD SLOW, ONE CHARACTER LOOP + READ_LOOP: DO + READ(UNIT=UNIT,IOSTAT=IOSTATD,IOMSG=IOMSGD,END=10)C1 + STREAM = STREAM//C1 + ENDDO READ_LOOP + ENDIF + ENDIF + 10 CLOSE(UNIT) + IF (PRESENT(IOSTAT)) IOSTAT = IOSTATD + IF (PRESENT(IOMSG)) IOMSG = IOMSGD + ENDFUNCTION LOAD_FILE_AS_STREAM +ENDMODULE FOXY_XML_FILE + + + + + + + +!< FOXY, FORTRAN XML PARSER FOR POOR PEOPLE +MODULE FOXY +!< FOXY, FORTRAN XML PARSER FOR POOR PEOPLE +USE FOXY_XML_FILE, ONLY : XML_FILE +USE FOXY_XML_TAG, ONLY : XML_TAG +USE PENF + +IMPLICIT NONE +PRIVATE +PUBLIC :: I1P, I2P, I4P, I8P, R4P, R8P +PUBLIC :: XML_FILE +PUBLIC :: XML_TAG +ENDMODULE FOXY + + + + + + +!< VTK_FORTRAN PARAMETERS. +MODULE VTK_FORTRAN_PARAMETERS +!< VTK_FORTRAN PARAMETERS. +USE, INTRINSIC :: ISO_FORTRAN_ENV, ONLY : OUTPUT_UNIT, ERROR_UNIT +USE PENF + +IMPLICIT NONE +PRIVATE +SAVE +PUBLIC :: STDERR +PUBLIC :: STDOUT +PUBLIC :: END_REC + +INTEGER(I4P), PARAMETER :: STDERR = ERROR_UNIT !< STANDARD ERROR UNIT. +INTEGER(I4P), PARAMETER :: STDOUT = OUTPUT_UNIT !< STANDARD OUTPUT UNIT. +CHARACTER(1), PARAMETER :: END_REC = CHAR(10) !< END-CHARACTER FOR BINARY-RECORD FINALIZE. +ENDMODULE VTK_FORTRAN_PARAMETERS + + +!< VTK FILE ABSTRACT XML WRITER. +MODULE VTKF_FILE_XML_WRITER_ABSTRACT +!< VTK FILE ABSTRACT XML WRITER. +USE FOXY +USE PENF +USE STRINGIFOR +USE VTK_FORTRAN_PARAMETERS + +IMPLICIT NONE +PRIVATE +PUBLIC :: XML_WRITER_ABSTRACT + +TYPE, ABSTRACT :: XML_WRITER_ABSTRACT + !< VTK FILE ABSTRACT XML WRITER. + TYPE(STRING) :: FORMAT_CH !< OUTPUT FORMAT, STRING CODE. + TYPE(STRING) :: TOPOLOGY !< MESH TOPOLOGY. + INTEGER(I4P) :: INDENT=0_I4P !< INDENT COUNT. + INTEGER(I8P) :: IOFFSET=0_I8P !< OFFSET COUNT. + INTEGER(I4P) :: XML=0_I4P !< XML LOGICAL UNIT. + INTEGER(I4P) :: VTM_BLOCK(1:2)=[-1_I4P, -1_I4P] !< BLOCK INDEXES. + INTEGER(I4P) :: ERROR=0_I4P !< IO ERROR STATUS. + TYPE(XML_TAG) :: TAG !< XML TAGS HANDLER. + LOGICAL :: IS_VOLATILE=.FALSE. !< FLAG TO CHECK VOLATILE WRITER. + TYPE(STRING) :: XML_VOLATILE !< XML FILE VOLATILE (NOT A PHYSICAL FILE). + CONTAINS + ! PUBLIC METHODS (SOME DEFERRED) + PROCEDURE, PASS(SELF) :: CLOSE_XML_FILE !< CLOSE XML FILE. + PROCEDURE, PASS(SELF) :: OPEN_XML_FILE !< OPEN XML FILE. + PROCEDURE, PASS(SELF) :: FREE !< FREE ALLOCATED MEMORY. + PROCEDURE, PASS(SELF) :: GET_XML_VOLATILE !< RETURN THE XML VOLATILE STRING FILE. + PROCEDURE, PASS(SELF) :: WRITE_CONNECTIVITY !< WRITE CONNECTIVITY. + PROCEDURE, PASS(SELF) :: W_DATA_LOCATION_TAG !< WRITE DATAARRAY LOCATION TAG. + PROCEDURE, PASS(SELF) :: W_DATA_TAG !< WRITE DATAARRAY TAG. + PROCEDURE, PASS(SELF) :: W_DATA_TAG_APPENDED !< WRITE DATAARRAY APPENDED TAG. + PROCEDURE, PASS(SELF) :: WRITE_END_TAG !< WRITE `</TAG_NAME>` END TAG. + PROCEDURE, PASS(SELF) :: WRITE_HEADER_TAG !< WRITE HEADER TAG. + PROCEDURE, PASS(SELF) :: WRITE_PARALLEL_OPEN_BLOCK !< WRITE PARALLEL OPEN BLOCK. + PROCEDURE, PASS(SELF) :: WRITE_PARALLEL_CLOSE_BLOCK !< WRITE PARALLEL CLOSE BLOCK. + PROCEDURE, PASS(SELF) :: WRITE_PARALLEL_DATAARRAY !< WRITE PARALLEL DATAARRAY. + PROCEDURE, PASS(SELF) :: WRITE_PARALLEL_GEO !< WRITE PARALLEL GEO. + PROCEDURE, PASS(SELF) :: WRITE_SELF_CLOSING_TAG !< WRITE SELF CLOSING TAG. + PROCEDURE, PASS(SELF) :: WRITE_START_TAG !< WRITE START TAG. + PROCEDURE, PASS(SELF) :: WRITE_TAG !< WRITE TAG. + PROCEDURE, PASS(SELF) :: WRITE_TOPOLOGY_TAG !< WRITE TOPOLOGY TAG. + PROCEDURE(INITIALIZE_INTERFACE), DEFERRED, PASS(SELF) :: INITIALIZE !< INITIALIZE WRITER. + PROCEDURE(FINALIZE_INTERFACE), DEFERRED, PASS(SELF) :: FINALIZE !< FINALIZE WRITER. + GENERIC :: W_DATA => & + W_DATA1_RANK1_R8P, & + W_DATA1_RANK1_R4P, & + W_DATA1_RANK1_I8P, & + W_DATA1_RANK1_I4P, & + W_DATA1_RANK1_I2P, & + W_DATA1_RANK1_I1P, & + W_DATA1_RANK2_R8P, & + W_DATA1_RANK2_R4P, & + W_DATA1_RANK2_I8P, & + W_DATA1_RANK2_I4P, & + W_DATA1_RANK2_I2P, & + W_DATA1_RANK2_I1P, & + W_DATA1_RANK3_R8P, & + W_DATA1_RANK3_R4P, & + W_DATA1_RANK3_I8P, & + W_DATA1_RANK3_I4P, & + W_DATA1_RANK3_I2P, & + W_DATA1_RANK3_I1P, & + W_DATA1_RANK4_R8P, & + W_DATA1_RANK4_R4P, & + W_DATA1_RANK4_I8P, & + W_DATA1_RANK4_I4P, & + W_DATA1_RANK4_I2P, & + W_DATA1_RANK4_I1P, & + W_DATA3_RANK1_R8P, & + W_DATA3_RANK1_R4P, & + W_DATA3_RANK1_I8P, & + W_DATA3_RANK1_I4P, & + W_DATA3_RANK1_I2P, & + W_DATA3_RANK1_I1P, & + W_DATA3_RANK3_R8P, & + W_DATA3_RANK3_R4P, & + W_DATA3_RANK3_I8P, & + W_DATA3_RANK3_I4P, & + W_DATA3_RANK3_I2P, & + W_DATA3_RANK3_I1P, & + W_DATA6_RANK1_R8P, & + W_DATA6_RANK1_R4P, & + W_DATA6_RANK1_I8P, & + W_DATA6_RANK1_I4P, & + W_DATA6_RANK1_I2P, & + W_DATA6_RANK1_I1P, & + W_DATA6_RANK3_R8P, & + W_DATA6_RANK3_R4P, & + W_DATA6_RANK3_I8P, & + W_DATA6_RANK3_I4P, & + W_DATA6_RANK3_I2P, & + W_DATA6_RANK3_I1P, & + W_DATA_LOCATION_TAG !< WRITE DATA (ARRAY). + GENERIC :: WRITE_FIELDDATA => & + WRITE_FIELDDATA1_RANK0, & + WRITE_FIELDDATA_TAG !< WRITE FIELDDATA TAG. + GENERIC :: WRITE_GEO => & + WRITE_GEO_STRG_DATA1_RANK2_R8P, & + WRITE_GEO_STRG_DATA1_RANK2_R4P, & + WRITE_GEO_STRG_DATA1_RANK4_R8P, & + WRITE_GEO_STRG_DATA1_RANK4_R4P, & + WRITE_GEO_STRG_DATA3_RANK1_R8P, & + WRITE_GEO_STRG_DATA3_RANK1_R4P, & + WRITE_GEO_STRG_DATA3_RANK3_R8P, & + WRITE_GEO_STRG_DATA3_RANK3_R4P, & + WRITE_GEO_RECT_DATA3_RANK1_R8P, & + WRITE_GEO_RECT_DATA3_RANK1_R4P, & + WRITE_GEO_UNST_DATA1_RANK2_R8P, & + WRITE_GEO_UNST_DATA1_RANK2_R4P, & + WRITE_GEO_UNST_DATA3_RANK1_R8P, & + WRITE_GEO_UNST_DATA3_RANK1_R4P !< WRITE MESH. + GENERIC :: WRITE_PARALLEL_BLOCK_FILES => & + WRITE_PARALLEL_BLOCK_FILE, & + WRITE_PARALLEL_BLOCK_FILES_ARRAY, & + WRITE_PARALLEL_BLOCK_FILES_STRING !< WRITE BLOCK LIST OF FILES. + GENERIC :: WRITE_PIECE => & + WRITE_PIECE_START_TAG, & + WRITE_PIECE_START_TAG_UNST, & + WRITE_PIECE_END_TAG !< WRITE PIECE START/END TAG. + ! DEFERRED METHODS + PROCEDURE(W_DATA1_RANK1_R8P_INTERFACE), DEFERRED, PASS(SELF) :: W_DATA1_RANK1_R8P !< DATA 1, RANK 1, R8P. + PROCEDURE(W_DATA1_RANK1_R4P_INTERFACE), DEFERRED, PASS(SELF) :: W_DATA1_RANK1_R4P !< DATA 1, RANK 1, R4P. + PROCEDURE(W_DATA1_RANK1_I8P_INTERFACE), DEFERRED, PASS(SELF) :: W_DATA1_RANK1_I8P !< DATA 1, RANK 1, I8P. + PROCEDURE(W_DATA1_RANK1_I4P_INTERFACE), DEFERRED, PASS(SELF) :: W_DATA1_RANK1_I4P !< DATA 1, RANK 1, I4P. + PROCEDURE(W_DATA1_RANK1_I2P_INTERFACE), DEFERRED, PASS(SELF) :: W_DATA1_RANK1_I2P !< DATA 1, RANK 1, I2P. + PROCEDURE(W_DATA1_RANK1_I1P_INTERFACE), DEFERRED, PASS(SELF) :: W_DATA1_RANK1_I1P !< DATA 1, RANK 1, I1P. + PROCEDURE(W_DATA1_RANK2_R8P_INTERFACE), DEFERRED, PASS(SELF) :: W_DATA1_RANK2_R8P !< DATA 1, RANK 2, R8P. + PROCEDURE(W_DATA1_RANK2_R4P_INTERFACE), DEFERRED, PASS(SELF) :: W_DATA1_RANK2_R4P !< DATA 1, RANK 2, R4P. + PROCEDURE(W_DATA1_RANK2_I8P_INTERFACE), DEFERRED, PASS(SELF) :: W_DATA1_RANK2_I8P !< DATA 1, RANK 2, I8P. + PROCEDURE(W_DATA1_RANK2_I4P_INTERFACE), DEFERRED, PASS(SELF) :: W_DATA1_RANK2_I4P !< DATA 1, RANK 2, I4P. + PROCEDURE(W_DATA1_RANK2_I2P_INTERFACE), DEFERRED, PASS(SELF) :: W_DATA1_RANK2_I2P !< DATA 1, RANK 2, I2P. + PROCEDURE(W_DATA1_RANK2_I1P_INTERFACE), DEFERRED, PASS(SELF) :: W_DATA1_RANK2_I1P !< DATA 1, RANK 2, I1P. + PROCEDURE(W_DATA1_RANK3_R8P_INTERFACE), DEFERRED, PASS(SELF) :: W_DATA1_RANK3_R8P !< DATA 1, RANK 3, R8P. + PROCEDURE(W_DATA1_RANK3_R4P_INTERFACE), DEFERRED, PASS(SELF) :: W_DATA1_RANK3_R4P !< DATA 1, RANK 3, R4P. + PROCEDURE(W_DATA1_RANK3_I8P_INTERFACE), DEFERRED, PASS(SELF) :: W_DATA1_RANK3_I8P !< DATA 1, RANK 3, I8P. + PROCEDURE(W_DATA1_RANK3_I4P_INTERFACE), DEFERRED, PASS(SELF) :: W_DATA1_RANK3_I4P !< DATA 1, RANK 3, I4P. + PROCEDURE(W_DATA1_RANK3_I2P_INTERFACE), DEFERRED, PASS(SELF) :: W_DATA1_RANK3_I2P !< DATA 1, RANK 3, I2P. + PROCEDURE(W_DATA1_RANK3_I1P_INTERFACE), DEFERRED, PASS(SELF) :: W_DATA1_RANK3_I1P !< DATA 1, RANK 3, I1P. + PROCEDURE(W_DATA1_RANK4_R8P_INTERFACE), DEFERRED, PASS(SELF) :: W_DATA1_RANK4_R8P !< DATA 1, RANK 4, R8P. + PROCEDURE(W_DATA1_RANK4_R4P_INTERFACE), DEFERRED, PASS(SELF) :: W_DATA1_RANK4_R4P !< DATA 1, RANK 4, R4P. + PROCEDURE(W_DATA1_RANK4_I8P_INTERFACE), DEFERRED, PASS(SELF) :: W_DATA1_RANK4_I8P !< DATA 1, RANK 4, I8P. + PROCEDURE(W_DATA1_RANK4_I4P_INTERFACE), DEFERRED, PASS(SELF) :: W_DATA1_RANK4_I4P !< DATA 1, RANK 4, I4P. + PROCEDURE(W_DATA1_RANK4_I2P_INTERFACE), DEFERRED, PASS(SELF) :: W_DATA1_RANK4_I2P !< DATA 1, RANK 4, I2P. + PROCEDURE(W_DATA1_RANK4_I1P_INTERFACE), DEFERRED, PASS(SELF) :: W_DATA1_RANK4_I1P !< DATA 1, RANK 4, I1P. + PROCEDURE(W_DATA3_RANK1_R8P_INTERFACE), DEFERRED, PASS(SELF) :: W_DATA3_RANK1_R8P !< DATA 3, RANK 1, R8P. + PROCEDURE(W_DATA3_RANK1_R4P_INTERFACE), DEFERRED, PASS(SELF) :: W_DATA3_RANK1_R4P !< DATA 3, RANK 1, R4P. + PROCEDURE(W_DATA3_RANK1_I8P_INTERFACE), DEFERRED, PASS(SELF) :: W_DATA3_RANK1_I8P !< DATA 3, RANK 1, I8P. + PROCEDURE(W_DATA3_RANK1_I4P_INTERFACE), DEFERRED, PASS(SELF) :: W_DATA3_RANK1_I4P !< DATA 3, RANK 1, I4P. + PROCEDURE(W_DATA3_RANK1_I2P_INTERFACE), DEFERRED, PASS(SELF) :: W_DATA3_RANK1_I2P !< DATA 3, RANK 1, I2P. + PROCEDURE(W_DATA3_RANK1_I1P_INTERFACE), DEFERRED, PASS(SELF) :: W_DATA3_RANK1_I1P !< DATA 3, RANK 1, I1P. + PROCEDURE(W_DATA3_RANK3_R8P_INTERFACE), DEFERRED, PASS(SELF) :: W_DATA3_RANK3_R8P !< DATA 3, RANK 3, R8P. + PROCEDURE(W_DATA3_RANK3_R4P_INTERFACE), DEFERRED, PASS(SELF) :: W_DATA3_RANK3_R4P !< DATA 3, RANK 3, R4P. + PROCEDURE(W_DATA3_RANK3_I8P_INTERFACE), DEFERRED, PASS(SELF) :: W_DATA3_RANK3_I8P !< DATA 3, RANK 3, I8P. + PROCEDURE(W_DATA3_RANK3_I4P_INTERFACE), DEFERRED, PASS(SELF) :: W_DATA3_RANK3_I4P !< DATA 3, RANK 3, I4P. + PROCEDURE(W_DATA3_RANK3_I2P_INTERFACE), DEFERRED, PASS(SELF) :: W_DATA3_RANK3_I2P !< DATA 3, RANK 3, I2P. + PROCEDURE(W_DATA3_RANK3_I1P_INTERFACE), DEFERRED, PASS(SELF) :: W_DATA3_RANK3_I1P !< DATA 3, RANK 3, I1P. + PROCEDURE(W_DATA6_RANK1_R8P_INTERFACE), DEFERRED, PASS(SELF) :: W_DATA6_RANK1_R8P !< DATA 3, RANK 1, R8P. + PROCEDURE(W_DATA6_RANK1_R4P_INTERFACE), DEFERRED, PASS(SELF) :: W_DATA6_RANK1_R4P !< DATA 3, RANK 1, R4P. + PROCEDURE(W_DATA6_RANK1_I8P_INTERFACE), DEFERRED, PASS(SELF) :: W_DATA6_RANK1_I8P !< DATA 3, RANK 1, I8P. + PROCEDURE(W_DATA6_RANK1_I4P_INTERFACE), DEFERRED, PASS(SELF) :: W_DATA6_RANK1_I4P !< DATA 3, RANK 1, I4P. + PROCEDURE(W_DATA6_RANK1_I2P_INTERFACE), DEFERRED, PASS(SELF) :: W_DATA6_RANK1_I2P !< DATA 3, RANK 1, I2P. + PROCEDURE(W_DATA6_RANK1_I1P_INTERFACE), DEFERRED, PASS(SELF) :: W_DATA6_RANK1_I1P !< DATA 3, RANK 1, I1P. + PROCEDURE(W_DATA6_RANK3_R8P_INTERFACE), DEFERRED, PASS(SELF) :: W_DATA6_RANK3_R8P !< DATA 3, RANK 3, R8P. + PROCEDURE(W_DATA6_RANK3_R4P_INTERFACE), DEFERRED, PASS(SELF) :: W_DATA6_RANK3_R4P !< DATA 3, RANK 3, R4P. + PROCEDURE(W_DATA6_RANK3_I8P_INTERFACE), DEFERRED, PASS(SELF) :: W_DATA6_RANK3_I8P !< DATA 3, RANK 3, I8P. + PROCEDURE(W_DATA6_RANK3_I4P_INTERFACE), DEFERRED, PASS(SELF) :: W_DATA6_RANK3_I4P !< DATA 3, RANK 3, I4P. + PROCEDURE(W_DATA6_RANK3_I2P_INTERFACE), DEFERRED, PASS(SELF) :: W_DATA6_RANK3_I2P !< DATA 3, RANK 3, I2P. + PROCEDURE(W_DATA6_RANK3_I1P_INTERFACE), DEFERRED, PASS(SELF) :: W_DATA6_RANK3_I1P !< DATA 3, RANK 3, I1P. + PROCEDURE(W_DATA_APPENDED_INTERFACE), DEFERRED, PASS(SELF) :: W_DATA_APPENDED !< WRITE APPENDED. + ! PRIVATE METHODS + PROCEDURE, PASS(SELF), PRIVATE :: WRITE_FIELDDATA1_RANK0 !< WRITE FIELDDATA TAG (DATA 1, RANK 0, R8P). + PROCEDURE, PASS(SELF), PRIVATE :: WRITE_FIELDDATA_TAG !< WRITE FIELDDATA TAG. + PROCEDURE, PASS(SELF), PRIVATE :: WRITE_GEO_STRG_DATA1_RANK2_R8P !< WRITE **STRUCTUREDGRID** MESH (DATA 1, RANK 2, R8P). + PROCEDURE, PASS(SELF), PRIVATE :: WRITE_GEO_STRG_DATA1_RANK2_R4P !< WRITE **STRUCTUREDGRID** MESH (DATA 1, RANK 2, R4P). + PROCEDURE, PASS(SELF), PRIVATE :: WRITE_GEO_STRG_DATA1_RANK4_R8P !< WRITE **STRUCTUREDGRID** MESH (DATA 1, RANK 4, R8P). + PROCEDURE, PASS(SELF), PRIVATE :: WRITE_GEO_STRG_DATA1_RANK4_R4P !< WRITE **STRUCTUREDGRID** MESH (DATA 1, RANK 4, R4P). + PROCEDURE, PASS(SELF), PRIVATE :: WRITE_GEO_STRG_DATA3_RANK1_R8P !< WRITE **STRUCTUREDGRID** MESH (DATA 3, RANK 1, R8P). + PROCEDURE, PASS(SELF), PRIVATE :: WRITE_GEO_STRG_DATA3_RANK1_R4P !< WRITE **STRUCTUREDGRID** MESH (DATA 3, RANK 1, R4P). + PROCEDURE, PASS(SELF), PRIVATE :: WRITE_GEO_STRG_DATA3_RANK3_R8P !< WRITE **STRUCTUREDGRID** MESH (DATA 3, RANK 3, R8P). + PROCEDURE, PASS(SELF), PRIVATE :: WRITE_GEO_STRG_DATA3_RANK3_R4P !< WRITE **STRUCTUREDGRID** MESH (DATA 3, RANK 3, R4P). + PROCEDURE, PASS(SELF), PRIVATE :: WRITE_GEO_RECT_DATA3_RANK1_R8P !< WRITE **RECTILINEARGRID** MESH (DATA 3, RANK 1, R8P). + PROCEDURE, PASS(SELF), PRIVATE :: WRITE_GEO_RECT_DATA3_RANK1_R4P !< WRITE **RECTILINEARGRID** MESH (DATA 3, RANK 1, R4P). + PROCEDURE, PASS(SELF), PRIVATE :: WRITE_GEO_UNST_DATA1_RANK2_R8P !< WRITE **UNSTRUCTUREDGRID** MESH (DATA 1, RANK 2, R8P). + PROCEDURE, PASS(SELF), PRIVATE :: WRITE_GEO_UNST_DATA1_RANK2_R4P !< WRITE **UNSTRUCTUREDGRID** MESH (DATA 1, RANK 2, R4P). + PROCEDURE, PASS(SELF), PRIVATE :: WRITE_GEO_UNST_DATA3_RANK1_R8P !< WRITE **UNSTRUCTUREDGRID** MESH (DATA 3, RANK 1, R8P). + PROCEDURE, PASS(SELF), PRIVATE :: WRITE_GEO_UNST_DATA3_RANK1_R4P !< WRITE **UNSTRUCTUREDGRID** MESH (DATA 3, RANK 1, R4P). + PROCEDURE, PASS(SELF), PRIVATE :: WRITE_PIECE_START_TAG !< WRITE `<PIECE ...>` START TAG. + PROCEDURE, PASS(SELF), PRIVATE :: WRITE_PIECE_START_TAG_UNST !< WRITE `<PIECE ...>` START TAG FOR UNSTRUCTURED TOPOLOGY. + PROCEDURE, PASS(SELF), PRIVATE :: WRITE_PIECE_END_TAG !< WRITE `</PIECE>` END TAG. + PROCEDURE, PASS(SELF), PRIVATE :: WRITE_PARALLEL_BLOCK_FILE !< WRITE SINGLE FILE THAT BELONG TO THE CURRENT BLOCK. + PROCEDURE, PASS(SELF), PRIVATE :: WRITE_PARALLEL_BLOCK_FILES_ARRAY !< WRITE BLOCK LIST OF FILES (ARRAY INPUT). + PROCEDURE, PASS(SELF), PRIVATE :: WRITE_PARALLEL_BLOCK_FILES_STRING !< WRITE BLOCK LIST OF FILES (STRING INPUT). +ENDTYPE XML_WRITER_ABSTRACT + +ABSTRACT INTERFACE + FUNCTION INITIALIZE_INTERFACE(SELF, FORMAT, FILENAME, MESH_TOPOLOGY, NX1, NX2, NY1, NY2, NZ1, NZ2, & + IS_VOLATILE, MESH_KIND) RESULT(ERROR) + !< INITIALIZE WRITER. + IMPORT :: XML_WRITER_ABSTRACT, I4P + CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT) :: SELF !< WRITER. + CHARACTER(*), INTENT(IN) :: FORMAT !< FILE FORMAT: ASCII. + CHARACTER(*), INTENT(IN) :: FILENAME !< FILE NAME. + CHARACTER(*), INTENT(IN) :: MESH_TOPOLOGY !< MESH TOPOLOGY. + INTEGER(I4P), INTENT(IN), OPTIONAL :: NX1 !< INITIAL NODE OF X AXIS. + INTEGER(I4P), INTENT(IN), OPTIONAL :: NX2 !< FINAL NODE OF X AXIS. + INTEGER(I4P), INTENT(IN), OPTIONAL :: NY1 !< INITIAL NODE OF Y AXIS. + INTEGER(I4P), INTENT(IN), OPTIONAL :: NY2 !< FINAL NODE OF Y AXIS. + INTEGER(I4P), INTENT(IN), OPTIONAL :: NZ1 !< INITIAL NODE OF Z AXIS. + INTEGER(I4P), INTENT(IN), OPTIONAL :: NZ2 !< FINAL NODE OF Z AXIS. + CHARACTER(*), INTENT(IN), OPTIONAL :: MESH_KIND !< KIND OF MESH DATA: FLOAT64, FLOAT32, ECC. + LOGICAL, INTENT(IN), OPTIONAL :: IS_VOLATILE !< FLAG TO CHECK VOLATILE WRITER. + INTEGER(I4P) :: ERROR !< ERROR STATUS. + ENDFUNCTION INITIALIZE_INTERFACE + + FUNCTION FINALIZE_INTERFACE(SELF) RESULT(ERROR) + !< FINALIZE WRITER. + IMPORT :: XML_WRITER_ABSTRACT, I4P + CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT) :: SELF !< WRITER. + INTEGER(I4P) :: ERROR !< ERROR STATUS. + ENDFUNCTION FINALIZE_INTERFACE + + FUNCTION W_DATA1_RANK1_R8P_INTERFACE(SELF, DATA_NAME, X, IS_TUPLES) RESULT(ERROR) + !< WRITE `<DATAARRAY... NumberOfComponents="1"...>...</DATAARRAY>` TAG (R8P). + IMPORT :: XML_WRITER_ABSTRACT, I4P, R8P + CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT) :: SELF !< WRITER. + CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. + REAL(R8P), INTENT(IN) :: X(1:) !< DATA VARIABLE. + LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". + INTEGER(I4P) :: ERROR !< ERROR STATUS. + ENDFUNCTION W_DATA1_RANK1_R8P_INTERFACE + + FUNCTION W_DATA1_RANK1_R4P_INTERFACE(SELF, DATA_NAME, X, IS_TUPLES) RESULT(ERROR) + !< WRITE `<DATAARRAY... NumberOfComponents="1"...>...</DATAARRAY>` TAG (R4P). + IMPORT :: XML_WRITER_ABSTRACT, I4P, R4P + CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT) :: SELF !< WRITER. + CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. + REAL(R4P), INTENT(IN) :: X(1:) !< DATA VARIABLE. + LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". + INTEGER(I4P) :: ERROR !< ERROR STATUS. + ENDFUNCTION W_DATA1_RANK1_R4P_INTERFACE + + FUNCTION W_DATA1_RANK1_I8P_INTERFACE(SELF, DATA_NAME, X, IS_TUPLES) RESULT(ERROR) + !< WRITE `<DATAARRAY... NumberOfComponents="1"...>...</DATAARRAY>` TAG (I8P). + IMPORT :: XML_WRITER_ABSTRACT, I4P, I8P + CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT) :: SELF !< WRITER. + CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. + INTEGER(I8P), INTENT(IN) :: X(1:) !< DATA VARIABLE. + LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". + INTEGER(I4P) :: ERROR !< ERROR STATUS. + ENDFUNCTION W_DATA1_RANK1_I8P_INTERFACE + + FUNCTION W_DATA1_RANK1_I4P_INTERFACE(SELF, DATA_NAME, X, IS_TUPLES) RESULT(ERROR) + !< WRITE `<DATAARRAY... NumberOfComponents="1"...>...</DATAARRAY>` TAG (I4P). + IMPORT :: XML_WRITER_ABSTRACT, I4P + CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT) :: SELF !< WRITER. + CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. + INTEGER(I4P), INTENT(IN) :: X(1:) !< DATA VARIABLE. + LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". + INTEGER(I4P) :: ERROR !< ERROR STATUS. + ENDFUNCTION W_DATA1_RANK1_I4P_INTERFACE + + FUNCTION W_DATA1_RANK1_I2P_INTERFACE(SELF, DATA_NAME, X, IS_TUPLES) RESULT(ERROR) + !< WRITE `<DATAARRAY... NumberOfComponents="1"...>...</DATAARRAY>` TAG (I2P). + IMPORT :: XML_WRITER_ABSTRACT, I2P, I4P + CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT) :: SELF !< WRITER. + CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. + INTEGER(I2P), INTENT(IN) :: X(1:) !< DATA VARIABLE. + LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". + INTEGER(I4P) :: ERROR !< ERROR STATUS. + ENDFUNCTION W_DATA1_RANK1_I2P_INTERFACE + + FUNCTION W_DATA1_RANK1_I1P_INTERFACE(SELF, DATA_NAME, X, IS_TUPLES) RESULT(ERROR) + !< WRITE `<DATAARRAY... NumberOfComponents="1"...>...</DATAARRAY>` TAG (I1P). + IMPORT :: XML_WRITER_ABSTRACT, I1P, I4P + CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT) :: SELF !< WRITER. + CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. + INTEGER(I1P), INTENT(IN) :: X(1:) !< DATA VARIABLE. + LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". + INTEGER(I4P) :: ERROR !< ERROR STATUS. + ENDFUNCTION W_DATA1_RANK1_I1P_INTERFACE + + FUNCTION W_DATA1_RANK2_R8P_INTERFACE(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR) + !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (R8P). + IMPORT :: XML_WRITER_ABSTRACT, I4P, R8P + CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT) :: SELF !< WRITER. + CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. + REAL(R8P), INTENT(IN) :: X(1:,1:) !< DATA VARIABLE. + LOGICAL, INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT. + LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". + INTEGER(I4P) :: ERROR !< ERROR STATUS. + ENDFUNCTION W_DATA1_RANK2_R8P_INTERFACE + + FUNCTION W_DATA1_RANK2_R4P_INTERFACE(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR) + !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (R4P). + IMPORT :: XML_WRITER_ABSTRACT, I4P, R4P + CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT) :: SELF !< WRITER. + CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. + REAL(R4P), INTENT(IN) :: X(1:,1:) !< DATA VARIABLE. + LOGICAL, INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT. + LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". + INTEGER(I4P) :: ERROR !< ERROR STATUS. + ENDFUNCTION W_DATA1_RANK2_R4P_INTERFACE + + FUNCTION W_DATA1_RANK2_I8P_INTERFACE(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR) + !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (I8P). + IMPORT :: XML_WRITER_ABSTRACT, I4P, I8P + CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT) :: SELF !< WRITER. + CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. + INTEGER(I8P), INTENT(IN) :: X(1:,1:) !< DATA VARIABLE. + LOGICAL, INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT. + LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". + INTEGER(I4P) :: ERROR !< ERROR STATUS. + ENDFUNCTION W_DATA1_RANK2_I8P_INTERFACE + + FUNCTION W_DATA1_RANK2_I4P_INTERFACE(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR) + !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (I4P). + IMPORT :: XML_WRITER_ABSTRACT, I4P + CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT) :: SELF !< WRITER. + CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. + INTEGER(I4P), INTENT(IN) :: X(1:,1:) !< DATA VARIABLE. + LOGICAL, INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT. + LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". + INTEGER(I4P) :: ERROR !< ERROR STATUS. + ENDFUNCTION W_DATA1_RANK2_I4P_INTERFACE + + FUNCTION W_DATA1_RANK2_I2P_INTERFACE(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR) + !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (I2P). + IMPORT :: XML_WRITER_ABSTRACT, I2P, I4P + CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT) :: SELF !< WRITER. + CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. + INTEGER(I2P), INTENT(IN) :: X(1:,1:) !< DATA VARIABLE. + LOGICAL, INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT. + LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". + INTEGER(I4P) :: ERROR !< ERROR STATUS. + ENDFUNCTION W_DATA1_RANK2_I2P_INTERFACE + + FUNCTION W_DATA1_RANK2_I1P_INTERFACE(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR) + !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (I1P). + IMPORT :: XML_WRITER_ABSTRACT, I1P, I4P + CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT) :: SELF !< WRITER. + CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. + INTEGER(I1P), INTENT(IN) :: X(1:,1:) !< DATA VARIABLE. + LOGICAL, INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT. + LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". + INTEGER(I4P) :: ERROR !< ERROR STATUS. + ENDFUNCTION W_DATA1_RANK2_I1P_INTERFACE + + FUNCTION W_DATA1_RANK3_R8P_INTERFACE(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR) + !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (R8P). + IMPORT :: XML_WRITER_ABSTRACT, I4P, R8P + CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT) :: SELF !< WRITER. + CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. + REAL(R8P), INTENT(IN) :: X(1:,1:,1:) !< DATA VARIABLE. + LOGICAL, INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT. + LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". + INTEGER(I4P) :: ERROR !< ERROR STATUS. + ENDFUNCTION W_DATA1_RANK3_R8P_INTERFACE + + FUNCTION W_DATA1_RANK3_R4P_INTERFACE(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR) + !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (R4P). + IMPORT :: XML_WRITER_ABSTRACT, I4P, R4P + CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT) :: SELF !< WRITER. + CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. + REAL(R4P), INTENT(IN) :: X(1:,1:,1:) !< DATA VARIABLE. + LOGICAL, INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT. + LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". + INTEGER(I4P) :: ERROR !< ERROR STATUS. + ENDFUNCTION W_DATA1_RANK3_R4P_INTERFACE + + FUNCTION W_DATA1_RANK3_I8P_INTERFACE(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR) + !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (I8P). + IMPORT :: XML_WRITER_ABSTRACT, I4P, I8P + CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT) :: SELF !< WRITER. + CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. + INTEGER(I8P), INTENT(IN) :: X(1:,1:,1:) !< DATA VARIABLE. + LOGICAL, INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT. + LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". + INTEGER(I4P) :: ERROR !< ERROR STATUS. + ENDFUNCTION W_DATA1_RANK3_I8P_INTERFACE + + FUNCTION W_DATA1_RANK3_I4P_INTERFACE(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR) + !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (I4P). + IMPORT :: XML_WRITER_ABSTRACT, I4P + CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT) :: SELF !< WRITER. + CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. + INTEGER(I4P), INTENT(IN) :: X(1:,1:,1:) !< DATA VARIABLE. + LOGICAL, INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT. + LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". + INTEGER(I4P) :: ERROR !< ERROR STATUS. + ENDFUNCTION W_DATA1_RANK3_I4P_INTERFACE + + FUNCTION W_DATA1_RANK3_I2P_INTERFACE(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR) + !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (I2P). + IMPORT :: XML_WRITER_ABSTRACT, I2P, I4P + CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT) :: SELF !< WRITER. + CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. + INTEGER(I2P), INTENT(IN) :: X(1:,1:,1:) !< DATA VARIABLE. + LOGICAL, INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT. + LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". + INTEGER(I4P) :: ERROR !< ERROR STATUS. + ENDFUNCTION W_DATA1_RANK3_I2P_INTERFACE + + FUNCTION W_DATA1_RANK3_I1P_INTERFACE(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR) + !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (I1P). + IMPORT :: XML_WRITER_ABSTRACT, I1P, I4P + CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT) :: SELF !< WRITER. + CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. + INTEGER(I1P), INTENT(IN) :: X(1:,1:,1:) !< DATA VARIABLE. + LOGICAL, INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT. + LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". + INTEGER(I4P) :: ERROR !< ERROR STATUS. + ENDFUNCTION W_DATA1_RANK3_I1P_INTERFACE + + FUNCTION W_DATA1_RANK4_R8P_INTERFACE(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR) + !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (R8P). + IMPORT :: XML_WRITER_ABSTRACT, I4P, R8P + CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT) :: SELF !< WRITER. + CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. + REAL(R8P), INTENT(IN) :: X(1:,1:,1:,1:) !< DATA VARIABLE. + LOGICAL, INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT. + LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". + INTEGER(I4P) :: ERROR !< ERROR STATUS. + ENDFUNCTION W_DATA1_RANK4_R8P_INTERFACE + + FUNCTION W_DATA1_RANK4_R4P_INTERFACE(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR) + !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (R4P). + IMPORT :: XML_WRITER_ABSTRACT, I4P, R4P + CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT) :: SELF !< WRITER. + CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. + REAL(R4P), INTENT(IN) :: X(1:,1:,1:,1:) !< DATA VARIABLE. + LOGICAL, INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT. + LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". + INTEGER(I4P) :: ERROR !< ERROR STATUS. + ENDFUNCTION W_DATA1_RANK4_R4P_INTERFACE + + FUNCTION W_DATA1_RANK4_I8P_INTERFACE(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR) + !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (I8P). + IMPORT :: XML_WRITER_ABSTRACT, I4P, I8P + CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT) :: SELF !< WRITER. + CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. + INTEGER(I8P), INTENT(IN) :: X(1:,1:,1:,1:) !< DATA VARIABLE. + LOGICAL, INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT. + LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". + INTEGER(I4P) :: ERROR !< ERROR STATUS. + ENDFUNCTION W_DATA1_RANK4_I8P_INTERFACE + + FUNCTION W_DATA1_RANK4_I4P_INTERFACE(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR) + !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (I4P). + IMPORT :: XML_WRITER_ABSTRACT, I4P + CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT) :: SELF !< WRITER. + CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. + INTEGER(I4P), INTENT(IN) :: X(1:,1:,1:,1:) !< DATA VARIABLE. + LOGICAL, INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT. + LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". + INTEGER(I4P) :: ERROR !< ERROR STATUS. + ENDFUNCTION W_DATA1_RANK4_I4P_INTERFACE + + FUNCTION W_DATA1_RANK4_I2P_INTERFACE(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR) + !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (I2P). + IMPORT :: XML_WRITER_ABSTRACT, I2P, I4P + CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT) :: SELF !< WRITER. + CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. + INTEGER(I2P), INTENT(IN) :: X(1:,1:,1:,1:) !< DATA VARIABLE. + LOGICAL, INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT. + LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". + INTEGER(I4P) :: ERROR !< ERROR STATUS. + ENDFUNCTION W_DATA1_RANK4_I2P_INTERFACE + + FUNCTION W_DATA1_RANK4_I1P_INTERFACE(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR) + !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (I1P). + IMPORT :: XML_WRITER_ABSTRACT, I1P, I4P + CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT) :: SELF !< WRITER. + CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. + INTEGER(I1P), INTENT(IN) :: X(1:,1:,1:,1:) !< DATA VARIABLE. + LOGICAL, INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT. + LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". + INTEGER(I4P) :: ERROR !< ERROR STATUS. + ENDFUNCTION W_DATA1_RANK4_I1P_INTERFACE + + FUNCTION W_DATA3_RANK1_R8P_INTERFACE(SELF, DATA_NAME, X, Y, Z, IS_TUPLES) RESULT(ERROR) + !< WRITE `<DATAARRAY... NumberOfComponents="3"...>...</DATAARRAY>` TAG (R8P). + IMPORT :: XML_WRITER_ABSTRACT, I4P, R8P + CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT) :: SELF !< WRITER. + CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. + REAL(R8P), INTENT(IN) :: X(1:) !< X COMPONENT OF DATA VARIABLE. + REAL(R8P), INTENT(IN) :: Y(1:) !< Y COMPONENT OF DATA VARIABLE. + REAL(R8P), INTENT(IN) :: Z(1:) !< Z COMPONENT OF DATA VARIABLE. + LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". + INTEGER(I4P) :: ERROR !< ERROR STATUS. + ENDFUNCTION W_DATA3_RANK1_R8P_INTERFACE + + FUNCTION W_DATA3_RANK1_R4P_INTERFACE(SELF, DATA_NAME, X, Y, Z, IS_TUPLES) RESULT(ERROR) + !< WRITE `<DATAARRAY... NumberOfComponents="3"...>...</DATAARRAY>` TAG (R4P). + IMPORT :: XML_WRITER_ABSTRACT, I4P, R4P + CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT) :: SELF !< WRITER. + CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. + REAL(R4P), INTENT(IN) :: X(1:) !< X COMPONENT OF DATA VARIABLE. + REAL(R4P), INTENT(IN) :: Y(1:) !< Y COMPONENT OF DATA VARIABLE. + REAL(R4P), INTENT(IN) :: Z(1:) !< Z COMPONENT OF DATA VARIABLE. + LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". + INTEGER(I4P) :: ERROR !< ERROR STATUS. + ENDFUNCTION W_DATA3_RANK1_R4P_INTERFACE + + FUNCTION W_DATA3_RANK1_I8P_INTERFACE(SELF, DATA_NAME, X, Y, Z, IS_TUPLES) RESULT(ERROR) + !< WRITE `<DATAARRAY... NumberOfComponents="3"...>...</DATAARRAY>` TAG (I8P). + IMPORT :: XML_WRITER_ABSTRACT, I4P, I8P + CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT) :: SELF !< WRITER. + CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. + INTEGER(I8P), INTENT(IN) :: X(1:) !< X COMPONENT OF DATA VARIABLE. + INTEGER(I8P), INTENT(IN) :: Y(1:) !< Y COMPONENT OF DATA VARIABLE. + INTEGER(I8P), INTENT(IN) :: Z(1:) !< Z COMPONENT OF DATA VARIABLE. + LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". + INTEGER(I4P) :: ERROR !< ERROR STATUS. + ENDFUNCTION W_DATA3_RANK1_I8P_INTERFACE + + FUNCTION W_DATA3_RANK1_I4P_INTERFACE(SELF, DATA_NAME, X, Y, Z, IS_TUPLES) RESULT(ERROR) + !< WRITE `<DATAARRAY... NumberOfComponents="3"...>...</DATAARRAY>` TAG (I4P). + IMPORT :: XML_WRITER_ABSTRACT, I4P + CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT) :: SELF !< WRITER. + CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. + INTEGER(I4P), INTENT(IN) :: X(1:) !< X COMPONENT OF DATA VARIABLE. + INTEGER(I4P), INTENT(IN) :: Y(1:) !< Y COMPONENT OF DATA VARIABLE. + INTEGER(I4P), INTENT(IN) :: Z(1:) !< Z COMPONENT OF DATA VARIABLE. + LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". + INTEGER(I4P) :: ERROR !< ERROR STATUS. + ENDFUNCTION W_DATA3_RANK1_I4P_INTERFACE + + FUNCTION W_DATA3_RANK1_I2P_INTERFACE(SELF, DATA_NAME, X, Y, Z, IS_TUPLES) RESULT(ERROR) + !< WRITE `<DATAARRAY... NumberOfComponents="3"...>...</DATAARRAY>` TAG (I2P). + IMPORT :: XML_WRITER_ABSTRACT, I2P, I4P + CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT) :: SELF !< WRITER. + CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. + INTEGER(I2P), INTENT(IN) :: X(1:) !< X COMPONENT OF DATA VARIABLE. + INTEGER(I2P), INTENT(IN) :: Y(1:) !< Y COMPONENT OF DATA VARIABLE. + INTEGER(I2P), INTENT(IN) :: Z(1:) !< Z COMPONENT OF DATA VARIABLE. + LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". + INTEGER(I4P) :: ERROR !< ERROR STATUS. + ENDFUNCTION W_DATA3_RANK1_I2P_INTERFACE + + FUNCTION W_DATA3_RANK1_I1P_INTERFACE(SELF, DATA_NAME, X, Y, Z, IS_TUPLES) RESULT(ERROR) + !< WRITE `<DATAARRAY... NumberOfComponents="3"...>...</DATAARRAY>` TAG (I1P). + IMPORT :: XML_WRITER_ABSTRACT, I1P, I4P + CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT) :: SELF !< WRITER. + CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. + INTEGER(I1P), INTENT(IN) :: X(1:) !< X COMPONENT OF DATA VARIABLE. + INTEGER(I1P), INTENT(IN) :: Y(1:) !< Y COMPONENT OF DATA VARIABLE. + INTEGER(I1P), INTENT(IN) :: Z(1:) !< Z COMPONENT OF DATA VARIABLE. + LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". + INTEGER(I4P) :: ERROR !< ERROR STATUS. + ENDFUNCTION W_DATA3_RANK1_I1P_INTERFACE + + FUNCTION W_DATA3_RANK3_R8P_INTERFACE(SELF, DATA_NAME, X, Y, Z, IS_TUPLES) RESULT(ERROR) + !< WRITE `<DATAARRAY... NumberOfComponents="3"...>...</DATAARRAY>` TAG (R8P). + IMPORT :: XML_WRITER_ABSTRACT, I4P, R8P + CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT) :: SELF !< WRITER. + CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. + REAL(R8P), INTENT(IN) :: X(1:,1:,1:) !< X COMPONENT OF DATA VARIABLE. + REAL(R8P), INTENT(IN) :: Y(1:,1:,1:) !< Y COMPONENT OF DATA VARIABLE. + REAL(R8P), INTENT(IN) :: Z(1:,1:,1:) !< Z COMPONENT OF DATA VARIABLE. + LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". + INTEGER(I4P) :: ERROR !< ERROR STATUS. + ENDFUNCTION W_DATA3_RANK3_R8P_INTERFACE + + FUNCTION W_DATA3_RANK3_R4P_INTERFACE(SELF, DATA_NAME, X, Y, Z, IS_TUPLES) RESULT(ERROR) + !< WRITE `<DATAARRAY... NumberOfComponents="3"...>...</DATAARRAY>` TAG (R4P). + IMPORT :: XML_WRITER_ABSTRACT, I4P, R4P + CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT) :: SELF !< WRITER. + CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. + REAL(R4P), INTENT(IN) :: X(1:,1:,1:) !< X COMPONENT OF DATA VARIABLE. + REAL(R4P), INTENT(IN) :: Y(1:,1:,1:) !< Y COMPONENT OF DATA VARIABLE. + REAL(R4P), INTENT(IN) :: Z(1:,1:,1:) !< Z COMPONENT OF DATA VARIABLE. + LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". + INTEGER(I4P) :: ERROR !< ERROR STATUS. + ENDFUNCTION W_DATA3_RANK3_R4P_INTERFACE + + FUNCTION W_DATA3_RANK3_I8P_INTERFACE(SELF, DATA_NAME, X, Y, Z, IS_TUPLES) RESULT(ERROR) + !< WRITE `<DATAARRAY... NumberOfComponents="3"...>...</DATAARRAY>` TAG (I8P). + IMPORT :: XML_WRITER_ABSTRACT, I4P, I8P + CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT) :: SELF !< WRITER. + CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. + INTEGER(I8P), INTENT(IN) :: X(1:,1:,1:) !< X COMPONENT OF DATA VARIABLE. + INTEGER(I8P), INTENT(IN) :: Y(1:,1:,1:) !< Y COMPONENT OF DATA VARIABLE. + INTEGER(I8P), INTENT(IN) :: Z(1:,1:,1:) !< Z COMPONENT OF DATA VARIABLE. + LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". + INTEGER(I4P) :: ERROR !< ERROR STATUS. + ENDFUNCTION W_DATA3_RANK3_I8P_INTERFACE + + FUNCTION W_DATA3_RANK3_I4P_INTERFACE(SELF, DATA_NAME, X, Y, Z, IS_TUPLES) RESULT(ERROR) + !< WRITE `<DATAARRAY... NumberOfComponents="3"...>...</DATAARRAY>` TAG (I4P). + IMPORT :: XML_WRITER_ABSTRACT, I4P + CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT) :: SELF !< WRITER. + CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. + INTEGER(I4P), INTENT(IN) :: X(1:,1:,1:) !< X COMPONENT OF DATA VARIABLE. + INTEGER(I4P), INTENT(IN) :: Y(1:,1:,1:) !< Y COMPONENT OF DATA VARIABLE. + INTEGER(I4P), INTENT(IN) :: Z(1:,1:,1:) !< Z COMPONENT OF DATA VARIABLE. + LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". + INTEGER(I4P) :: ERROR !< ERROR STATUS. + ENDFUNCTION W_DATA3_RANK3_I4P_INTERFACE + + FUNCTION W_DATA3_RANK3_I2P_INTERFACE(SELF, DATA_NAME, X, Y, Z, IS_TUPLES) RESULT(ERROR) + !< WRITE `<DATAARRAY... NumberOfComponents="3"...>...</DATAARRAY>` TAG (I2P). + IMPORT :: XML_WRITER_ABSTRACT, I2P, I4P + CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT) :: SELF !< WRITER. + CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. + INTEGER(I2P), INTENT(IN) :: X(1:,1:,1:) !< X COMPONENT OF DATA VARIABLE. + INTEGER(I2P), INTENT(IN) :: Y(1:,1:,1:) !< Y COMPONENT OF DATA VARIABLE. + INTEGER(I2P), INTENT(IN) :: Z(1:,1:,1:) !< Z COMPONENT OF DATA VARIABLE. + LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". + INTEGER(I4P) :: ERROR !< ERROR STATUS. + ENDFUNCTION W_DATA3_RANK3_I2P_INTERFACE + + FUNCTION W_DATA3_RANK3_I1P_INTERFACE(SELF, DATA_NAME, X, Y, Z, IS_TUPLES) RESULT(ERROR) + !< WRITE `<DATAARRAY... NumberOfComponents="3"...>...</DATAARRAY>` TAG (I1P). + IMPORT :: XML_WRITER_ABSTRACT, I1P, I4P + CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT) :: SELF !< WRITER. + CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. + INTEGER(I1P), INTENT(IN) :: X(1:,1:,1:) !< X COMPONENT OF DATA VARIABLE. + INTEGER(I1P), INTENT(IN) :: Y(1:,1:,1:) !< Y COMPONENT OF DATA VARIABLE. + INTEGER(I1P), INTENT(IN) :: Z(1:,1:,1:) !< Z COMPONENT OF DATA VARIABLE. + LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". + INTEGER(I4P) :: ERROR !< ERROR STATUS. + ENDFUNCTION W_DATA3_RANK3_I1P_INTERFACE + + FUNCTION W_DATA6_RANK1_R8P_INTERFACE(SELF, DATA_NAME, U, V, W, X, Y, Z, IS_TUPLES) RESULT(ERROR) + !< WRITE `<DATAARRAY... NumberOfComponents="6"...>...</DATAARRAY>` TAG (R8P). + IMPORT :: XML_WRITER_ABSTRACT, I4P, R8P + CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT) :: SELF !< WRITER. + CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. + REAL(R8P), INTENT(IN) :: U(1:) !< U COMPONENT OF DATA VARIABLE. + REAL(R8P), INTENT(IN) :: V(1:) !< V COMPONENT OF DATA VARIABLE. + REAL(R8P), INTENT(IN) :: W(1:) !< W COMPONENT OF DATA VARIABLE. + REAL(R8P), INTENT(IN) :: X(1:) !< X COMPONENT OF DATA VARIABLE. + REAL(R8P), INTENT(IN) :: Y(1:) !< Y COMPONENT OF DATA VARIABLE. + REAL(R8P), INTENT(IN) :: Z(1:) !< Z COMPONENT OF DATA VARIABLE. + LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". + INTEGER(I4P) :: ERROR !< ERROR STATUS. + ENDFUNCTION W_DATA6_RANK1_R8P_INTERFACE + + FUNCTION W_DATA6_RANK1_R4P_INTERFACE(SELF, DATA_NAME, U, V, W, X, Y, Z, IS_TUPLES) RESULT(ERROR) + !< WRITE `<DATAARRAY... NumberOfComponents="6"...>...</DATAARRAY>` TAG (R4P). + IMPORT :: XML_WRITER_ABSTRACT, I4P, R4P + CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT) :: SELF !< WRITER. + CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. + REAL(R4P), INTENT(IN) :: U(1:) !< U COMPONENT OF DATA VARIABLE. + REAL(R4P), INTENT(IN) :: V(1:) !< V COMPONENT OF DATA VARIABLE. + REAL(R4P), INTENT(IN) :: W(1:) !< W COMPONENT OF DATA VARIABLE. + REAL(R4P), INTENT(IN) :: X(1:) !< X COMPONENT OF DATA VARIABLE. + REAL(R4P), INTENT(IN) :: Y(1:) !< Y COMPONENT OF DATA VARIABLE. + REAL(R4P), INTENT(IN) :: Z(1:) !< Z COMPONENT OF DATA VARIABLE. + LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". + INTEGER(I4P) :: ERROR !< ERROR STATUS. + ENDFUNCTION W_DATA6_RANK1_R4P_INTERFACE + + FUNCTION W_DATA6_RANK1_I8P_INTERFACE(SELF, DATA_NAME, U, V, W, X, Y, Z, IS_TUPLES) RESULT(ERROR) + !< WRITE `<DATAARRAY... NumberOfComponents="6"...>...</DATAARRAY>` TAG (I8P). + IMPORT :: XML_WRITER_ABSTRACT, I4P, I8P + CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT) :: SELF !< WRITER. + CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. + INTEGER(I8P), INTENT(IN) :: U(1:) !< U COMPONENT OF DATA VARIABLE. + INTEGER(I8P), INTENT(IN) :: V(1:) !< V COMPONENT OF DATA VARIABLE. + INTEGER(I8P), INTENT(IN) :: W(1:) !< W COMPONENT OF DATA VARIABLE. + INTEGER(I8P), INTENT(IN) :: X(1:) !< X COMPONENT OF DATA VARIABLE. + INTEGER(I8P), INTENT(IN) :: Y(1:) !< Y COMPONENT OF DATA VARIABLE. + INTEGER(I8P), INTENT(IN) :: Z(1:) !< Z COMPONENT OF DATA VARIABLE. + LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". + INTEGER(I4P) :: ERROR !< ERROR STATUS. + ENDFUNCTION W_DATA6_RANK1_I8P_INTERFACE + + FUNCTION W_DATA6_RANK1_I4P_INTERFACE(SELF, DATA_NAME, U, V, W, X, Y, Z, IS_TUPLES) RESULT(ERROR) + !< WRITE `<DATAARRAY... NumberOfComponents="6"...>...</DATAARRAY>` TAG (I4P). + IMPORT :: XML_WRITER_ABSTRACT, I4P + CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT) :: SELF !< WRITER. + CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. + INTEGER(I4P), INTENT(IN) :: U(1:) !< U COMPONENT OF DATA VARIABLE. + INTEGER(I4P), INTENT(IN) :: V(1:) !< V COMPONENT OF DATA VARIABLE. + INTEGER(I4P), INTENT(IN) :: W(1:) !< W COMPONENT OF DATA VARIABLE. + INTEGER(I4P), INTENT(IN) :: X(1:) !< X COMPONENT OF DATA VARIABLE. + INTEGER(I4P), INTENT(IN) :: Y(1:) !< Y COMPONENT OF DATA VARIABLE. + INTEGER(I4P), INTENT(IN) :: Z(1:) !< Z COMPONENT OF DATA VARIABLE. + LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". + INTEGER(I4P) :: ERROR !< ERROR STATUS. + ENDFUNCTION W_DATA6_RANK1_I4P_INTERFACE + + FUNCTION W_DATA6_RANK1_I2P_INTERFACE(SELF, DATA_NAME, U, V, W, X, Y, Z, IS_TUPLES) RESULT(ERROR) + !< WRITE `<DATAARRAY... NumberOfComponents="6"...>...</DATAARRAY>` TAG (I2P). + IMPORT :: XML_WRITER_ABSTRACT, I2P, I4P + CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT) :: SELF !< WRITER. + CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. + INTEGER(I2P), INTENT(IN) :: U(1:) !< U COMPONENT OF DATA VARIABLE. + INTEGER(I2P), INTENT(IN) :: V(1:) !< V COMPONENT OF DATA VARIABLE. + INTEGER(I2P), INTENT(IN) :: W(1:) !< W COMPONENT OF DATA VARIABLE. + INTEGER(I2P), INTENT(IN) :: X(1:) !< X COMPONENT OF DATA VARIABLE. + INTEGER(I2P), INTENT(IN) :: Y(1:) !< Y COMPONENT OF DATA VARIABLE. + INTEGER(I2P), INTENT(IN) :: Z(1:) !< Z COMPONENT OF DATA VARIABLE. + LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". + INTEGER(I4P) :: ERROR !< ERROR STATUS. + ENDFUNCTION W_DATA6_RANK1_I2P_INTERFACE + + FUNCTION W_DATA6_RANK1_I1P_INTERFACE(SELF, DATA_NAME, U, V, W, X, Y, Z, IS_TUPLES) RESULT(ERROR) + !< WRITE `<DATAARRAY... NumberOfComponents="6"...>...</DATAARRAY>` TAG (I1P). + IMPORT :: XML_WRITER_ABSTRACT, I1P, I4P + CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT) :: SELF !< WRITER. + CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. + INTEGER(I1P), INTENT(IN) :: U(1:) !< U COMPONENT OF DATA VARIABLE. + INTEGER(I1P), INTENT(IN) :: V(1:) !< V COMPONENT OF DATA VARIABLE. + INTEGER(I1P), INTENT(IN) :: W(1:) !< W COMPONENT OF DATA VARIABLE. + INTEGER(I1P), INTENT(IN) :: X(1:) !< X COMPONENT OF DATA VARIABLE. + INTEGER(I1P), INTENT(IN) :: Y(1:) !< Y COMPONENT OF DATA VARIABLE. + INTEGER(I1P), INTENT(IN) :: Z(1:) !< Z COMPONENT OF DATA VARIABLE. + LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". + INTEGER(I4P) :: ERROR !< ERROR STATUS. + ENDFUNCTION W_DATA6_RANK1_I1P_INTERFACE + + FUNCTION W_DATA6_RANK3_R8P_INTERFACE(SELF, DATA_NAME, U, V, W, X, Y, Z, IS_TUPLES) RESULT(ERROR) + !< WRITE `<DATAARRAY... NumberOfComponents="6"...>...</DATAARRAY>` TAG (R8P). + IMPORT :: XML_WRITER_ABSTRACT, I4P, R8P + CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT) :: SELF !< WRITER. + CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. + REAL(R8P), INTENT(IN) :: U(1:,1:,1:) !< U COMPONENT OF DATA VARIABLE. + REAL(R8P), INTENT(IN) :: V(1:,1:,1:) !< V COMPONENT OF DATA VARIABLE. + REAL(R8P), INTENT(IN) :: W(1:,1:,1:) !< W COMPONENT OF DATA VARIABLE. + REAL(R8P), INTENT(IN) :: X(1:,1:,1:) !< X COMPONENT OF DATA VARIABLE. + REAL(R8P), INTENT(IN) :: Y(1:,1:,1:) !< Y COMPONENT OF DATA VARIABLE. + REAL(R8P), INTENT(IN) :: Z(1:,1:,1:) !< Z COMPONENT OF DATA VARIABLE. + LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". + INTEGER(I4P) :: ERROR !< ERROR STATUS. + ENDFUNCTION W_DATA6_RANK3_R8P_INTERFACE + + FUNCTION W_DATA6_RANK3_R4P_INTERFACE(SELF, DATA_NAME, U, V, W, X, Y, Z, IS_TUPLES) RESULT(ERROR) + !< WRITE `<DATAARRAY... NumberOfComponents="6"...>...</DATAARRAY>` TAG (R4P). + IMPORT :: XML_WRITER_ABSTRACT, I4P, R4P + CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT) :: SELF !< WRITER. + CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. + REAL(R4P), INTENT(IN) :: U(1:,1:,1:) !< U COMPONENT OF DATA VARIABLE. + REAL(R4P), INTENT(IN) :: V(1:,1:,1:) !< V COMPONENT OF DATA VARIABLE. + REAL(R4P), INTENT(IN) :: W(1:,1:,1:) !< W COMPONENT OF DATA VARIABLE. + REAL(R4P), INTENT(IN) :: X(1:,1:,1:) !< X COMPONENT OF DATA VARIABLE. + REAL(R4P), INTENT(IN) :: Y(1:,1:,1:) !< Y COMPONENT OF DATA VARIABLE. + REAL(R4P), INTENT(IN) :: Z(1:,1:,1:) !< Z COMPONENT OF DATA VARIABLE. + LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". + INTEGER(I4P) :: ERROR !< ERROR STATUS. + ENDFUNCTION W_DATA6_RANK3_R4P_INTERFACE + + FUNCTION W_DATA6_RANK3_I8P_INTERFACE(SELF, DATA_NAME, U, V, W, X, Y, Z, IS_TUPLES) RESULT(ERROR) + !< WRITE `<DATAARRAY... NumberOfComponents="6"...>...</DATAARRAY>` TAG (I8P). + IMPORT :: XML_WRITER_ABSTRACT, I4P, I8P + CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT) :: SELF !< WRITER. + CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. + INTEGER(I8P), INTENT(IN) :: U(1:,1:,1:) !< U COMPONENT OF DATA VARIABLE. + INTEGER(I8P), INTENT(IN) :: V(1:,1:,1:) !< V COMPONENT OF DATA VARIABLE. + INTEGER(I8P), INTENT(IN) :: W(1:,1:,1:) !< W COMPONENT OF DATA VARIABLE. + INTEGER(I8P), INTENT(IN) :: X(1:,1:,1:) !< X COMPONENT OF DATA VARIABLE. + INTEGER(I8P), INTENT(IN) :: Y(1:,1:,1:) !< Y COMPONENT OF DATA VARIABLE. + INTEGER(I8P), INTENT(IN) :: Z(1:,1:,1:) !< Z COMPONENT OF DATA VARIABLE. + LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". + INTEGER(I4P) :: ERROR !< ERROR STATUS. + ENDFUNCTION W_DATA6_RANK3_I8P_INTERFACE + + FUNCTION W_DATA6_RANK3_I4P_INTERFACE(SELF, DATA_NAME, U, V, W, X, Y, Z, IS_TUPLES) RESULT(ERROR) + !< WRITE `<DATAARRAY... NumberOfComponents="6"...>...</DATAARRAY>` TAG (I4P). + IMPORT :: XML_WRITER_ABSTRACT, I4P + CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT) :: SELF !< WRITER. + CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. + INTEGER(I4P), INTENT(IN) :: U(1:,1:,1:) !< U COMPONENT OF DATA VARIABLE. + INTEGER(I4P), INTENT(IN) :: V(1:,1:,1:) !< V COMPONENT OF DATA VARIABLE. + INTEGER(I4P), INTENT(IN) :: W(1:,1:,1:) !< W COMPONENT OF DATA VARIABLE. + INTEGER(I4P), INTENT(IN) :: X(1:,1:,1:) !< X COMPONENT OF DATA VARIABLE. + INTEGER(I4P), INTENT(IN) :: Y(1:,1:,1:) !< Y COMPONENT OF DATA VARIABLE. + INTEGER(I4P), INTENT(IN) :: Z(1:,1:,1:) !< Z COMPONENT OF DATA VARIABLE. + LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". + INTEGER(I4P) :: ERROR !< ERROR STATUS. + ENDFUNCTION W_DATA6_RANK3_I4P_INTERFACE + + FUNCTION W_DATA6_RANK3_I2P_INTERFACE(SELF, DATA_NAME, U, V, W, X, Y, Z, IS_TUPLES) RESULT(ERROR) + !< WRITE `<DATAARRAY... NumberOfComponents="6"...>...</DATAARRAY>` TAG (I2P). + IMPORT :: XML_WRITER_ABSTRACT, I2P, I4P + CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT) :: SELF !< WRITER. + CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. + INTEGER(I2P), INTENT(IN) :: U(1:,1:,1:) !< U COMPONENT OF DATA VARIABLE. + INTEGER(I2P), INTENT(IN) :: V(1:,1:,1:) !< V COMPONENT OF DATA VARIABLE. + INTEGER(I2P), INTENT(IN) :: W(1:,1:,1:) !< W COMPONENT OF DATA VARIABLE. + INTEGER(I2P), INTENT(IN) :: X(1:,1:,1:) !< X COMPONENT OF DATA VARIABLE. + INTEGER(I2P), INTENT(IN) :: Y(1:,1:,1:) !< Y COMPONENT OF DATA VARIABLE. + INTEGER(I2P), INTENT(IN) :: Z(1:,1:,1:) !< Z COMPONENT OF DATA VARIABLE. + LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". + INTEGER(I4P) :: ERROR !< ERROR STATUS. + ENDFUNCTION W_DATA6_RANK3_I2P_INTERFACE + + FUNCTION W_DATA6_RANK3_I1P_INTERFACE(SELF, DATA_NAME, U, V, W, X, Y, Z, IS_TUPLES) RESULT(ERROR) + !< WRITE `<DATAARRAY... NumberOfComponents="6"...>...</DATAARRAY>` TAG (I1P). + IMPORT :: XML_WRITER_ABSTRACT, I1P, I4P + CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT) :: SELF !< WRITER. + CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. + INTEGER(I1P), INTENT(IN) :: U(1:,1:,1:) !< U COMPONENT OF DATA VARIABLE. + INTEGER(I1P), INTENT(IN) :: V(1:,1:,1:) !< V COMPONENT OF DATA VARIABLE. + INTEGER(I1P), INTENT(IN) :: W(1:,1:,1:) !< W COMPONENT OF DATA VARIABLE. + INTEGER(I1P), INTENT(IN) :: X(1:,1:,1:) !< X COMPONENT OF DATA VARIABLE. + INTEGER(I1P), INTENT(IN) :: Y(1:,1:,1:) !< Y COMPONENT OF DATA VARIABLE. + INTEGER(I1P), INTENT(IN) :: Z(1:,1:,1:) !< Z COMPONENT OF DATA VARIABLE. + LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". + INTEGER(I4P) :: ERROR !< ERROR STATUS. + ENDFUNCTION W_DATA6_RANK3_I1P_INTERFACE + + SUBROUTINE W_DATA_APPENDED_INTERFACE(SELF) + !< WRITE `<APPENDEDDATA...>...</APPENDEDDATA>` TAG. + IMPORT :: XML_WRITER_ABSTRACT + CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT) :: SELF !< WRITER. + ENDSUBROUTINE W_DATA_APPENDED_INTERFACE +ENDINTERFACE +CONTAINS + ! FILES METHODS + SUBROUTINE CLOSE_XML_FILE(SELF) + !< CLOSE XML FILE. + CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT) :: SELF !< WRITER. + + IF (.NOT.SELF%IS_VOLATILE) CLOSE(UNIT=SELF%XML, IOSTAT=SELF%ERROR) + ENDSUBROUTINE CLOSE_XML_FILE + + SUBROUTINE OPEN_XML_FILE(SELF, FILENAME) + !< OPEN XML FILE. + CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT) :: SELF !< WRITER. + CHARACTER(*), INTENT(IN) :: FILENAME !< FILE NAME. + + IF (.NOT.SELF%IS_VOLATILE) THEN + OPEN(NEWUNIT=SELF%XML, & + FILE=TRIM(ADJUSTL(FILENAME)), & + FORM='UNFORMATTED', & + ACCESS='STREAM', & + ACTION='WRITE', & + STATUS='REPLACE', & + IOSTAT=SELF%ERROR) + ELSE + SELF%XML_VOLATILE = '' + ENDIF + ENDSUBROUTINE OPEN_XML_FILE + + ELEMENTAL SUBROUTINE FREE(SELF, ERROR) + !< FREE ALLOCATED MEMORY. + CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT) :: SELF !< WRITER. + INTEGER(I4P), INTENT(OUT), OPTIONAL :: ERROR !< ERROR STATUS. + + CALL SELF%FORMAT_CH%FREE + CALL SELF%TOPOLOGY%FREE + SELF%INDENT=0_I4P + SELF%IOFFSET=0_I8P + SELF%XML=0_I4P + SELF%VTM_BLOCK(1:2)=[-1_I4P, -1_I4P] + SELF%ERROR=0_I4P + CALL SELF%TAG%FREE + SELF%IS_VOLATILE=.FALSE. + CALL SELF%XML_VOLATILE%FREE + ENDSUBROUTINE FREE + + PURE SUBROUTINE GET_XML_VOLATILE(SELF, XML_VOLATILE, ERROR) + !< RETURN THE EVENTUAL XML VOLATILE STRING FILE. + CLASS(XML_WRITER_ABSTRACT), INTENT(IN) :: SELF !< WRITER. + CHARACTER(LEN=:), INTENT(OUT), ALLOCATABLE :: XML_VOLATILE !< XML VOLATILE FILE. + INTEGER(I4P), INTENT(OUT), OPTIONAL :: ERROR !< ERROR STATUS. + + IF (SELF%IS_VOLATILE) THEN + XML_VOLATILE = SELF%XML_VOLATILE%RAW + ENDIF + ENDSUBROUTINE GET_XML_VOLATILE + + ! TAG METHODS + SUBROUTINE WRITE_END_TAG(SELF, NAME) + !< WRITE `</TAG_NAME>` END TAG. + CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT) :: SELF !< WRITER. + CHARACTER(*), INTENT(IN) :: NAME !< TAG NAME. + + SELF%INDENT = SELF%INDENT - 2 + SELF%TAG = XML_TAG(NAME=NAME, INDENT=SELF%INDENT) + IF (.NOT.SELF%IS_VOLATILE) THEN + CALL SELF%TAG%WRITE(UNIT=SELF%XML, IOSTAT=SELF%ERROR, IS_INDENTED=.TRUE., END_RECORD=END_REC, ONLY_END=.TRUE.) + ELSE + SELF%XML_VOLATILE = SELF%XML_VOLATILE//SELF%TAG%STRINGIFY(IS_INDENTED=.TRUE., ONLY_END=.TRUE.)//END_REC + ENDIF + ENDSUBROUTINE WRITE_END_TAG + + SUBROUTINE WRITE_HEADER_TAG(SELF) + !< WRITE HEADER TAG. + CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT) :: SELF !< WRITER. + TYPE(STRING) :: BUFFER !< BUFFER STRING. + + BUFFER = '<?xml version="1.0"?>'//END_REC + IF (ENDIAN==ENDIANL) THEN + BUFFER = BUFFER//'<VTKFile type="'//SELF%TOPOLOGY//'" version="1.0" byte_order="LittleEndian">' + ELSE + BUFFER = BUFFER//'<VTKFile type="'//SELF%TOPOLOGY//'" version="1.0" byte_order="BigEndian">' + ENDIF + IF (.NOT.SELF%IS_VOLATILE) THEN + WRITE(UNIT=SELF%XML, IOSTAT=SELF%ERROR)BUFFER//END_REC + ELSE + SELF%XML_VOLATILE = SELF%XML_VOLATILE//BUFFER//END_REC + ENDIF + SELF%INDENT = 2 + ENDSUBROUTINE WRITE_HEADER_TAG + + SUBROUTINE WRITE_SELF_CLOSING_TAG(SELF, NAME, ATTRIBUTES) + !< WRITE `<TAG_NAME.../>` SELF CLOSING TAG. + CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT) :: SELF !< WRITER. + CHARACTER(*), INTENT(IN) :: NAME !< TAG NAME. + CHARACTER(*), INTENT(IN), OPTIONAL :: ATTRIBUTES !< TAG ATTRIBUTES. + + SELF%TAG = XML_TAG(NAME=NAME, ATTRIBUTES_STREAM=ATTRIBUTES, SANITIZE_ATTRIBUTES_VALUE=.TRUE., INDENT=SELF%INDENT, & + IS_SELF_CLOSING=.TRUE.) + IF (.NOT.SELF%IS_VOLATILE) THEN + CALL SELF%TAG%WRITE(UNIT=SELF%XML, IOSTAT=SELF%ERROR, IS_INDENTED=.TRUE., END_RECORD=END_REC) + ELSE + SELF%XML_VOLATILE = SELF%XML_VOLATILE//SELF%TAG%STRINGIFY(IS_INDENTED=.TRUE.)//END_REC + ENDIF + ENDSUBROUTINE WRITE_SELF_CLOSING_TAG + + SUBROUTINE WRITE_START_TAG(SELF, NAME, ATTRIBUTES) + !< WRITE `<TAG_NAME...>` START TAG. + CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT) :: SELF !< WRITER. + CHARACTER(*), INTENT(IN) :: NAME !< TAG NAME. + CHARACTER(*), INTENT(IN), OPTIONAL :: ATTRIBUTES !< TAG ATTRIBUTES. + + SELF%TAG = XML_TAG(NAME=NAME, ATTRIBUTES_STREAM=ATTRIBUTES, SANITIZE_ATTRIBUTES_VALUE=.TRUE., INDENT=SELF%INDENT) + IF (.NOT.SELF%IS_VOLATILE) THEN + CALL SELF%TAG%WRITE(UNIT=SELF%XML, IOSTAT=SELF%ERROR, IS_INDENTED=.TRUE., END_RECORD=END_REC, ONLY_START=.TRUE.) + ELSE + SELF%XML_VOLATILE = SELF%XML_VOLATILE//SELF%TAG%STRINGIFY(IS_INDENTED=.TRUE., ONLY_START=.TRUE.)//END_REC + ENDIF + SELF%INDENT = SELF%INDENT + 2 + ENDSUBROUTINE WRITE_START_TAG + + SUBROUTINE WRITE_TAG(SELF, NAME, ATTRIBUTES, CONTENT) + !< WRITE `<TAG_NAME...>...</TAG_NAME>` TAG. + CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT) :: SELF !< WRITER. + CHARACTER(*), INTENT(IN) :: NAME !< TAG NAME. + CHARACTER(*), INTENT(IN), OPTIONAL :: ATTRIBUTES !< TAG ATTRIBUTES. + CHARACTER(*), INTENT(IN), OPTIONAL :: CONTENT !< TAG CONTENT. + + SELF%TAG = XML_TAG(NAME=NAME, ATTRIBUTES_STREAM=ATTRIBUTES, SANITIZE_ATTRIBUTES_VALUE=.TRUE., CONTENT=CONTENT, & + INDENT=SELF%INDENT) + IF (.NOT.SELF%IS_VOLATILE) THEN + CALL SELF%TAG%WRITE(UNIT=SELF%XML, IOSTAT=SELF%ERROR, IS_INDENTED=.TRUE., IS_CONTENT_INDENTED=.TRUE., END_RECORD=END_REC) + ELSE + SELF%XML_VOLATILE = SELF%XML_VOLATILE//SELF%TAG%STRINGIFY(IS_INDENTED=.TRUE., IS_CONTENT_INDENTED=.TRUE.)//END_REC + ENDIF + ENDSUBROUTINE WRITE_TAG + + SUBROUTINE WRITE_TOPOLOGY_TAG(SELF, NX1, NX2, NY1, NY2, NZ1, NZ2, MESH_KIND) + !< WRITE XML TOPOLOGY TAG. + CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT) :: SELF !< WRITER. + INTEGER(I4P), INTENT(IN), OPTIONAL :: NX1 !< INITIAL NODE OF X AXIS. + INTEGER(I4P), INTENT(IN), OPTIONAL :: NX2 !< FINAL NODE OF X AXIS. + INTEGER(I4P), INTENT(IN), OPTIONAL :: NY1 !< INITIAL NODE OF Y AXIS. + INTEGER(I4P), INTENT(IN), OPTIONAL :: NY2 !< FINAL NODE OF Y AXIS. + INTEGER(I4P), INTENT(IN), OPTIONAL :: NZ1 !< INITIAL NODE OF Z AXIS. + INTEGER(I4P), INTENT(IN), OPTIONAL :: NZ2 !< FINAL NODE OF Z AXIS. + CHARACTER(*), INTENT(IN), OPTIONAL :: MESH_KIND !< KIND OF MESH DATA: FLOAT64, FLOAT32, ECC. + TYPE(STRING) :: BUFFER !< BUFFER STRING. + + BUFFER = '' + SELECT CASE(SELF%TOPOLOGY%CHARS()) + CASE('RectilinearGrid', 'StructuredGrid','ImageData') + BUFFER = 'WholeExtent="'// & + TRIM(STR(N=NX1))//' '//TRIM(STR(N=NX2))//' '//& + TRIM(STR(N=NY1))//' '//TRIM(STR(N=NY2))//' '//& + TRIM(STR(N=NZ1))//' '//TRIM(STR(N=NZ2))//'"' + CASE('PRectilinearGrid', 'PStructuredGrid','PImageData') + BUFFER = 'WholeExtent="'// & + TRIM(STR(N=NX1))//' '//TRIM(STR(N=NX2))//' '//& + TRIM(STR(N=NY1))//' '//TRIM(STR(N=NY2))//' '//& + TRIM(STR(N=NZ1))//' '//TRIM(STR(N=NZ2))//'" GhostLevel="#"' + CASE('PUnstructuredGrid') + BUFFER = 'GhostLevel="0"' + ENDSELECT + CALL SELF%WRITE_START_TAG(NAME=SELF%TOPOLOGY%CHARS(), ATTRIBUTES=BUFFER%CHARS()) + ! PARALLEL TOPOLOGIES PECULIARS + SELECT CASE(SELF%TOPOLOGY%CHARS()) + CASE('PRectilinearGrid') + IF (.NOT.PRESENT(MESH_KIND)) THEN + SELF%ERROR = 1 + RETURN + ENDIF + CALL SELF%WRITE_START_TAG(NAME='PCoordinates') + CALL SELF%WRITE_SELF_CLOSING_TAG(NAME='PDataArray', ATTRIBUTES='type="'//TRIM(MESH_KIND)//'"') + CALL SELF%WRITE_SELF_CLOSING_TAG(NAME='PDataArray', ATTRIBUTES='type="'//TRIM(MESH_KIND)//'"') + CALL SELF%WRITE_SELF_CLOSING_TAG(NAME='PDataArray', ATTRIBUTES='type="'//TRIM(MESH_KIND)//'"') + CALL SELF%WRITE_END_TAG(NAME='PCoordinates') + CASE('PStructuredGrid', 'PUnstructuredGrid') + IF (.NOT.PRESENT(MESH_KIND)) THEN + SELF%ERROR = 1 + RETURN + ENDIF + CALL SELF%WRITE_START_TAG(NAME='PPoints') + CALL SELF%WRITE_SELF_CLOSING_TAG(NAME='PDataArray', & + ATTRIBUTES='type="'//TRIM(MESH_KIND)//'" NumberOfComponents="3" NAME="POINTS"') + CALL SELF%WRITE_END_TAG(NAME='PPoints') + ENDSELECT + ENDSUBROUTINE WRITE_TOPOLOGY_TAG + + ! W_DATA + SUBROUTINE W_DATA_TAG(SELF, DATA_TYPE, NUMBER_OF_COMPONENTS, DATA_NAME, DATA_CONTENT, IS_TUPLES) + !< WRITE `<DATAARRAY...>...</DATAARRAY>` TAG. + CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT) :: SELF !< WRITER. + CHARACTER(*), INTENT(IN) :: DATA_TYPE !< TYPE OF DATAARRAY. + INTEGER(I4P), INTENT(IN) :: NUMBER_OF_COMPONENTS !< NUMBER OF DATAARRAY COMPONENTS. + CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. + CHARACTER(*), INTENT(IN), OPTIONAL :: DATA_CONTENT !< DATA CONTENT. + LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES". + TYPE(STRING) :: TAG_ATTRIBUTES !< TAG ATTRIBUTES. + LOGICAL :: IS_TUPLES_ !< USE "NUMBEROFTUPLES". + + IS_TUPLES_ = .FALSE. + IF (PRESENT(IS_TUPLES)) IS_TUPLES_ = IS_TUPLES + IF (IS_TUPLES_) THEN + TAG_ATTRIBUTES = 'type="'//TRIM(ADJUSTL(DATA_TYPE))// & + '" NumberOfTuples="'//TRIM(STR(NUMBER_OF_COMPONENTS, .TRUE.))// & + '" Name="'//TRIM(ADJUSTL(DATA_NAME))// & + '" format="'//SELF%FORMAT_CH//'"' + ELSE + TAG_ATTRIBUTES = 'type="'//TRIM(ADJUSTL(DATA_TYPE))// & + '" NumberOfComponents="'//TRIM(STR(NUMBER_OF_COMPONENTS, .TRUE.))// & + '" Name="'//TRIM(ADJUSTL(DATA_NAME))// & + '" format="'//SELF%FORMAT_CH//'"' + ENDIF + CALL SELF%WRITE_TAG(NAME='DataArray', ATTRIBUTES=TAG_ATTRIBUTES%CHARS(), CONTENT=DATA_CONTENT) + ENDSUBROUTINE W_DATA_TAG + + SUBROUTINE W_DATA_TAG_APPENDED(SELF, DATA_TYPE, NUMBER_OF_COMPONENTS, DATA_NAME, IS_TUPLES) + !< WRITE `<DATAARRAY.../>` TAG. + CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT) :: SELF !< WRITER. + CHARACTER(*), INTENT(IN) :: DATA_TYPE !< TYPE OF DATAARRAY. + INTEGER(I4P), INTENT(IN) :: NUMBER_OF_COMPONENTS !< NUMBER OF DATAARRAY COMPONENTS. + CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. + LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES". + TYPE(STRING) :: TAG_ATTRIBUTES !< TAG ATTRIBUTES. + LOGICAL :: IS_TUPLES_ !< USE "NUMBEROFTUPLES". + + IS_TUPLES_ = .FALSE. + IF (PRESENT(IS_TUPLES)) IS_TUPLES_ = IS_TUPLES + IF (IS_TUPLES_) THEN + TAG_ATTRIBUTES = 'type="'//TRIM(ADJUSTL(DATA_TYPE))// & + '" NumberOfTuples="'//TRIM(STR(NUMBER_OF_COMPONENTS, .TRUE.))// & + '" Name="'//TRIM(ADJUSTL(DATA_NAME))// & + '" format="'//SELF%FORMAT_CH// & + '" offset="'//TRIM(STR(SELF%IOFFSET, .TRUE.))//'"' + ELSE + TAG_ATTRIBUTES = 'type="'//TRIM(ADJUSTL(DATA_TYPE))// & + '" NumberOfComponents="'//TRIM(STR(NUMBER_OF_COMPONENTS, .TRUE.))// & + '" Name="'//TRIM(ADJUSTL(DATA_NAME))// & + '" format="'//SELF%FORMAT_CH// & + '" offset="'//TRIM(STR(SELF%IOFFSET, .TRUE.))//'"' + ENDIF + CALL SELF%WRITE_SELF_CLOSING_TAG(NAME='DataArray', ATTRIBUTES=TAG_ATTRIBUTES%CHARS()) + ENDSUBROUTINE W_DATA_TAG_APPENDED + + FUNCTION W_DATA_LOCATION_TAG(SELF, LOCATION, ACTION) RESULT(ERROR) + !< WRITE `<[/]POINTDATA>` OR `<[/]CELLDATA>` OPEN/CLOSE TAG. + !< + !< @NOTE **MUST** BE CALLED BEFORE SAVING THE DATA RELATED TO GEOMETRIC MESH, THIS FUNCTION INITIALIZES THE + !< SAVING OF DATA VARIABLES INDICATING THE *LOCATION* (NODE OR CELL CENTERED) OF VARIABLES THAT WILL BE SAVED. + !< + !< @NOTE A SINGLE FILE CAN CONTAIN BOTH CELL AND NODE CENTERED VARIABLES. IN THIS CASE THE VTK_DAT_XML FUNCTION MUST BE + !< CALLED TWO TIMES, BEFORE SAVING CELL-CENTERED VARIABLES AND BEFORE SAVING NODE-CENTERED VARIABLES. + !< + !<### EXAMPLES OF USAGE + !< + !<#### OPENING NODE PIECE + !<```FORTRAN + !< ERROR = VTK%W_DATA('NODE','OPEN') + !<``` + !< + !<#### CLOSING NODE PIECE + !<```FORTRAN + !< ERROR = VTK%W_DATA('NODE','CLOSE') + !<``` + !< + !<#### OPENING CELL PIECE + !<```FORTRAN + !< ERROR = VTK%W_DATA('CELL','OPEN') + !<``` + !< + !<#### CLOSING CELL PIECE + !<```FORTRAN + !< ERROR = VTK%W_DATA('CELL','CLOSE') + !<``` + CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT) :: SELF !< WRITER. + CHARACTER(*), INTENT(IN) :: LOCATION !< LOCATION OF VARIABLES: **CELL** OR **NODE** CENTERED. + CHARACTER(*), INTENT(IN) :: ACTION !< ACTION: **OPEN** OR **CLOSE** TAG. + INTEGER(I4P) :: ERROR !< ERROR STATUS. + TYPE(STRING) :: LOCATION_ !< LOCATION STRING. + TYPE(STRING) :: ACTION_ !< ACTION STRING. + + LOCATION_ = TRIM(ADJUSTL(LOCATION)) ; LOCATION_ = LOCATION_%UPPER() + ACTION_ = TRIM(ADJUSTL(ACTION)) ; ACTION_ = ACTION_%UPPER() + SELECT CASE(LOCATION_%CHARS()) + CASE('CELL') + LOCATION_ = 'CellData' + CASE('NODE') + LOCATION_ = 'PointData' + ENDSELECT + SELECT CASE(SELF%TOPOLOGY%CHARS()) + CASE('PRectilinearGrid', 'PStructuredGrid', 'PUnstructuredGrid') + LOCATION_ = 'P'//LOCATION_ + ENDSELECT + SELECT CASE(ACTION_%CHARS()) + CASE('OPEN') + CALL SELF%WRITE_START_TAG(NAME=LOCATION_%CHARS()) + CASE('CLOSE') + CALL SELF%WRITE_END_TAG(NAME=LOCATION_%CHARS()) + ENDSELECT + ERROR = SELF%ERROR + ENDFUNCTION W_DATA_LOCATION_TAG + + ! WRITE_FIELDDATA METHODS + FUNCTION WRITE_FIELDDATA1_RANK0(SELF, DATA_NAME, X) RESULT(ERROR) + !< WRITE `<DATAARRAY... NUMBEROFTUPLES="..."...>...</DATAARRAY>` TAG (R8P). + CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT) :: SELF !< WRITER. + CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. + CLASS(*), INTENT(IN) :: X !< DATA VARIABLE. + INTEGER(I4P) :: ERROR !< ERROR STATUS. + + SELECT TYPE(X) + TYPE IS(REAL(R8P)) + SELF%ERROR = SELF%W_DATA(DATA_NAME=DATA_NAME, X=[X], IS_TUPLES=.TRUE.) + TYPE IS(REAL(R4P)) + SELF%ERROR = SELF%W_DATA(DATA_NAME=DATA_NAME, X=[X], IS_TUPLES=.TRUE.) + TYPE IS(INTEGER(I8P)) + SELF%ERROR = SELF%W_DATA(DATA_NAME=DATA_NAME, X=[X], IS_TUPLES=.TRUE.) + TYPE IS(INTEGER(I4P)) + SELF%ERROR = SELF%W_DATA(DATA_NAME=DATA_NAME, X=[X], IS_TUPLES=.TRUE.) + TYPE IS(INTEGER(I2P)) + SELF%ERROR = SELF%W_DATA(DATA_NAME=DATA_NAME, X=[X], IS_TUPLES=.TRUE.) + TYPE IS(INTEGER(I1P)) + SELF%ERROR = SELF%W_DATA(DATA_NAME=DATA_NAME, X=[X], IS_TUPLES=.TRUE.) + ENDSELECT + ERROR = SELF%ERROR + ENDFUNCTION WRITE_FIELDDATA1_RANK0 + + FUNCTION WRITE_FIELDDATA_TAG(SELF, ACTION) RESULT(ERROR) + !< WRITE `<FIELDDATA>`/`</FIELDDATA>` START/END TAG. + CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT) :: SELF !< WRITER. + CHARACTER(*), INTENT(IN) :: ACTION !< ACTION: **OPEN** OR **CLOSE** TAG. + INTEGER(I4P) :: ERROR !< ERROR STATUS. + TYPE(STRING) :: ACTION_ !< ACTION STRING. + + ACTION_ = TRIM(ADJUSTL(ACTION)) ; ACTION_ = ACTION_%UPPER() + SELECT CASE(ACTION_%CHARS()) + CASE('OPEN') + CALL SELF%WRITE_START_TAG(NAME='FieldData') + CASE('CLOSE') + CALL SELF%WRITE_END_TAG(NAME='FieldData') + ENDSELECT + ERROR = SELF%ERROR + ENDFUNCTION WRITE_FIELDDATA_TAG + + ! WRITE_PIECE METHODS + FUNCTION WRITE_PIECE_START_TAG(SELF, NX1, NX2, NY1, NY2, NZ1, NZ2) RESULT(ERROR) + !< WRITE `<PIECE ...>` START TAG. + CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT) :: SELF !< WRITER. + INTEGER(I4P), INTENT(IN) :: NX1 !< INITIAL NODE OF X AXIS. + INTEGER(I4P), INTENT(IN) :: NX2 !< FINAL NODE OF X AXIS. + INTEGER(I4P), INTENT(IN) :: NY1 !< INITIAL NODE OF Y AXIS. + INTEGER(I4P), INTENT(IN) :: NY2 !< FINAL NODE OF Y AXIS. + INTEGER(I4P), INTENT(IN) :: NZ1 !< INITIAL NODE OF Z AXIS. + INTEGER(I4P), INTENT(IN) :: NZ2 !< FINAL NODE OF Z AXIS. + INTEGER(I4P) :: ERROR !< ERROR STATUS. + TYPE(STRING) :: TAG_ATTRIBUTES !< TAG ATTRIBUTES. + + TAG_ATTRIBUTES = 'Extent="'//TRIM(STR(N=NX1))//' '//TRIM(STR(N=NX2))//' '// & + TRIM(STR(N=NY1))//' '//TRIM(STR(N=NY2))//' '// & + TRIM(STR(N=NZ1))//' '//TRIM(STR(N=NZ2))//'"' + CALL SELF%WRITE_START_TAG(NAME='Piece', ATTRIBUTES=TAG_ATTRIBUTES%CHARS()) + ERROR = SELF%ERROR + ENDFUNCTION WRITE_PIECE_START_TAG + + FUNCTION WRITE_PIECE_START_TAG_UNST(SELF, NP, NC) RESULT(ERROR) + !< WRITE `<PIECE ...>` START TAG FOR UNSTRUCTURED TOPOLOGY. + CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT) :: SELF !< WRITER. + INTEGER(I4P), INTENT(IN) :: NP !< NUMBER OF POINTS. + INTEGER(I4P), INTENT(IN) :: NC !< NUMBER OF CELLS. + INTEGER(I4P) :: ERROR !< ERROR STATUS. + TYPE(STRING) :: TAG_ATTRIBUTES !< TAG ATTRIBUTES. + + TAG_ATTRIBUTES = 'NumberOfPoints="'//TRIM(STR(N=NP))//'" NumberOfCells="'//TRIM(STR(N=NC))//'"' + CALL SELF%WRITE_START_TAG(NAME='Piece', ATTRIBUTES=TAG_ATTRIBUTES%CHARS()) + ERROR = SELF%ERROR + ENDFUNCTION WRITE_PIECE_START_TAG_UNST + + FUNCTION WRITE_PIECE_END_TAG(SELF) RESULT(ERROR) + !< WRITE `</PIECE>` END TAG. + CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT) :: SELF !< WRITER. + INTEGER(I4P) :: ERROR !< ERROR STATUS. + + CALL SELF%WRITE_END_TAG(NAME='Piece') + ERROR = SELF%ERROR + ENDFUNCTION WRITE_PIECE_END_TAG + + ! WRITE_GEO_RECT METHODS + FUNCTION WRITE_GEO_RECT_DATA3_RANK1_R8P(SELF, X, Y, Z) RESULT(ERROR) + !< WRITE MESH WITH **RECTILINEARGRID** TOPOLOGY (DATA 3, RANK 1, R8P). + CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT) :: SELF !< WRITER. + REAL(R8P), INTENT(IN) :: X(1:) !< X COORDINATES. + REAL(R8P), INTENT(IN) :: Y(1:) !< Y COORDINATES. + REAL(R8P), INTENT(IN) :: Z(1:) !< Z COORDINATES. + INTEGER(I4P) :: ERROR !< ERROR STATUS. + + CALL SELF%WRITE_START_TAG(NAME='Coordinates') + ERROR = SELF%W_DATA(DATA_NAME='X', X=X) + ERROR = SELF%W_DATA(DATA_NAME='Y', X=Y) + ERROR = SELF%W_DATA(DATA_NAME='Z', X=Z) + CALL SELF%WRITE_END_TAG(NAME='Coordinates') + ERROR = SELF%ERROR + ENDFUNCTION WRITE_GEO_RECT_DATA3_RANK1_R8P + + FUNCTION WRITE_GEO_RECT_DATA3_RANK1_R4P(SELF, X, Y, Z) RESULT(ERROR) + !< WRITE MESH WITH **RECTILINEARGRID** TOPOLOGY (DATA 3, RANK 1, R4P). + CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT) :: SELF !< WRITER. + REAL(R4P), INTENT(IN) :: X(1:) !< X COORDINATES. + REAL(R4P), INTENT(IN) :: Y(1:) !< Y COORDINATES. + REAL(R4P), INTENT(IN) :: Z(1:) !< Z COORDINATES. + INTEGER(I4P) :: ERROR !< ERROR STATUS. + + CALL SELF%WRITE_START_TAG(NAME='Coordinates') + ERROR = SELF%W_DATA(DATA_NAME='X', X=X) + ERROR = SELF%W_DATA(DATA_NAME='Y', X=Y) + ERROR = SELF%W_DATA(DATA_NAME='Z', X=Z) + CALL SELF%WRITE_END_TAG(NAME='Coordinates') + ERROR = SELF%ERROR + ENDFUNCTION WRITE_GEO_RECT_DATA3_RANK1_R4P + + ! WRITE_GEO_STRG METHODS + FUNCTION WRITE_GEO_STRG_DATA1_RANK2_R8P(SELF, XYZ) RESULT(ERROR) + !< WRITE MESH WITH **STRUCTUREDGRID** TOPOLOGY (DATA 1, RANK 2, R8P). + CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT) :: SELF !< WRITER. + REAL(R8P), INTENT(IN) :: XYZ(1:,1:) !< X, Y, Z COORDINATES [1:3,1:N]. + INTEGER(I4P) :: ERROR !< ERROR STATUS. + + CALL SELF%WRITE_START_TAG(NAME='Points') + ERROR = SELF%W_DATA(DATA_NAME='Points', X=XYZ) + CALL SELF%WRITE_END_TAG(NAME='Points') + ERROR = SELF%ERROR + ENDFUNCTION WRITE_GEO_STRG_DATA1_RANK2_R8P + + FUNCTION WRITE_GEO_STRG_DATA1_RANK2_R4P(SELF, XYZ) RESULT(ERROR) + !< WRITE MESH WITH **STRUCTUREDGRID** TOPOLOGY (DATA 1, RANK 2, R4P). + CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT) :: SELF !< WRITER. + REAL(R4P), INTENT(IN) :: XYZ(1:,1:) !< X, Y, Z COORDINATES [1:3,:]. + INTEGER(I4P) :: ERROR !< ERROR STATUS. + + CALL SELF%WRITE_START_TAG(NAME='Points') + ERROR = SELF%W_DATA(DATA_NAME='Points', X=XYZ) + CALL SELF%WRITE_END_TAG(NAME='Points') + ERROR = SELF%ERROR + ENDFUNCTION WRITE_GEO_STRG_DATA1_RANK2_R4P + + FUNCTION WRITE_GEO_STRG_DATA1_RANK4_R8P(SELF, XYZ) RESULT(ERROR) + !< WRITE MESH WITH **STRUCTUREDGRID** TOPOLOGY (DATA 1, RANK 4, R8P). + CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT) :: SELF !< WRITER. + REAL(R8P), INTENT(IN) :: XYZ(1:,1:,1:,1:) !< X, Y, Z COORDINATES [1:3,:,:,:]. + INTEGER(I4P) :: ERROR !< ERROR STATUS. + + CALL SELF%WRITE_START_TAG(NAME='Points') + ERROR = SELF%W_DATA(DATA_NAME='Points', X=XYZ) + CALL SELF%WRITE_END_TAG(NAME='Points') + ERROR = SELF%ERROR + ENDFUNCTION WRITE_GEO_STRG_DATA1_RANK4_R8P + + FUNCTION WRITE_GEO_STRG_DATA1_RANK4_R4P(SELF, XYZ) RESULT(ERROR) + !< WRITE MESH WITH **STRUCTUREDGRID** TOPOLOGY (DATA 1, RANK 4, R4P). + CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT) :: SELF !< WRITER. + REAL(R4P), INTENT(IN) :: XYZ(1:,1:,1:,1:) !< X, Y, Z COORDINATES [1:3,:,:,:]. + INTEGER(I4P) :: ERROR !< ERROR STATUS. + + CALL SELF%WRITE_START_TAG(NAME='Points') + ERROR = SELF%W_DATA(DATA_NAME='Points', X=XYZ) + CALL SELF%WRITE_END_TAG(NAME='Points') + ERROR = SELF%ERROR + ENDFUNCTION WRITE_GEO_STRG_DATA1_RANK4_R4P + + FUNCTION WRITE_GEO_STRG_DATA3_RANK1_R8P(SELF, N, X, Y, Z) RESULT(ERROR) + !< WRITE MESH WITH **STRUCTUREDGRID** TOPOLOGY (DATA 3, RANK 1, R8P). + CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT) :: SELF !< WRITER. + INTEGER(I4P), INTENT(IN) :: N !< NUMBER OF NODES. + REAL(R8P), INTENT(IN) :: X(1:) !< X COORDINATES. + REAL(R8P), INTENT(IN) :: Y(1:) !< Y COORDINATES. + REAL(R8P), INTENT(IN) :: Z(1:) !< Z COORDINATES. + INTEGER(I4P) :: ERROR !< ERROR STATUS. + + IF ((N/=SIZE(X, DIM=1)).OR.(N/=SIZE(Y, DIM=1)).OR.(N/=SIZE(Z, DIM=1))) THEN + SELF%ERROR = 1 + RETURN + ENDIF + CALL SELF%WRITE_START_TAG(NAME='Points') + ERROR = SELF%W_DATA(DATA_NAME='Points', X=X, Y=Y, Z=Z) + CALL SELF%WRITE_END_TAG(NAME='Points') + ERROR = SELF%ERROR + ENDFUNCTION WRITE_GEO_STRG_DATA3_RANK1_R8P + + FUNCTION WRITE_GEO_STRG_DATA3_RANK1_R4P(SELF, N, X, Y, Z) RESULT(ERROR) + !< WRITE MESH WITH **STRUCTUREDGRID** TOPOLOGY (DATA 3, RANK 1, R4P). + CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT) :: SELF !< WRITER. + INTEGER(I4P), INTENT(IN) :: N !< NUMBER OF NODES. + REAL(R4P), INTENT(IN) :: X(1:) !< X COORDINATES. + REAL(R4P), INTENT(IN) :: Y(1:) !< Y COORDINATES. + REAL(R4P), INTENT(IN) :: Z(1:) !< Z COORDINATES. + INTEGER(I4P) :: ERROR !< ERROR STATUS. + + IF ((N/=SIZE(X, DIM=1)).OR.(N/=SIZE(Y, DIM=1)).OR.(N/=SIZE(Z, DIM=1))) THEN + SELF%ERROR = 1 + RETURN + ENDIF + CALL SELF%WRITE_START_TAG(NAME='Points') + ERROR = SELF%W_DATA(DATA_NAME='Points', X=X, Y=Y, Z=Z) + CALL SELF%WRITE_END_TAG(NAME='Points') + ERROR = SELF%ERROR + ENDFUNCTION WRITE_GEO_STRG_DATA3_RANK1_R4P + + FUNCTION WRITE_GEO_STRG_DATA3_RANK3_R8P(SELF, N, X, Y, Z) RESULT(ERROR) + !< WRITE MESH WITH **STRUCTUREDGRID** TOPOLOGY (DATA 3, RANK 3, R8P). + CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT) :: SELF !< WRITER. + INTEGER(I4P), INTENT(IN) :: N !< NUMBER OF NODES. + REAL(R8P), INTENT(IN) :: X(1:,1:,1:) !< X COORDINATES. + REAL(R8P), INTENT(IN) :: Y(1:,1:,1:) !< Y COORDINATES. + REAL(R8P), INTENT(IN) :: Z(1:,1:,1:) !< Z COORDINATES. + INTEGER(I4P) :: ERROR !< ERROR STATUS. + + IF ((N/=SIZE(X, DIM=1)*SIZE(X, DIM=2)*SIZE(X, DIM=3)).OR.& + (N/=SIZE(Y, DIM=1)*SIZE(Y, DIM=2)*SIZE(Y, DIM=3)).OR.& + (N/=SIZE(Z, DIM=1)*SIZE(Z, DIM=2)*SIZE(Z, DIM=3))) THEN + SELF%ERROR = 1 + RETURN + ENDIF + CALL SELF%WRITE_START_TAG(NAME='Points') + ERROR = SELF%W_DATA(DATA_NAME='Points', X=X, Y=Y, Z=Z) + CALL SELF%WRITE_END_TAG(NAME='Points') + ERROR = SELF%ERROR + ENDFUNCTION WRITE_GEO_STRG_DATA3_RANK3_R8P + + FUNCTION WRITE_GEO_STRG_DATA3_RANK3_R4P(SELF, N, X, Y, Z) RESULT(ERROR) + !< WRITE MESH WITH **STRUCTUREDGRID** TOPOLOGY (DATA 3, RANK 3, R4P). + CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT) :: SELF !< WRITER. + INTEGER(I4P), INTENT(IN) :: N !< NUMBER OF NODES. + REAL(R4P), INTENT(IN) :: X(1:,1:,1:) !< X COORDINATES. + REAL(R4P), INTENT(IN) :: Y(1:,1:,1:) !< Y COORDINATES. + REAL(R4P), INTENT(IN) :: Z(1:,1:,1:) !< Z COORDINATES. + INTEGER(I4P) :: ERROR !< ERROR STATUS. + + IF ((N/=SIZE(X, DIM=1)*SIZE(X, DIM=2)*SIZE(X, DIM=3)).OR.& + (N/=SIZE(Y, DIM=1)*SIZE(Y, DIM=2)*SIZE(Y, DIM=3)).OR.& + (N/=SIZE(Z, DIM=1)*SIZE(Z, DIM=2)*SIZE(Z, DIM=3))) THEN + SELF%ERROR = 1 + RETURN + ENDIF + CALL SELF%WRITE_START_TAG(NAME='Points') + ERROR = SELF%W_DATA(DATA_NAME='Points', X=X, Y=Y, Z=Z) + CALL SELF%WRITE_END_TAG(NAME='Points') + ERROR = SELF%ERROR + ENDFUNCTION WRITE_GEO_STRG_DATA3_RANK3_R4P + + ! WRITE_GEO_UNST METHODS + FUNCTION WRITE_GEO_UNST_DATA1_RANK2_R8P(SELF, NP, NC, XYZ) RESULT(ERROR) + !< WRITE MESH WITH **UNSTRUCTUREDGRID** TOPOLOGY (DATA 1, RANK 2, R8P). + CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT) :: SELF !< WRITER. + INTEGER(I4P), INTENT(IN) :: NP !< NUMBER OF POINTS. + INTEGER(I4P), INTENT(IN) :: NC !< NUMBER OF CELLS. + REAL(R8P), INTENT(IN) :: XYZ(1:,1:) !< X, Y, Z COORDINATES [1:3,:]. + INTEGER(I4P) :: ERROR !< ERROR STATUS. + + IF (NP/=SIZE(XYZ, DIM=2)) THEN + SELF%ERROR = 1 + RETURN + ENDIF + CALL SELF%WRITE_START_TAG(NAME='Points') + ERROR = SELF%W_DATA(DATA_NAME='Points', X=XYZ) + CALL SELF%WRITE_END_TAG(NAME='Points') + ERROR = SELF%ERROR + ENDFUNCTION WRITE_GEO_UNST_DATA1_RANK2_R8P + + FUNCTION WRITE_GEO_UNST_DATA1_RANK2_R4P(SELF, NP, NC, XYZ) RESULT(ERROR) + !< WRITE MESH WITH **UNSTRUCTUREDGRID** TOPOLOGY (DATA 1, RANK 2, R4P). + CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT) :: SELF !< WRITER. + INTEGER(I4P), INTENT(IN) :: NP !< NUMBER OF POINTS. + INTEGER(I4P), INTENT(IN) :: NC !< NUMBER OF CELLS. + REAL(R4P), INTENT(IN) :: XYZ(1:,1:) !< X, Y, Z COORDINATES [1:3,:]. + INTEGER(I4P) :: ERROR !< ERROR STATUS. + + IF (NP/=SIZE(XYZ, DIM=2)) THEN + SELF%ERROR = 1 + RETURN + ENDIF + CALL SELF%WRITE_START_TAG(NAME='Points') + ERROR = SELF%W_DATA(DATA_NAME='Points', X=XYZ) + CALL SELF%WRITE_END_TAG(NAME='Points') + ERROR = SELF%ERROR + ENDFUNCTION WRITE_GEO_UNST_DATA1_RANK2_R4P + + FUNCTION WRITE_GEO_UNST_DATA3_RANK1_R8P(SELF, NP, NC, X, Y, Z) RESULT(ERROR) + !< WRITE MESH WITH **UNSTRUCTUREDGRID** TOPOLOGY (DATA 3, RANK 1, R8P). + CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT) :: SELF !< WRITER. + INTEGER(I4P), INTENT(IN) :: NP !< NUMBER OF POINTS. + INTEGER(I4P), INTENT(IN) :: NC !< NUMBER OF CELLS. + REAL(R8P), INTENT(IN) :: X(1:) !< X COORDINATES. + REAL(R8P), INTENT(IN) :: Y(1:) !< Y COORDINATES. + REAL(R8P), INTENT(IN) :: Z(1:) !< Z COORDINATES. + INTEGER(I4P) :: ERROR !< ERROR STATUS. + + IF ((NP/=SIZE(X, DIM=1)).OR.(NP/=SIZE(Y, DIM=1)).OR.(NP/=SIZE(Z, DIM=1))) THEN + SELF%ERROR = 1 + RETURN + ENDIF + CALL SELF%WRITE_START_TAG(NAME='Points') + ERROR = SELF%W_DATA(DATA_NAME='Points', X=X, Y=Y, Z=Z) + CALL SELF%WRITE_END_TAG(NAME='Points') + ERROR = SELF%ERROR + ENDFUNCTION WRITE_GEO_UNST_DATA3_RANK1_R8P + + FUNCTION WRITE_GEO_UNST_DATA3_RANK1_R4P(SELF, NP, NC, X, Y, Z) RESULT(ERROR) + !< WRITE MESH WITH **UNSTRUCTUREDGRID** TOPOLOGY (DATA 3, RANK 1, R4P). + CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT) :: SELF !< WRITER. + INTEGER(I4P), INTENT(IN) :: NP !< NUMBER OF POINTS. + INTEGER(I4P), INTENT(IN) :: NC !< NUMBER OF CELLS. + REAL(R4P), INTENT(IN) :: X(1:) !< X COORDINATES. + REAL(R4P), INTENT(IN) :: Y(1:) !< Y COORDINATES. + REAL(R4P), INTENT(IN) :: Z(1:) !< Z COORDINATES. + INTEGER(I4P) :: ERROR !< ERROR STATUS. + + IF ((NP/=SIZE(X, DIM=1)).OR.(NP/=SIZE(Y, DIM=1)).OR.(NP/=SIZE(Z, DIM=1))) THEN + SELF%ERROR = 1 + RETURN + ENDIF + CALL SELF%WRITE_START_TAG(NAME='Points') + ERROR = SELF%W_DATA(DATA_NAME='Points', X=X, Y=Y, Z=Z) + CALL SELF%WRITE_END_TAG(NAME='Points') + ERROR = SELF%ERROR + ENDFUNCTION WRITE_GEO_UNST_DATA3_RANK1_R4P + + FUNCTION WRITE_CONNECTIVITY(SELF, NC, CONNECTIVITY, OFFSET, VTKC_TYPE, FACE, FACEOFFSET) RESULT(ERROR) + !< WRITE MESH CONNECTIVITY. + !< + !< **MUST** BE USED WHEN UNSTRUCTURED GRID IS USED, IT SAVES THE CONNECTIVITY OF THE UNSTRUCTURED GIRD. + !< @NOTE THE VECTOR **CONNECT** MUST FOLLOW THE VTK-XML STANDARD. IT IS PASSED AS *ASSUMED-SHAPE ARRAY* + !< BECAUSE ITS DIMENSIONS IS RELATED TO THE MESH DIMENSIONS IN A COMPLEX WAY. ITS DIMENSIONS CAN BE CALCULATED BY THE FOLLOWING + !< EQUATION: \(DC = \SUM\LIMITS_{I = 1}^{NC} {NVERTEX_I }\). + !< NOTE THAT THIS EQUATION IS DIFFERENT FROM THE LEGACY ONE. THE XML CONNECTIVITY CONVENTION IS QUITE DIFFERENT FROM THE + !< LEGACY STANDARD. + !< AS AN EXAMPLE SUPPOSE WE HAVE A MESH COMPOSED BY 2 CELLS, ONE HEXAHEDRON (8 VERTICES) AND ONE PYRAMID WITH + !< SQUARE BASIS (5 VERTICES) AND SUPPOSE THAT THE BASIS OF PYRAMID IS CONSTITUTE BY A FACE OF THE HEXAHEDRON AND SO THE TWO CELLS + !< SHARE 4 VERTICES. THE ABOVE EQUATION GIVES \(DC=8+5=13\). THE CONNECTIVITY VECTOR FOR THIS MESH CAN BE: + !< + !<##### FIRST CELL + !<+ CONNECT(1) = 0 IDENTIFICATION FLAG OF \(1^\CIRC\) VERTEX OF FIRST CELL + !<+ CONNECT(2) = 1 IDENTIFICATION FLAG OF \(2^\CIRC\) VERTEX OF FIRST CELL + !<+ CONNECT(3) = 2 IDENTIFICATION FLAG OF \(3^\CIRC\) VERTEX OF FIRST CELL + !<+ CONNECT(4) = 3 IDENTIFICATION FLAG OF \(4^\CIRC\) VERTEX OF FIRST CELL + !<+ CONNECT(5) = 4 IDENTIFICATION FLAG OF \(5^\CIRC\) VERTEX OF FIRST CELL + !<+ CONNECT(6) = 5 IDENTIFICATION FLAG OF \(6^\CIRC\) VERTEX OF FIRST CELL + !<+ CONNECT(7) = 6 IDENTIFICATION FLAG OF \(7^\CIRC\) VERTEX OF FIRST CELL + !<+ CONNECT(8) = 7 IDENTIFICATION FLAG OF \(8^\CIRC\) VERTEX OF FIRST CELL + !< + !<##### SECOND CELL + !<+ CONNECT(9 ) = 0 IDENTIFICATION FLAG OF \(1^\CIRC\) VERTEX OF SECOND CELL + !<+ CONNECT(10) = 1 IDENTIFICATION FLAG OF \(2^\CIRC\) VERTEX OF SECOND CELL + !<+ CONNECT(11) = 2 IDENTIFICATION FLAG OF \(3^\CIRC\) VERTEX OF SECOND CELL + !<+ CONNECT(12) = 3 IDENTIFICATION FLAG OF \(4^\CIRC\) VERTEX OF SECOND CELL + !<+ CONNECT(13) = 8 IDENTIFICATION FLAG OF \(5^\CIRC\) VERTEX OF SECOND CELL + !< + !< THEREFORE THIS CONNECTIVITY VECTOR CONVENTION IS MORE SIMPLE THAN THE LEGACY CONVENTION, NOW WE MUST CREATE ALSO THE + !< *OFFSET* VECTOR THAT CONTAINS THE DATA NOW MISSING IN THE *CONNECT* VECTOR. THE OFFSET + !< VECTOR FOR THIS MESH CAN BE: + !< + !<##### FIRST CELL + !<+ OFFSET(1) = 8 => SUMM OF NODES OF \(1^\CIRC\) CELL + !< + !<##### SECOND CELL + !<+ OFFSET(2) = 13 => SUMM OF NODES OF \(1^\CIRC\) AND \(2^\CIRC\) CELLS + !< + !< THE VALUE OF EVERY CELL-OFFSET CAN BE CALCULATED BY THE FOLLOWING EQUATION: \(OFFSET_C=\SUM\LIMITS_{I=1}^{C}{NVERTEX_I}\) + !< WHERE \(OFFSET_C\) IS THE VALUE OF \(C^{TH}\) CELL AND \(NVERTEX_I\) IS THE NUMBER OF VERTICES OF \(I^{TH}\) CELL. + !< THE FUNCTION VTK_CON_XML DOES NOT CALCULATE THE CONNECTIVITY AND OFFSET VECTORS: IT WRITES THE CONNECTIVITY AND OFFSET + !< VECTORS CONFORMING THE VTK-XML STANDARD, BUT DOES NOT CALCULATE THEM. + !< THE VECTOR VARIABLE *CELL\_TYPE* MUST CONFORM THE VTK-XML STANDARD (SEE THE FILE VTK-STANDARD AT THE + !< KITWARE HOMEPAGE) THAT IS THE SAME OF THE LEGACY STANDARD. IT CONTAINS THE + !< *TYPE* OF EACH CELLS. FOR THE ABOVE EXAMPLE THIS VECTOR IS: + !< + !<##### FIRST CELL + !<+ CELL\_TYPE(1) = 12 HEXAHEDRON TYPE OF FIRST CELL + !< + !<##### SECOND CELL + !<+ CELL\_TYPE(2) = 14 PYRAMID TYPE OF SECOND CELL + CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT) :: SELF !< WRITER. + INTEGER(I4P), INTENT(IN) :: NC !< NUMBER OF CELLS. + INTEGER(I4P), INTENT(IN) :: CONNECTIVITY(1:) !< MESH CONNECTIVITY. + INTEGER(I4P), INTENT(IN) :: OFFSET(1:) !< CELL OFFSET. + INTEGER(I4P), OPTIONAL, INTENT(IN) :: FACE(1:) !< FACE COMPOSING THE POLYHEDRA. + INTEGER(I4P), OPTIONAL, INTENT(IN) :: FACEOFFSET(1:) !< FACE OFFSET. + INTEGER(I1P), INTENT(IN) :: VTKC_TYPE(1:) !< VTK CELL TYPE. + INTEGER(I4P) :: ERROR !< ERROR STATUS. + + CALL SELF%WRITE_START_TAG(NAME='Cells') + ERROR = SELF%W_DATA(DATA_NAME='connectivity', X=CONNECTIVITY) + ERROR = SELF%W_DATA(DATA_NAME='offsets', X=OFFSET) + ERROR = SELF%W_DATA(DATA_NAME='types', X=VTKC_TYPE) + CALL SELF%WRITE_END_TAG(NAME='Cells') + + !< ADD FACES AND FACEOFFSETS TO THE CELL BLOCK FOR POLYHEDRA. IF THE CELL IS NOT A POLYHEDRON, ITS OFFSET MUST BE SET TO -1. + IF(PRESENT(FACE).AND. PRESENT(FACEOFFSET)) THEN + ERROR = SELF%W_DATA(DATA_NAME='Faces', X=FACE) + ERROR = SELF%W_DATA(DATA_NAME='FaceOffsets', X=FACEOFFSET) + ENDIF + ENDFUNCTION WRITE_CONNECTIVITY + + ! WRITE_PARALLEL METHODS + FUNCTION WRITE_PARALLEL_OPEN_BLOCK(SELF, NAME) RESULT(ERROR) + !< WRITE A BLOCK (OPEN) CONTAINER. + CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT) :: SELF !< WRITER. + CHARACTER(*), INTENT(IN), OPTIONAL :: NAME !< BLOCK NAME. + INTEGER(I4P) :: ERROR !< ERROR STATUS. + TYPE(STRING) :: BUFFER !< BUFFER STRING. + + SELF%VTM_BLOCK = SELF%VTM_BLOCK + 1 + IF (PRESENT(NAME)) THEN + BUFFER = 'Index="'//TRIM(STR((SELF%VTM_BLOCK(1) + SELF%VTM_BLOCK(2)),.TRUE.))//'" Name="'//TRIM(ADJUSTL(NAME))//'"' + ELSE + BUFFER = 'Index="'//TRIM(STR((SELF%VTM_BLOCK(1) + SELF%VTM_BLOCK(2)),.TRUE.))//'"' + ENDIF + CALL SELF%WRITE_START_TAG(NAME='Block', ATTRIBUTES=BUFFER%CHARS()) + ERROR = SELF%ERROR + ENDFUNCTION WRITE_PARALLEL_OPEN_BLOCK + + FUNCTION WRITE_PARALLEL_CLOSE_BLOCK(SELF) RESULT(ERROR) + !< CLOSE A BLOCK CONTAINER. + CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT) :: SELF !< WRITER. + INTEGER(I4P) :: ERROR !< ERROR STATUS. + + SELF%VTM_BLOCK(2) = -1 + CALL SELF%WRITE_END_TAG(NAME='Block') + ERROR = SELF%ERROR + ENDFUNCTION WRITE_PARALLEL_CLOSE_BLOCK + + FUNCTION WRITE_PARALLEL_DATAARRAY(SELF, DATA_NAME, DATA_TYPE, NUMBER_OF_COMPONENTS) RESULT(ERROR) + !< WRITE PARALLEL (PARTITIONED) VTK-XML DATAARRAY INFO. + CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT) :: SELF !< WRITER. + CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. + CHARACTER(*), INTENT(IN) :: DATA_TYPE !< TYPE OF DATAARRAY. + INTEGER(I4P), INTENT(IN), OPTIONAL :: NUMBER_OF_COMPONENTS !< NUMBER OF DATAARRAY COMPONENTS. + INTEGER(I4P) :: ERROR !< ERROR STATUS. + TYPE(STRING) :: BUFFER !< BUFFER STRING. + + IF (PRESENT(NUMBER_OF_COMPONENTS)) THEN + BUFFER = 'type="'//TRIM(ADJUSTL(DATA_TYPE))//'" Name="'//TRIM(ADJUSTL(DATA_NAME))//& + '" NumberOfComponents="'//TRIM(STR(NUMBER_OF_COMPONENTS, .TRUE.))//'"' + ELSE + BUFFER = 'type="'//TRIM(ADJUSTL(DATA_TYPE))//'" Name="'//TRIM(ADJUSTL(DATA_NAME))//'"' + ENDIF + CALL SELF%WRITE_SELF_CLOSING_TAG(NAME='PDataArray', ATTRIBUTES=BUFFER%CHARS()) + ERROR = SELF%ERROR + ENDFUNCTION WRITE_PARALLEL_DATAARRAY + + FUNCTION WRITE_PARALLEL_GEO(SELF, SOURCE, NX1, NX2, NY1, NY2, NZ1, NZ2) RESULT(ERROR) + !< WRITE PARALLEL (PARTITIONED) VTK-XML GEO SOURCE FILE. + CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT) :: SELF !< WRITER. + CHARACTER(*), INTENT(IN) :: SOURCE !< SOURCE FILE NAME CONTAINING THE PIECE DATA. + INTEGER(I4P), INTENT(IN), OPTIONAL :: NX1 !< INITIAL NODE OF X AXIS. + INTEGER(I4P), INTENT(IN), OPTIONAL :: NX2 !< FINAL NODE OF X AXIS. + INTEGER(I4P), INTENT(IN), OPTIONAL :: NY1 !< INITIAL NODE OF Y AXIS. + INTEGER(I4P), INTENT(IN), OPTIONAL :: NY2 !< FINAL NODE OF Y AXIS. + INTEGER(I4P), INTENT(IN), OPTIONAL :: NZ1 !< INITIAL NODE OF Z AXIS. + INTEGER(I4P), INTENT(IN), OPTIONAL :: NZ2 !< FINAL NODE OF Z AXIS. + INTEGER(I4P) :: ERROR !< ERROR STATUS. + TYPE(STRING) :: BUFFER !< BUFFER STRING. + + SELECT CASE (SELF%TOPOLOGY%CHARS()) + CASE('PRectilinearGrid', 'PStructuredGrid') + BUFFER = 'Extent="'// & + TRIM(STR(N=NX1))//' '//TRIM(STR(N=NX2))//' '// & + TRIM(STR(N=NY1))//' '//TRIM(STR(N=NY2))//' '// & + TRIM(STR(N=NZ1))//' '//TRIM(STR(N=NZ2))//'" Source="'//TRIM(ADJUSTL(SOURCE))//'"' + CASE('PUnstructuredGrid') + BUFFER = 'Source="'//TRIM(ADJUSTL(SOURCE))//'"' + ENDSELECT + CALL SELF%WRITE_SELF_CLOSING_TAG(NAME='Piece', ATTRIBUTES=BUFFER%CHARS()) + ERROR = SELF%ERROR + ENDFUNCTION WRITE_PARALLEL_GEO + + FUNCTION WRITE_PARALLEL_BLOCK_FILE(SELF, FILE_INDEX, FILENAME, NAME) RESULT(ERROR) + !< WRITE SINGLE FILE THAT BELONG TO THE CURRENT BLOCK. + CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT) :: SELF !< WRITER. + INTEGER(I4P), INTENT(IN) :: FILE_INDEX !< INDEX OF FILE IN THE LIST. + CHARACTER(*), INTENT(IN) :: FILENAME !< WRAPPED FILE NAMES. + CHARACTER(*), INTENT(IN), OPTIONAL :: NAME !< NAMES ATTRIBUTED TO WRAPPED FILE. + INTEGER(I4P) :: ERROR !< ERROR STATUS. + + IF (PRESENT(NAME)) THEN + CALL SELF%WRITE_SELF_CLOSING_TAG(NAME='Dataset', & + ATTRIBUTES='Index="'//TRIM(STR(FILE_INDEX, .TRUE.))//& + '" File="'//TRIM(ADJUSTL(FILENAME))// & + '" Name="'//TRIM(ADJUSTL(NAME))//'"') + ELSE + CALL SELF%WRITE_SELF_CLOSING_TAG(NAME='Dataset', & + ATTRIBUTES='Index="'//TRIM(STR(FILE_INDEX, .TRUE.))// & + '" File="'//TRIM(ADJUSTL(FILENAME))//'"') + ENDIF + ERROR = SELF%ERROR + ENDFUNCTION WRITE_PARALLEL_BLOCK_FILE + + FUNCTION WRITE_PARALLEL_BLOCK_FILES_ARRAY(SELF, FILENAMES, NAMES) RESULT(ERROR) + !< WRITE LIST OF FILES THAT BELONG TO THE CURRENT BLOCK (LIST PASSED AS RANK 1 ARRAY). + !< + !<#### EXAMPLE OF USAGE: 3 FILES BLOCKS + !<```FORTRAN + !< ERROR = VTM%WRITE_FILES_LIST_OF_BLOCK(FILENAMES=['FILE_1.VTS','FILE_2.VTS','FILE_3.VTU']) + !<``` + !< + !<#### EXAMPLE OF USAGE: 3 FILES BLOCKS WITH CUSTOM NAME + !<```FORTRAN + !< ERROR = VTM%WRITE_FILES_LIST_OF_BLOCK(FILENAMES=['FILE_1.VTS','FILE_2.VTS','FILE_3.VTU'],& + !< NAMES=['BLOCK-BAR','BLOCK-FOO','BLOCK-BAZ']) + !<``` + CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT) :: SELF !< WRITER. + CHARACTER(*), INTENT(IN) :: FILENAMES(:) !< LIST OF VTK-XML WRAPPED FILE NAMES. + CHARACTER(*), INTENT(IN), OPTIONAL :: NAMES(:) !< LIST NAMES ATTRIBUTED TO WRAPPED FILES. + INTEGER(I4P) :: ERROR !< ERROR STATUS. + INTEGER(I4P) :: F !< FILE COUNTER. + + IF (PRESENT(NAMES)) THEN + IF (SIZE(NAMES, DIM=1)==SIZE(FILENAMES, DIM=1)) THEN + DO F=1, SIZE(FILENAMES, DIM=1) + CALL SELF%WRITE_SELF_CLOSING_TAG(NAME='Dataset', & + ATTRIBUTES='Index="'//TRIM(STR(F-1, .TRUE.))// & + '" File="'//TRIM(ADJUSTL(FILENAMES(F)))// & + '" Name="'//TRIM(ADJUSTL(NAMES(F)))//'"') + ENDDO + ENDIF + ELSE + DO F=1,SIZE(FILENAMES, DIM=1) + CALL SELF%WRITE_SELF_CLOSING_TAG(NAME='Dataset', & + ATTRIBUTES='Index="'//TRIM(STR(F-1, .TRUE.))// & + '" File="'//TRIM(ADJUSTL(FILENAMES(F)))//'"') + ENDDO + ENDIF + ERROR = SELF%ERROR + ENDFUNCTION WRITE_PARALLEL_BLOCK_FILES_ARRAY + + FUNCTION WRITE_PARALLEL_BLOCK_FILES_STRING(SELF, FILENAMES, NAMES, DELIMITER) RESULT(ERROR) + !< WRITE LIST OF FILES THAT BELONG TO THE CURRENT BLOCK (LIST PASSED AS SINGLE STRING). + !< + !<#### EXAMPLE OF USAGE: 3 FILES BLOCKS + !<```FORTRAN + !< ERROR = VTM%WRITE_FILES_LIST_OF_BLOCK(FILENAMES='FILE_1.VTS FILE_2.VTS FILE_3.VTU') + !<``` + !< + !<#### EXAMPLE OF USAGE: 3 FILES BLOCKS WITH CUSTOM NAME + !<```FORTRAN + !< ERROR = VTM%WRITE_FILES_LIST_OF_BLOCK(FILENAMES='FILE_1.VTS FILE_2.VTS FILE_3.VTU',& + !< NAMES='BLOCK-BAR BLOCK-FOO BLOCK-BAZ') + !<``` + CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT) :: SELF !< WRITER. + CHARACTER(*), INTENT(IN) :: FILENAMES !< LIST OF VTK-XML WRAPPED FILE NAMES. + CHARACTER(*), INTENT(IN), OPTIONAL :: NAMES !< LIST NAMES ATTRIBUTED TO WRAPPED FILES. + CHARACTER(*), INTENT(IN), OPTIONAL :: DELIMITER !< DELIMITER CHARACTER. + INTEGER(I4P) :: ERROR !< ERROR STATUS. + TYPE(STRING), ALLOCATABLE :: FILENAMES_(:) !< LIST OF VTK-XML WRAPPED FILE NAMES. + TYPE(STRING), ALLOCATABLE :: NAMES_(:) !< LIST NAMES ATTRIBUTED TO WRAPPED FILES. + TYPE(STRING) :: DELIMITER_ !< DELIMITER CHARACTER. + TYPE(STRING) :: BUFFER !< A STRING BUFFER. + INTEGER(I4P) :: F !< FILE COUNTER. + + DELIMITER_ = ' ' ; IF (PRESENT(DELIMITER)) DELIMITER_ = DELIMITER + BUFFER = FILENAMES + CALL BUFFER%SPLIT(TOKENS=FILENAMES_, SEP=DELIMITER_%CHARS()) + IF (PRESENT(NAMES)) THEN + BUFFER = NAMES + CALL BUFFER%SPLIT(TOKENS=NAMES_, SEP=DELIMITER_%CHARS()) + IF (SIZE(NAMES_, DIM=1)==SIZE(FILENAMES_, DIM=1)) THEN + DO F=1, SIZE(FILENAMES_, DIM=1) + CALL SELF%WRITE_SELF_CLOSING_TAG(NAME='Dataset', & + ATTRIBUTES='Index="'//TRIM(STR(F-1, .TRUE.))// & + '" File="'//TRIM(ADJUSTL(FILENAMES_(F)))// & + '" Name="'//TRIM(ADJUSTL(NAMES_(F)))//'"') + ENDDO + ENDIF + ELSE + DO F=1,SIZE(FILENAMES_, DIM=1) + CALL SELF%WRITE_SELF_CLOSING_TAG(NAME='Dataset', & + ATTRIBUTES='Index="'//TRIM(STR(F-1,.TRUE.))// & + '" File="'//TRIM(ADJUSTL(FILENAMES_(F)))//'"') + ENDDO + ENDIF + ERROR = SELF%ERROR + ENDFUNCTION WRITE_PARALLEL_BLOCK_FILES_STRING +ENDMODULE VTKF_FILE_XML_WRITER_ABSTRACT + + + +!< DATAARRAY ENCODER, CODECS: "ASCII", "BASE64". +MODULE VTK_FORTRAN_DATAARRAY_ENCODER +!< VTK FILE XML WRITER, ASCII LOCAL. +USE BEFOR64 +USE PENF + +IMPLICIT NONE +PRIVATE +PUBLIC :: ENCODE_ASCII_DATAARRAY +PUBLIC :: ENCODE_BINARY_DATAARRAY + +INTERFACE ENCODE_ASCII_DATAARRAY + !< ASCII DATAARRAY ENCODER. + MODULE PROCEDURE ENCODE_ASCII_DATAARRAY1_RANK1_R8P, & + ENCODE_ASCII_DATAARRAY1_RANK1_R4P, & + ENCODE_ASCII_DATAARRAY1_RANK1_I8P, & + ENCODE_ASCII_DATAARRAY1_RANK1_I4P, & + ENCODE_ASCII_DATAARRAY1_RANK1_I2P, & + ENCODE_ASCII_DATAARRAY1_RANK1_I1P, & + ENCODE_ASCII_DATAARRAY1_RANK2_R8P, & + ENCODE_ASCII_DATAARRAY1_RANK2_R4P, & + ENCODE_ASCII_DATAARRAY1_RANK2_I8P, & + ENCODE_ASCII_DATAARRAY1_RANK2_I4P, & + ENCODE_ASCII_DATAARRAY1_RANK2_I2P, & + ENCODE_ASCII_DATAARRAY1_RANK2_I1P, & + ENCODE_ASCII_DATAARRAY1_RANK3_R8P, & + ENCODE_ASCII_DATAARRAY1_RANK3_R4P, & + ENCODE_ASCII_DATAARRAY1_RANK3_I8P, & + ENCODE_ASCII_DATAARRAY1_RANK3_I4P, & + ENCODE_ASCII_DATAARRAY1_RANK3_I2P, & + ENCODE_ASCII_DATAARRAY1_RANK3_I1P, & + ENCODE_ASCII_DATAARRAY1_RANK4_R8P, & + ENCODE_ASCII_DATAARRAY1_RANK4_R4P, & + ENCODE_ASCII_DATAARRAY1_RANK4_I8P, & + ENCODE_ASCII_DATAARRAY1_RANK4_I4P, & + ENCODE_ASCII_DATAARRAY1_RANK4_I2P, & + ENCODE_ASCII_DATAARRAY1_RANK4_I1P, & + ENCODE_ASCII_DATAARRAY3_RANK1_R8P, & + ENCODE_ASCII_DATAARRAY3_RANK1_R4P, & + ENCODE_ASCII_DATAARRAY3_RANK1_I8P, & + ENCODE_ASCII_DATAARRAY3_RANK1_I4P, & + ENCODE_ASCII_DATAARRAY3_RANK1_I2P, & + ENCODE_ASCII_DATAARRAY3_RANK1_I1P, & + ENCODE_ASCII_DATAARRAY3_RANK3_R8P, & + ENCODE_ASCII_DATAARRAY3_RANK3_R4P, & + ENCODE_ASCII_DATAARRAY3_RANK3_I8P, & + ENCODE_ASCII_DATAARRAY3_RANK3_I4P, & + ENCODE_ASCII_DATAARRAY3_RANK3_I2P, & + ENCODE_ASCII_DATAARRAY3_RANK3_I1P, & + ENCODE_ASCII_DATAARRAY6_RANK1_R8P, & + ENCODE_ASCII_DATAARRAY6_RANK1_R4P, & + ENCODE_ASCII_DATAARRAY6_RANK1_I8P, & + ENCODE_ASCII_DATAARRAY6_RANK1_I4P, & + ENCODE_ASCII_DATAARRAY6_RANK1_I2P, & + ENCODE_ASCII_DATAARRAY6_RANK1_I1P, & + ENCODE_ASCII_DATAARRAY6_RANK3_R8P, & + ENCODE_ASCII_DATAARRAY6_RANK3_R4P, & + ENCODE_ASCII_DATAARRAY6_RANK3_I8P, & + ENCODE_ASCII_DATAARRAY6_RANK3_I4P, & + ENCODE_ASCII_DATAARRAY6_RANK3_I2P, & + ENCODE_ASCII_DATAARRAY6_RANK3_I1P +ENDINTERFACE ENCODE_ASCII_DATAARRAY +INTERFACE ENCODE_BINARY_DATAARRAY + !< BINARY (BASE64) DATAARRAY ENCODER. + MODULE PROCEDURE ENCODE_BINARY_DATAARRAY1_RANK1_R8P, & + ENCODE_BINARY_DATAARRAY1_RANK1_R4P, & + ENCODE_BINARY_DATAARRAY1_RANK1_I8P, & + ENCODE_BINARY_DATAARRAY1_RANK1_I4P, & + ENCODE_BINARY_DATAARRAY1_RANK1_I2P, & + ENCODE_BINARY_DATAARRAY1_RANK1_I1P, & + ENCODE_BINARY_DATAARRAY1_RANK2_R8P, & + ENCODE_BINARY_DATAARRAY1_RANK2_R4P, & + ENCODE_BINARY_DATAARRAY1_RANK2_I8P, & + ENCODE_BINARY_DATAARRAY1_RANK2_I4P, & + ENCODE_BINARY_DATAARRAY1_RANK2_I2P, & + ENCODE_BINARY_DATAARRAY1_RANK2_I1P, & + ENCODE_BINARY_DATAARRAY1_RANK3_R8P, & + ENCODE_BINARY_DATAARRAY1_RANK3_R4P, & + ENCODE_BINARY_DATAARRAY1_RANK3_I8P, & + ENCODE_BINARY_DATAARRAY1_RANK3_I4P, & + ENCODE_BINARY_DATAARRAY1_RANK3_I2P, & + ENCODE_BINARY_DATAARRAY1_RANK3_I1P, & + ENCODE_BINARY_DATAARRAY1_RANK4_R8P, & + ENCODE_BINARY_DATAARRAY1_RANK4_R4P, & + ENCODE_BINARY_DATAARRAY1_RANK4_I8P, & + ENCODE_BINARY_DATAARRAY1_RANK4_I4P, & + ENCODE_BINARY_DATAARRAY1_RANK4_I2P, & + ENCODE_BINARY_DATAARRAY1_RANK4_I1P, & + ENCODE_BINARY_DATAARRAY3_RANK1_R8P, & + ENCODE_BINARY_DATAARRAY3_RANK1_R4P, & + ENCODE_BINARY_DATAARRAY3_RANK1_I8P, & + ENCODE_BINARY_DATAARRAY3_RANK1_I4P, & + ENCODE_BINARY_DATAARRAY3_RANK1_I2P, & + ENCODE_BINARY_DATAARRAY3_RANK1_I1P, & + ENCODE_BINARY_DATAARRAY3_RANK3_R8P, & + ENCODE_BINARY_DATAARRAY3_RANK3_R4P, & + ENCODE_BINARY_DATAARRAY3_RANK3_I8P, & + ENCODE_BINARY_DATAARRAY3_RANK3_I4P, & + ENCODE_BINARY_DATAARRAY3_RANK3_I2P, & + ENCODE_BINARY_DATAARRAY3_RANK3_I1P, & + ENCODE_BINARY_DATAARRAY6_RANK1_R8P, & + ENCODE_BINARY_DATAARRAY6_RANK1_R4P, & + ENCODE_BINARY_DATAARRAY6_RANK1_I8P, & + ENCODE_BINARY_DATAARRAY6_RANK1_I4P, & + ENCODE_BINARY_DATAARRAY6_RANK1_I2P, & + ENCODE_BINARY_DATAARRAY6_RANK1_I1P, & + ENCODE_BINARY_DATAARRAY6_RANK3_R8P, & + ENCODE_BINARY_DATAARRAY6_RANK3_R4P, & + ENCODE_BINARY_DATAARRAY6_RANK3_I8P, & + ENCODE_BINARY_DATAARRAY6_RANK3_I4P, & + ENCODE_BINARY_DATAARRAY6_RANK3_I2P, & + ENCODE_BINARY_DATAARRAY6_RANK3_I1P +ENDINTERFACE ENCODE_BINARY_DATAARRAY +CONTAINS + !< ASCII ENCODER + FUNCTION ENCODE_ASCII_DATAARRAY1_RANK1_R16P(X) RESULT(CODE) + !< ENCODE (BASE64) A DATAARRAY WITH 1 COMPONENTS OF RANK 1 (R8P). + REAL(R16P), INTENT(IN) :: X(1:) !< DATA VARIABLE. + CHARACTER(LEN=:), ALLOCATABLE :: CODE !< ENCODED BASE64 DATAARRAY. + INTEGER(I4P) :: N !< COUNTER. + INTEGER(I4P) :: L !< LENGTH + INTEGER(I4P) :: SP !< STRING POINTER + INTEGER(I4P) :: SIZE_N!< DIMENSION SIZE + + SIZE_N = SIZE(X,DIM=1) + L = DR16P+1 + SP = 0 + CODE = REPEAT(' ',L*SIZE_N) + DO N = 1,SIZE_N + CODE(SP+1:SP+L) = STR(N=X(N)) + SP = SP + L + ENDDO + ENDFUNCTION ENCODE_ASCII_DATAARRAY1_RANK1_R16P + + FUNCTION ENCODE_ASCII_DATAARRAY1_RANK1_R8P(X) RESULT(CODE) + !< ENCODE (BASE64) A DATAARRAY WITH 1 COMPONENTS OF RANK 1 (R8P). + REAL(R8P), INTENT(IN) :: X(1:) !< DATA VARIABLE. + CHARACTER(LEN=:), ALLOCATABLE :: CODE !< ENCODED BASE64 DATAARRAY. + INTEGER(I4P) :: N !< COUNTER. + INTEGER(I4P) :: L !< LENGTH + INTEGER(I4P) :: SP !< STRING POINTER + INTEGER(I4P) :: SIZE_N!< DIMENSION SIZE + + SIZE_N = SIZE(X,DIM=1) + L = DR8P+1 + SP = 0 + CODE = REPEAT(' ',L*SIZE_N) + DO N = 1,SIZE_N + CODE(SP+1:SP+L) = STR(N=X(N)) + SP = SP + L + ENDDO + ENDFUNCTION ENCODE_ASCII_DATAARRAY1_RANK1_R8P + + FUNCTION ENCODE_ASCII_DATAARRAY1_RANK1_R4P(X) RESULT(CODE) + !< ENCODE (BASE64) A DATAARRAY WITH 1 COMPONENTS OF RANK 1 (R4P). + REAL(R4P), INTENT(IN) :: X(1:) !< DATA VARIABLE. + CHARACTER(LEN=:), ALLOCATABLE :: CODE !< ENCODED BASE64 DATAARRAY. + INTEGER(I4P) :: N !< COUNTER. + INTEGER(I4P) :: L !< LENGTH + INTEGER(I4P) :: SP !< STRING POINTER + INTEGER(I4P) :: SIZE_N!< DIMENSION SIZE + + SIZE_N = SIZE(X,DIM=1) + L = DR4P+1 + SP = 0 + CODE = REPEAT(' ',L*SIZE_N) + DO N = 1,SIZE_N + CODE(SP+1:SP+L) = STR(N=X(N)) + SP = SP + L + ENDDO + ENDFUNCTION ENCODE_ASCII_DATAARRAY1_RANK1_R4P + + FUNCTION ENCODE_ASCII_DATAARRAY1_RANK1_I8P(X) RESULT(CODE) + !< ENCODE (BASE64) A DATAARRAY WITH 1 COMPONENTS OF RANK 1 (I8P). + INTEGER(I8P), INTENT(IN) :: X(1:) !< DATA VARIABLE. + CHARACTER(LEN=:), ALLOCATABLE :: CODE !< ENCODED BASE64 DATAARRAY. + INTEGER(I4P) :: N !< COUNTER. + INTEGER(I4P) :: L !< LENGTH + INTEGER(I4P) :: SP !< STRING POINTER + INTEGER(I4P) :: SIZE_N!< DIMENSION SIZE + + SIZE_N = SIZE(X,DIM=1) + L = DI8P+1 + SP = 0 + CODE = REPEAT(' ',L*SIZE_N) + DO N = 1,SIZE_N + CODE(SP+1:SP+L) = STR(N=X(N)) + SP = SP + L + ENDDO + ENDFUNCTION ENCODE_ASCII_DATAARRAY1_RANK1_I8P + + FUNCTION ENCODE_ASCII_DATAARRAY1_RANK1_I4P(X) RESULT(CODE) + !< ENCODE (BASE64) A DATAARRAY WITH 1 COMPONENTS OF RANK 1 (I4P). + INTEGER(I4P), INTENT(IN) :: X(1:) !< DATA VARIABLE. + CHARACTER(LEN=:), ALLOCATABLE :: CODE !< ENCODED BASE64 DATAARRAY. + INTEGER(I4P) :: N !< COUNTER. + INTEGER(I4P) :: L !< LENGTH + INTEGER(I4P) :: SP !< STRING POINTER + INTEGER(I4P) :: SIZE_N!< DIMENSION SIZE + + SIZE_N = SIZE(X,DIM=1) + L = DI4P+1 + SP = 0 + CODE = REPEAT(' ',L*SIZE_N) + DO N = 1,SIZE_N + CODE(SP+1:SP+L) = STR(N=X(N)) + SP = SP + L + ENDDO + ENDFUNCTION ENCODE_ASCII_DATAARRAY1_RANK1_I4P + + FUNCTION ENCODE_ASCII_DATAARRAY1_RANK1_I2P(X) RESULT(CODE) + !< ENCODE (BASE64) A DATAARRAY WITH 1 COMPONENTS OF RANK 1 (I2P). + INTEGER(I2P), INTENT(IN) :: X(1:) !< DATA VARIABLE. + CHARACTER(LEN=:), ALLOCATABLE :: CODE !< ENCODED BASE64 DATAARRAY. + INTEGER(I4P) :: N !< COUNTER. + INTEGER(I4P) :: L !< LENGTH + INTEGER(I4P) :: SP !< STRING POINTER + INTEGER(I4P) :: SIZE_N!< DIMENSION SIZE + + SIZE_N = SIZE(X,DIM=1) + L = DI2P+1 + SP = 0 + CODE = REPEAT(' ',L*SIZE_N) + DO N = 1,SIZE_N + CODE(SP+1:SP+L) = STR(N=X(N)) + SP = SP + L + ENDDO + ENDFUNCTION ENCODE_ASCII_DATAARRAY1_RANK1_I2P + + FUNCTION ENCODE_ASCII_DATAARRAY1_RANK1_I1P(X) RESULT(CODE) + !< ENCODE (BASE64) A DATAARRAY WITH 1 COMPONENTS OF RANK 1 (I1P). + INTEGER(I1P), INTENT(IN) :: X(1:) !< DATA VARIABLE. + CHARACTER(LEN=:), ALLOCATABLE :: CODE !< ENCODED BASE64 DATAARRAY. + INTEGER(I4P) :: N !< COUNTER. + INTEGER(I4P) :: L !< LENGTH + INTEGER(I4P) :: SP !< STRING POINTER + INTEGER(I4P) :: SIZE_N!< DIMENSION SIZE + + SIZE_N = SIZE(X,DIM=1) + L = DI1P+1 + SP = 0 + CODE = REPEAT(' ',L*SIZE_N) + DO N = 1,SIZE_N + CODE(SP+1:SP+L) = STR(N=X(N)) + SP = SP + L + ENDDO + ENDFUNCTION ENCODE_ASCII_DATAARRAY1_RANK1_I1P + + FUNCTION ENCODE_ASCII_DATAARRAY1_RANK2_R16P(X) RESULT(CODE) + !< ENCODE (BASE64) A DATAARRAY WITH 1 COMPONENTS OF RANK 2 (R16P). + REAL(R16P), INTENT(IN) :: X(1:,1:) !< DATA VARIABLE + CHARACTER(LEN=:), ALLOCATABLE :: CODE !< ENCODED BASE64 DATAARRAY. + INTEGER(I4P) :: N1 !< COUNTER. + INTEGER(I4P) :: N2 !< COUNTER. + INTEGER(I4P) :: L !< LENGTH + INTEGER(I4P) :: SP !< STRING POINTER + INTEGER(I4P) :: SIZE_N1 !< DIMENSION 1 SIZE + INTEGER(I4P) :: SIZE_N2 !< DIMENSION 2 SIZE + + SIZE_N1 = SIZE(X, DIM=1) + SIZE_N2 = SIZE(X, DIM=2) + L = DR16P + 1 + SP = 0 + CODE = REPEAT(' ',L*SIZE_N1*SIZE_N2) + DO N2=1, SIZE(X, DIM=2) + DO N1=1, SIZE(X, DIM=1)-1 + CODE(SP+1:SP+L) = STR(N=X(N1, N2))//' ' + SP = SP + L + ENDDO + CODE(SP+1:SP+L) = ' '//STR(N=X(SIZE(X, DIM=1), N2)) + SP = SP + L + ENDDO + ENDFUNCTION ENCODE_ASCII_DATAARRAY1_RANK2_R16P + + FUNCTION ENCODE_ASCII_DATAARRAY1_RANK2_R8P(X) RESULT(CODE) + !< ENCODE (BASE64) A DATAARRAY WITH 1 COMPONENTS OF RANK 2 (R8P). + REAL(R8P), INTENT(IN) :: X(1:,1:) !< DATA VARIABLE + CHARACTER(LEN=:), ALLOCATABLE :: CODE !< ENCODED BASE64 DATAARRAY. + INTEGER(I4P) :: N1 !< COUNTER. + INTEGER(I4P) :: N2 !< COUNTER. + INTEGER(I4P) :: L !< LENGTH + INTEGER(I4P) :: SP !< STRING POINTER + INTEGER(I4P) :: SIZE_N1 !< DIMENSION 1 SIZE + INTEGER(I4P) :: SIZE_N2 !< DIMENSION 2 SIZE + + SIZE_N1 = SIZE(X, DIM=1) + SIZE_N2 = SIZE(X, DIM=2) + L = DR8P + 1 + SP = 0 + CODE = REPEAT(' ',L*SIZE_N1*SIZE_N2) + DO N2=1, SIZE(X, DIM=2) + DO N1=1, SIZE(X, DIM=1)-1 + CODE(SP+1:SP+L) = STR(N=X(N1, N2))//' ' + SP = SP + L + ENDDO + CODE(SP+1:SP+L) = ' '//STR(N=X(SIZE(X, DIM=1), N2)) + SP = SP + L + ENDDO + ENDFUNCTION ENCODE_ASCII_DATAARRAY1_RANK2_R8P + + FUNCTION ENCODE_ASCII_DATAARRAY1_RANK2_R4P(X) RESULT(CODE) + !< ENCODE (BASE64) A DATAARRAY WITH 1 COMPONENTS OF RANK 2 (R4P). + REAL(R4P), INTENT(IN) :: X(1:,1:) !< DATA VARIABLE + CHARACTER(LEN=:), ALLOCATABLE :: CODE !< ENCODED BASE64 DATAARRAY. + INTEGER(I4P) :: N1 !< COUNTER. + INTEGER(I4P) :: N2 !< COUNTER. + INTEGER(I4P) :: L !< LENGTH + INTEGER(I4P) :: SP !< STRING POINTER + INTEGER(I4P) :: SIZE_N1 !< DIMENSION 1 SIZE + INTEGER(I4P) :: SIZE_N2 !< DIMENSION 2 SIZE + + SIZE_N1 = SIZE(X, DIM=1) + SIZE_N2 = SIZE(X, DIM=2) + L = DR4P + 1 + SP = 0 + CODE = REPEAT(' ',L*SIZE_N1*SIZE_N2) + DO N2=1, SIZE(X, DIM=2) + DO N1=1, SIZE(X, DIM=1)-1 + CODE(SP+1:SP+L) = STR(N=X(N1, N2))//' ' + SP = SP + L + ENDDO + CODE(SP+1:SP+L) = ' '//STR(N=X(SIZE(X, DIM=1), N2)) + SP = SP + L + ENDDO + ENDFUNCTION ENCODE_ASCII_DATAARRAY1_RANK2_R4P + + FUNCTION ENCODE_ASCII_DATAARRAY1_RANK2_I8P(X) RESULT(CODE) + !< ENCODE (BASE64) A DATAARRAY WITH 1 COMPONENTS OF RANK 2 (I8P). + INTEGER(I8P), INTENT(IN) :: X(1:,1:) !< DATA VARIABLE + CHARACTER(LEN=:), ALLOCATABLE :: CODE !< ENCODED BASE64 DATAARRAY. + INTEGER(I4P) :: N1 !< COUNTER. + INTEGER(I4P) :: N2 !< COUNTER. + INTEGER(I4P) :: L !< LENGTH + INTEGER(I4P) :: SP !< STRING POINTER + INTEGER(I4P) :: SIZE_N1 !< DIMENSION 1 SIZE + INTEGER(I4P) :: SIZE_N2 !< DIMENSION 2 SIZE + + SIZE_N1 = SIZE(X, DIM=1) + SIZE_N2 = SIZE(X, DIM=2) + L = DI8P + 1 + SP = 0 + CODE = REPEAT(' ',L*SIZE_N1*SIZE_N2) + DO N2=1, SIZE(X, DIM=2) + DO N1=1, SIZE(X, DIM=1)-1 + CODE(SP+1:SP+L) = STR(N=X(N1, N2))//' ' + SP = SP + L + ENDDO + CODE(SP+1:SP+L) = ' '//STR(N=X(SIZE(X, DIM=1), N2)) + SP = SP + L + ENDDO + ENDFUNCTION ENCODE_ASCII_DATAARRAY1_RANK2_I8P + + FUNCTION ENCODE_ASCII_DATAARRAY1_RANK2_I4P(X) RESULT(CODE) + !< ENCODE (BASE64) A DATAARRAY WITH 1 COMPONENTS OF RANK 2 (I4P). + INTEGER(I4P), INTENT(IN) :: X(1:,1:) !< DATA VARIABLE + CHARACTER(LEN=:), ALLOCATABLE :: CODE !< ENCODED BASE64 DATAARRAY. + INTEGER(I4P) :: N1 !< COUNTER. + INTEGER(I4P) :: N2 !< COUNTER. + INTEGER(I4P) :: L !< LENGTH + INTEGER(I4P) :: SP !< STRING POINTER + INTEGER(I4P) :: SIZE_N1 !< DIMENSION 1 SIZE + INTEGER(I4P) :: SIZE_N2 !< DIMENSION 2 SIZE + + SIZE_N1 = SIZE(X, DIM=1) + SIZE_N2 = SIZE(X, DIM=2) + L = DI4P + 1 + SP = 0 + CODE = REPEAT(' ',L*SIZE_N1*SIZE_N2) + DO N2=1, SIZE(X, DIM=2) + DO N1=1, SIZE(X, DIM=1)-1 + CODE(SP+1:SP+L) = STR(N=X(N1, N2))//' ' + SP = SP + L + ENDDO + CODE(SP+1:SP+L) = ' '//STR(N=X(SIZE(X, DIM=1), N2)) + SP = SP + L + ENDDO + ENDFUNCTION ENCODE_ASCII_DATAARRAY1_RANK2_I4P + + FUNCTION ENCODE_ASCII_DATAARRAY1_RANK2_I2P(X) RESULT(CODE) + !< ENCODE (BASE64) A DATAARRAY WITH 1 COMPONENTS OF RANK 2 (I2P). + INTEGER(I2P), INTENT(IN) :: X(1:,1:) !< DATA VARIABLE + CHARACTER(LEN=:), ALLOCATABLE :: CODE !< ENCODED BASE64 DATAARRAY. + INTEGER(I4P) :: N1 !< COUNTER. + INTEGER(I4P) :: N2 !< COUNTER. + INTEGER(I4P) :: L !< LENGTH + INTEGER(I4P) :: SP !< STRING POINTER + INTEGER(I4P) :: SIZE_N1 !< DIMENSION 1 SIZE + INTEGER(I4P) :: SIZE_N2 !< DIMENSION 2 SIZE + + SIZE_N1 = SIZE(X, DIM=1) + SIZE_N2 = SIZE(X, DIM=2) + L = DI4P + 1 + SP = 0 + CODE = REPEAT(' ',L*SIZE_N1*SIZE_N2) + DO N2=1, SIZE(X, DIM=2) + DO N1=1, SIZE(X, DIM=1)-1 + CODE(SP+1:SP+L) = STR(N=X(N1, N2))//' ' + SP = SP + L + ENDDO + CODE(SP+1:SP+L) = ' '//STR(N=X(SIZE(X, DIM=1), N2)) + SP = SP + L + ENDDO + ENDFUNCTION ENCODE_ASCII_DATAARRAY1_RANK2_I2P + + FUNCTION ENCODE_ASCII_DATAARRAY1_RANK2_I1P(X) RESULT(CODE) + !< ENCODE (BASE64) A DATAARRAY WITH 1 COMPONENTS OF RANK 2 (I2P). + INTEGER(I1P), INTENT(IN) :: X(1:,1:) !< DATA VARIABLE + CHARACTER(LEN=:), ALLOCATABLE :: CODE !< ENCODED BASE64 DATAARRAY. + INTEGER(I4P) :: N1 !< COUNTER. + INTEGER(I4P) :: N2 !< COUNTER. + INTEGER(I4P) :: L !< LENGTH + INTEGER(I4P) :: SP !< STRING POINTER + INTEGER(I4P) :: SIZE_N1 !< DIMENSION 1 SIZE + INTEGER(I4P) :: SIZE_N2 !< DIMENSION 2 SIZE + + SIZE_N1 = SIZE(X, DIM=1) + SIZE_N2 = SIZE(X, DIM=2) + L = DI1P + 1 + SP = 0 + CODE = REPEAT(' ',L*SIZE_N1*SIZE_N2) + DO N2=1, SIZE(X, DIM=2) + DO N1=1, SIZE(X, DIM=1)-1 + CODE(SP+1:SP+L) = STR(N=X(N1, N2))//' ' + SP = SP + L + ENDDO + CODE(SP+1:SP+L) = ' '//STR(N=X(SIZE(X, DIM=1), N2)) + SP = SP + L + ENDDO + ENDFUNCTION ENCODE_ASCII_DATAARRAY1_RANK2_I1P + + FUNCTION ENCODE_ASCII_DATAARRAY1_RANK3_R16P(X) RESULT(CODE) + !< ENCODE (BASE64) A DATAARRAY WITH 1 COMPONENTS OF RANK 3 (R16P). + REAL(R16P), INTENT(IN) :: X(1:,1:,1:) !< DATA VARIABLE + CHARACTER(LEN=:), ALLOCATABLE :: CODE !< ENCODED BASE64 DATAARRAY. + INTEGER(I4P) :: N1 !< COUNTER. + INTEGER(I4P) :: N2 !< COUNTER. + INTEGER(I4P) :: N3 !< COUNTER. + INTEGER(I4P) :: L !< LENGTH + INTEGER(I4P) :: SP !< STRING POINTER + INTEGER(I4P) :: SIZE_N1 !< DIMENSION 1 SIZE + INTEGER(I4P) :: SIZE_N2 !< DIMENSION 2 SIZE + INTEGER(I4P) :: SIZE_N3 !< DIMENSION 3 SIZE + + SIZE_N1 = SIZE(X, DIM=1) + SIZE_N2 = SIZE(X, DIM=2) + SIZE_N3 = SIZE(X, DIM=3) + + L = DR16P + 1 + SP = 0 + CODE = REPEAT(' ',L*SIZE_N1*SIZE_N2*SIZE_N3) + DO N3=1, SIZE(X, DIM=3) + DO N2=1, SIZE(X, DIM=2) + DO N1=1, SIZE(X, DIM=1)-1 + CODE(SP+1:SP+L) = STR(N=X(N1, N2, N3))//' ' + SP = SP + 1 + ENDDO + CODE(SP+1:SP+L) = ' '//STR(N=X(SIZE(X, DIM=1), N2, N3)) + ENDDO + ENDDO + ENDFUNCTION ENCODE_ASCII_DATAARRAY1_RANK3_R16P + + FUNCTION ENCODE_ASCII_DATAARRAY1_RANK3_R8P(X) RESULT(CODE) + !< ENCODE (BASE64) A DATAARRAY WITH 1 COMPONENTS OF RANK 3 (R8P). + REAL(R8P), INTENT(IN) :: X(1:,1:,1:) !< DATA VARIABLE + CHARACTER(LEN=:), ALLOCATABLE :: CODE !< ENCODED BASE64 DATAARRAY. + INTEGER(I4P) :: N1 !< COUNTER. + INTEGER(I4P) :: N2 !< COUNTER. + INTEGER(I4P) :: N3 !< COUNTER. + INTEGER(I4P) :: L !< LENGTH + INTEGER(I4P) :: SP !< STRING POINTER + INTEGER(I4P) :: SIZE_N1 !< DIMENSION 1 SIZE + INTEGER(I4P) :: SIZE_N2 !< DIMENSION 2 SIZE + INTEGER(I4P) :: SIZE_N3 !< DIMENSION 3 SIZE + + SIZE_N1 = SIZE(X, DIM=1) + SIZE_N2 = SIZE(X, DIM=2) + SIZE_N3 = SIZE(X, DIM=3) + + L = DR8P + 1 + SP = 0 + CODE = REPEAT(' ',L*SIZE_N1*SIZE_N2*SIZE_N3) + DO N3=1, SIZE(X, DIM=3) + DO N2=1, SIZE(X, DIM=2) + DO N1=1, SIZE(X, DIM=1)-1 + CODE(SP+1:SP+L) = STR(N=X(N1, N2, N3))//' ' + SP = SP + L + ENDDO + CODE(SP+1:SP+L) = ' '//STR(N=X(SIZE(X, DIM=1), N2, N3)) + SP = SP + L + ENDDO + ENDDO + ENDFUNCTION ENCODE_ASCII_DATAARRAY1_RANK3_R8P + + FUNCTION ENCODE_ASCII_DATAARRAY1_RANK3_R4P(X) RESULT(CODE) + !< ENCODE (BASE64) A DATAARRAY WITH 1 COMPONENTS OF RANK 3 (R4P). + REAL(R4P), INTENT(IN) :: X(1:,1:,1:) !< DATA VARIABLE + CHARACTER(LEN=:), ALLOCATABLE :: CODE !< ENCODED BASE64 DATAARRAY. + INTEGER(I4P) :: N1 !< COUNTER. + INTEGER(I4P) :: N2 !< COUNTER. + INTEGER(I4P) :: N3 !< COUNTER. + INTEGER(I4P) :: L !< LENGTH + INTEGER(I4P) :: SP !< STRING POINTER + INTEGER(I4P) :: SIZE_N1 !< DIMENSION 1 SIZE + INTEGER(I4P) :: SIZE_N2 !< DIMENSION 2 SIZE + INTEGER(I4P) :: SIZE_N3 !< DIMENSION 3 SIZE + + SIZE_N1 = SIZE(X, DIM=1) + SIZE_N2 = SIZE(X, DIM=2) + SIZE_N3 = SIZE(X, DIM=3) + + L = DR4P + 1 + SP = 0 + CODE = REPEAT(' ',L*SIZE_N1*SIZE_N2*SIZE_N3) + DO N3=1, SIZE(X, DIM=3) + DO N2=1, SIZE(X, DIM=2) + DO N1=1, SIZE(X, DIM=1)-1 + CODE(SP+1:SP+L) = STR(N=X(N1, N2, N3))//' ' + SP = SP + L + ENDDO + CODE(SP+1:SP+L) = ' '//STR(N=X(SIZE(X, DIM=1), N2, N3)) + SP = SP + L + ENDDO + ENDDO + ENDFUNCTION ENCODE_ASCII_DATAARRAY1_RANK3_R4P + + FUNCTION ENCODE_ASCII_DATAARRAY1_RANK3_I8P(X) RESULT(CODE) + !< ENCODE (BASE64) A DATAARRAY WITH 1 COMPONENTS OF RANK 3 (I8P). + INTEGER(I8P), INTENT(IN) :: X(1:,1:,1:) !< DATA VARIABLE + CHARACTER(LEN=:), ALLOCATABLE :: CODE !< ENCODED BASE64 DATAARRAY. + INTEGER(I4P) :: N1 !< COUNTER. + INTEGER(I4P) :: N2 !< COUNTER. + INTEGER(I4P) :: N3 !< COUNTER. + INTEGER(I4P) :: L !< LENGTH + INTEGER(I4P) :: SP !< STRING POINTER + INTEGER(I4P) :: SIZE_N1 !< DIMENSION 1 SIZE + INTEGER(I4P) :: SIZE_N2 !< DIMENSION 2 SIZE + INTEGER(I4P) :: SIZE_N3 !< DIMENSION 3 SIZE + + SIZE_N1 = SIZE(X, DIM=1) + SIZE_N2 = SIZE(X, DIM=2) + SIZE_N3 = SIZE(X, DIM=3) + + L = DI8P + 1 + SP = 0 + CODE = REPEAT(' ',L*SIZE_N1*SIZE_N2*SIZE_N3) + DO N3=1, SIZE(X, DIM=3) + DO N2=1, SIZE(X, DIM=2) + DO N1=1, SIZE(X, DIM=1)-1 + CODE(SP+1:SP+L) = STR(N=X(N1, N2, N3))//' ' + SP = SP + L + ENDDO + CODE(SP+1:SP+L) = ' '//STR(N=X(SIZE(X, DIM=1), N2, N3)) + SP = SP + L + ENDDO + ENDDO + ENDFUNCTION ENCODE_ASCII_DATAARRAY1_RANK3_I8P + + FUNCTION ENCODE_ASCII_DATAARRAY1_RANK3_I4P(X) RESULT(CODE) + !< ENCODE (BASE64) A DATAARRAY WITH 1 COMPONENTS OF RANK 3 (I4P). + INTEGER(I4P), INTENT(IN) :: X(1:,1:,1:) !< DATA VARIABLE + CHARACTER(LEN=:), ALLOCATABLE :: CODE !< ENCODED BASE64 DATAARRAY. + INTEGER(I4P) :: N1 !< COUNTER. + INTEGER(I4P) :: N2 !< COUNTER. + INTEGER(I4P) :: N3 !< COUNTER. + INTEGER(I4P) :: L !< LENGTH + INTEGER(I4P) :: SP !< STRING POINTER + INTEGER(I4P) :: SIZE_N1 !< DIMENSION 1 SIZE + INTEGER(I4P) :: SIZE_N2 !< DIMENSION 2 SIZE + INTEGER(I4P) :: SIZE_N3 !< DIMENSION 3 SIZE + + SIZE_N1 = SIZE(X, DIM=1) + SIZE_N2 = SIZE(X, DIM=2) + SIZE_N3 = SIZE(X, DIM=3) + + L = DI4P + 1 + SP = 0 + CODE = REPEAT(' ',L*SIZE_N1*SIZE_N2*SIZE_N3) + DO N3=1, SIZE(X, DIM=3) + DO N2=1, SIZE(X, DIM=2) + DO N1=1, SIZE(X, DIM=1)-1 + CODE(SP+1:SP+L) = STR(N=X(N1, N2, N3))//' ' + SP = SP + L + ENDDO + CODE(SP+1:SP+L) = ' '//STR(N=X(SIZE(X, DIM=1), N2, N3)) + SP = SP + L + ENDDO + ENDDO + ENDFUNCTION ENCODE_ASCII_DATAARRAY1_RANK3_I4P + + FUNCTION ENCODE_ASCII_DATAARRAY1_RANK3_I2P(X) RESULT(CODE) + !< ENCODE (BASE64) A DATAARRAY WITH 1 COMPONENTS OF RANK 3 (I2P). + INTEGER(I2P), INTENT(IN) :: X(1:,1:,1:) !< DATA VARIABLE + CHARACTER(LEN=:), ALLOCATABLE :: CODE !< ENCODED BASE64 DATAARRAY. + INTEGER(I4P) :: N1 !< COUNTER. + INTEGER(I4P) :: N2 !< COUNTER. + INTEGER(I4P) :: N3 !< COUNTER. + INTEGER(I4P) :: L !< LENGTH + INTEGER(I4P) :: SP !< STRING POINTER + INTEGER(I4P) :: SIZE_N1 !< DIMENSION 1 SIZE + INTEGER(I4P) :: SIZE_N2 !< DIMENSION 2 SIZE + INTEGER(I4P) :: SIZE_N3 !< DIMENSION 3 SIZE + + SIZE_N1 = SIZE(X, DIM=1) + SIZE_N2 = SIZE(X, DIM=2) + SIZE_N3 = SIZE(X, DIM=3) + + L = DI2P + 1 + SP = 0 + CODE = REPEAT(' ',L*SIZE_N1*SIZE_N2*SIZE_N3) + DO N3=1, SIZE(X, DIM=3) + DO N2=1, SIZE(X, DIM=2) + DO N1=1, SIZE(X, DIM=1)-1 + CODE(SP+1:SP+L) = STR(N=X(N1, N2, N3))//' ' + SP = SP + L + ENDDO + CODE(SP+1:SP+L) = ' '//STR(N=X(SIZE(X, DIM=1), N2, N3)) + SP = SP + L + ENDDO + ENDDO + ENDFUNCTION ENCODE_ASCII_DATAARRAY1_RANK3_I2P + + FUNCTION ENCODE_ASCII_DATAARRAY1_RANK3_I1P(X) RESULT(CODE) + !< ENCODE (BASE64) A DATAARRAY WITH 1 COMPONENTS OF RANK 3 (I1P). + INTEGER(I1P), INTENT(IN) :: X(1:,1:,1:) !< DATA VARIABLE + CHARACTER(LEN=:), ALLOCATABLE :: CODE !< ENCODED BASE64 DATAARRAY. + INTEGER(I4P) :: N1 !< COUNTER. + INTEGER(I4P) :: N2 !< COUNTER. + INTEGER(I4P) :: N3 !< COUNTER. + INTEGER(I4P) :: L !< LENGTH + INTEGER(I4P) :: SP !< STRING POINTER + INTEGER(I4P) :: SIZE_N1 !< DIMENSION 1 SIZE + INTEGER(I4P) :: SIZE_N2 !< DIMENSION 2 SIZE + INTEGER(I4P) :: SIZE_N3 !< DIMENSION 3 SIZE + + SIZE_N1 = SIZE(X, DIM=1) + SIZE_N2 = SIZE(X, DIM=2) + SIZE_N3 = SIZE(X, DIM=3) + + L = DI1P + 1 + SP = 0 + CODE = REPEAT(' ',L*SIZE_N1*SIZE_N2*SIZE_N3) + DO N3=1, SIZE(X, DIM=3) + DO N2=1, SIZE(X, DIM=2) + DO N1=1, SIZE(X, DIM=1)-1 + CODE(SP+1:SP+L) = STR(N=X(N1, N2, N3))//' ' + SP = SP + L + ENDDO + CODE(SP+1:SP+L) = ' '//STR(N=X(SIZE(X, DIM=1), N2, N3)) + SP = SP + L + ENDDO + ENDDO + ENDFUNCTION ENCODE_ASCII_DATAARRAY1_RANK3_I1P + + FUNCTION ENCODE_ASCII_DATAARRAY1_RANK4_R16P(X) RESULT(CODE) + !< ENCODE (BASE64) A DATAARRAY WITH 1 COMPONENTS OF RANK 4 (R16P). + REAL(R16P), INTENT(IN) :: X(1:,1:,1:,1:) !< DATA VARIABLE. + CHARACTER(LEN=:), ALLOCATABLE :: CODE !< ENCODED BASE64 DATAARRAY. + INTEGER(I4P) :: N1 !< COUNTER. + INTEGER(I4P) :: N2 !< COUNTER. + INTEGER(I4P) :: N3 !< COUNTER. + INTEGER(I4P) :: N4 !< COUNTER. + INTEGER(I4P) :: L !< LENGTH + INTEGER(I4P) :: SP !< STRING POINTER + INTEGER(I4P) :: SIZE_N1 !< DIMENSION 1 SIZE + INTEGER(I4P) :: SIZE_N2 !< DIMENSION 2 SIZE + INTEGER(I4P) :: SIZE_N3 !< DIMENSION 3 SIZE + INTEGER(I4P) :: SIZE_N4 !< DIMENSION 4 SIZE + + SIZE_N1 = SIZE(X, DIM=1) + SIZE_N2 = SIZE(X, DIM=2) + SIZE_N3 = SIZE(X, DIM=3) + SIZE_N3 = SIZE(X, DIM=4) + + L = DR16P + 1 + SP = 0 + CODE = REPEAT(' ',L*SIZE_N1*SIZE_N2*SIZE_N3*SIZE_N4) + DO N4=1, SIZE(X, DIM=4) + DO N3=1, SIZE(X, DIM=3) + DO N2=1, SIZE(X, DIM=2) + DO N1=1, SIZE(X, DIM=1) + CODE(SP+1:SP+L) = STR(N=X(N1, N2, N3, N4))//' ' + SP = SP + L + ENDDO + ENDDO + ENDDO + ENDDO + ENDFUNCTION ENCODE_ASCII_DATAARRAY1_RANK4_R16P + + FUNCTION ENCODE_ASCII_DATAARRAY1_RANK4_R8P(X) RESULT(CODE) + !< ENCODE (BASE64) A DATAARRAY WITH 1 COMPONENTS OF RANK 4 (R8P). + REAL(R8P), INTENT(IN) :: X(1:,1:,1:,1:) !< DATA VARIABLE. + CHARACTER(LEN=:), ALLOCATABLE :: CODE !< ENCODED BASE64 DATAARRAY. + INTEGER(I4P) :: N1 !< COUNTER. + INTEGER(I4P) :: N2 !< COUNTER. + INTEGER(I4P) :: N3 !< COUNTER. + INTEGER(I4P) :: N4 !< COUNTER. + INTEGER(I4P) :: L !< LENGTH + INTEGER(I4P) :: SP !< STRING POINTER + INTEGER(I4P) :: SIZE_N1 !< DIMENSION 1 SIZE + INTEGER(I4P) :: SIZE_N2 !< DIMENSION 2 SIZE + INTEGER(I4P) :: SIZE_N3 !< DIMENSION 3 SIZE + INTEGER(I4P) :: SIZE_N4 !< DIMENSION 4 SIZE + + SIZE_N1 = SIZE(X, DIM=1) + SIZE_N2 = SIZE(X, DIM=2) + SIZE_N3 = SIZE(X, DIM=3) + SIZE_N3 = SIZE(X, DIM=4) + + L = DR8P + 1 + SP = 0 + CODE = REPEAT(' ',L*SIZE_N1*SIZE_N2*SIZE_N3*SIZE_N4) + DO N4=1, SIZE(X, DIM=4) + DO N3=1, SIZE(X, DIM=3) + DO N2=1, SIZE(X, DIM=2) + DO N1=1, SIZE(X, DIM=1) + CODE(SP+1:SP+L) = STR(N=X(N1, N2, N3, N4))//' ' + SP = SP + L + ENDDO + ENDDO + ENDDO + ENDDO + ENDFUNCTION ENCODE_ASCII_DATAARRAY1_RANK4_R8P + + FUNCTION ENCODE_ASCII_DATAARRAY1_RANK4_R4P(X) RESULT(CODE) + !< ENCODE (BASE64) A DATAARRAY WITH 1 COMPONENTS OF RANK 4 (R4P). + REAL(R4P), INTENT(IN) :: X(1:,1:,1:,1:) !< DATA VARIABLE. + CHARACTER(LEN=:), ALLOCATABLE :: CODE !< ENCODED BASE64 DATAARRAY. + INTEGER(I4P) :: N1 !< COUNTER. + INTEGER(I4P) :: N2 !< COUNTER. + INTEGER(I4P) :: N3 !< COUNTER. + INTEGER(I4P) :: N4 !< COUNTER. + INTEGER(I4P) :: L !< LENGTH + INTEGER(I4P) :: SP !< STRING POINTER + INTEGER(I4P) :: SIZE_N1 !< DIMENSION 1 SIZE + INTEGER(I4P) :: SIZE_N2 !< DIMENSION 2 SIZE + INTEGER(I4P) :: SIZE_N3 !< DIMENSION 3 SIZE + INTEGER(I4P) :: SIZE_N4 !< DIMENSION 4 SIZE + + SIZE_N1 = SIZE(X, DIM=1) + SIZE_N2 = SIZE(X, DIM=2) + SIZE_N3 = SIZE(X, DIM=3) + SIZE_N3 = SIZE(X, DIM=4) + + L = DR4P + 1 + SP = 0 + CODE = REPEAT(' ',L*SIZE_N1*SIZE_N2*SIZE_N3*SIZE_N4) + DO N4=1, SIZE(X, DIM=4) + DO N3=1, SIZE(X, DIM=3) + DO N2=1, SIZE(X, DIM=2) + DO N1=1, SIZE(X, DIM=1) + CODE(SP+1:SP+L) = STR(N=X(N1, N2, N3, N4))//' ' + SP = SP + L + ENDDO + ENDDO + ENDDO + ENDDO + ENDFUNCTION ENCODE_ASCII_DATAARRAY1_RANK4_R4P + + FUNCTION ENCODE_ASCII_DATAARRAY1_RANK4_I8P(X) RESULT(CODE) + !< ENCODE (BASE64) A DATAARRAY WITH 1 COMPONENTS OF RANK 4 (I8P). + INTEGER(I8P), INTENT(IN) :: X(1:,1:,1:,1:) !< DATA VARIABLE. + CHARACTER(LEN=:), ALLOCATABLE :: CODE !< ENCODED BASE64 DATAARRAY. + INTEGER(I4P) :: N1 !< COUNTER. + INTEGER(I4P) :: N2 !< COUNTER. + INTEGER(I4P) :: N3 !< COUNTER. + INTEGER(I4P) :: N4 !< COUNTER. + INTEGER(I4P) :: L !< LENGTH + INTEGER(I4P) :: SP !< STRING POINTER + INTEGER(I4P) :: SIZE_N1 !< DIMENSION 1 SIZE + INTEGER(I4P) :: SIZE_N2 !< DIMENSION 2 SIZE + INTEGER(I4P) :: SIZE_N3 !< DIMENSION 3 SIZE + INTEGER(I4P) :: SIZE_N4 !< DIMENSION 4 SIZE + + SIZE_N1 = SIZE(X, DIM=1) + SIZE_N2 = SIZE(X, DIM=2) + SIZE_N3 = SIZE(X, DIM=3) + SIZE_N3 = SIZE(X, DIM=4) + + L = DI8P + 1 + SP = 0 + CODE = REPEAT(' ',L*SIZE_N1*SIZE_N2*SIZE_N3*SIZE_N4) + DO N4=1, SIZE(X, DIM=4) + DO N3=1, SIZE(X, DIM=3) + DO N2=1, SIZE(X, DIM=2) + DO N1=1, SIZE(X, DIM=1) + CODE(SP+1:SP+L) = STR(N=X(N1, N2, N3, N4))//' ' + SP = SP + L + ENDDO + ENDDO + ENDDO + ENDDO + ENDFUNCTION ENCODE_ASCII_DATAARRAY1_RANK4_I8P + + FUNCTION ENCODE_ASCII_DATAARRAY1_RANK4_I4P(X) RESULT(CODE) + !< ENCODE (BASE64) A DATAARRAY WITH 1 COMPONENTS OF RANK 4 (I4P). + INTEGER(I4P), INTENT(IN) :: X(1:,1:,1:,1:) !< DATA VARIABLE. + CHARACTER(LEN=:), ALLOCATABLE :: CODE !< ENCODED BASE64 DATAARRAY. + INTEGER(I4P) :: N1 !< COUNTER. + INTEGER(I4P) :: N2 !< COUNTER. + INTEGER(I4P) :: N3 !< COUNTER. + INTEGER(I4P) :: N4 !< COUNTER. + INTEGER(I4P) :: L !< LENGTH + INTEGER(I4P) :: SP !< STRING POINTER + INTEGER(I4P) :: SIZE_N1 !< DIMENSION 1 SIZE + INTEGER(I4P) :: SIZE_N2 !< DIMENSION 2 SIZE + INTEGER(I4P) :: SIZE_N3 !< DIMENSION 3 SIZE + INTEGER(I4P) :: SIZE_N4 !< DIMENSION 4 SIZE + + SIZE_N1 = SIZE(X, DIM=1) + SIZE_N2 = SIZE(X, DIM=2) + SIZE_N3 = SIZE(X, DIM=3) + SIZE_N3 = SIZE(X, DIM=4) + + L = DI4P + 1 + SP = 0 + CODE = REPEAT(' ',L*SIZE_N1*SIZE_N2*SIZE_N3*SIZE_N4) + DO N4=1, SIZE(X, DIM=4) + DO N3=1, SIZE(X, DIM=3) + DO N2=1, SIZE(X, DIM=2) + DO N1=1, SIZE(X, DIM=1) + CODE(SP+1:SP+L) = STR(N=X(N1, N2, N3, N4))//' ' + SP = SP + L + ENDDO + ENDDO + ENDDO + ENDDO + ENDFUNCTION ENCODE_ASCII_DATAARRAY1_RANK4_I4P + + FUNCTION ENCODE_ASCII_DATAARRAY1_RANK4_I2P(X) RESULT(CODE) + !< ENCODE (BASE64) A DATAARRAY WITH 1 COMPONENTS OF RANK 4 (I2P). + INTEGER(I2P), INTENT(IN) :: X(1:,1:,1:,1:) !< DATA VARIABLE. + CHARACTER(LEN=:), ALLOCATABLE :: CODE !< ENCODED BASE64 DATAARRAY. + INTEGER(I4P) :: N1 !< COUNTER. + INTEGER(I4P) :: N2 !< COUNTER. + INTEGER(I4P) :: N3 !< COUNTER. + INTEGER(I4P) :: N4 !< COUNTER. + INTEGER(I4P) :: L !< LENGTH + INTEGER(I4P) :: SP !< STRING POINTER + INTEGER(I4P) :: SIZE_N1 !< DIMENSION 1 SIZE + INTEGER(I4P) :: SIZE_N2 !< DIMENSION 2 SIZE + INTEGER(I4P) :: SIZE_N3 !< DIMENSION 3 SIZE + INTEGER(I4P) :: SIZE_N4 !< DIMENSION 4 SIZE + + SIZE_N1 = SIZE(X, DIM=1) + SIZE_N2 = SIZE(X, DIM=2) + SIZE_N3 = SIZE(X, DIM=3) + SIZE_N3 = SIZE(X, DIM=4) + + L = DI2P + 1 + SP = 0 + CODE = REPEAT(' ',L*SIZE_N1*SIZE_N2*SIZE_N3*SIZE_N4) + DO N4=1, SIZE(X, DIM=4) + DO N3=1, SIZE(X, DIM=3) + DO N2=1, SIZE(X, DIM=2) + DO N1=1, SIZE(X, DIM=1) + CODE(SP+1:SP+L) = STR(N=X(N1, N2, N3, N4))//' ' + SP = SP + L + ENDDO + ENDDO + ENDDO + ENDDO + ENDFUNCTION ENCODE_ASCII_DATAARRAY1_RANK4_I2P + + FUNCTION ENCODE_ASCII_DATAARRAY1_RANK4_I1P(X) RESULT(CODE) + !< ENCODE (BASE64) A DATAARRAY WITH 1 COMPONENTS OF RANK 4 (I1P). + INTEGER(I1P), INTENT(IN) :: X(1:,1:,1:,1:) !< DATA VARIABLE. + CHARACTER(LEN=:), ALLOCATABLE :: CODE !< ENCODED BASE64 DATAARRAY. + INTEGER(I4P) :: N1 !< COUNTER. + INTEGER(I4P) :: N2 !< COUNTER. + INTEGER(I4P) :: N3 !< COUNTER. + INTEGER(I4P) :: N4 !< COUNTER. + INTEGER(I4P) :: L !< LENGTH + INTEGER(I4P) :: SP !< STRING POINTER + INTEGER(I4P) :: SIZE_N1 !< DIMENSION 1 SIZE + INTEGER(I4P) :: SIZE_N2 !< DIMENSION 2 SIZE + INTEGER(I4P) :: SIZE_N3 !< DIMENSION 3 SIZE + INTEGER(I4P) :: SIZE_N4 !< DIMENSION 4 SIZE + + SIZE_N1 = SIZE(X, DIM=1) + SIZE_N2 = SIZE(X, DIM=2) + SIZE_N3 = SIZE(X, DIM=3) + SIZE_N3 = SIZE(X, DIM=4) + + L = DI1P + 1 + SP = 0 + CODE = REPEAT(' ',L*SIZE_N1*SIZE_N2*SIZE_N3*SIZE_N4) + DO N4=1, SIZE(X, DIM=4) + DO N3=1, SIZE(X, DIM=3) + DO N2=1, SIZE(X, DIM=2) + DO N1=1, SIZE(X, DIM=1) + CODE(SP+1:SP+L) = STR(N=X(N1, N2, N3, N4))//' ' + SP = SP + L + ENDDO + ENDDO + ENDDO + ENDDO + ENDFUNCTION ENCODE_ASCII_DATAARRAY1_RANK4_I1P + + FUNCTION ENCODE_ASCII_DATAARRAY3_RANK1_R16P(X, Y, Z) RESULT(CODE) + !< ENCODE (BASE64) A DATAARRAY WITH 3 COMPONENTS OF RANK 1 (R16P). + REAL(R16P), INTENT(IN) :: X(1:) !< X COMPONENT. + REAL(R16P), INTENT(IN) :: Y(1:) !< Y COMPONENT. + REAL(R16P), INTENT(IN) :: Z(1:) !< Z COMPONENT. + CHARACTER(LEN=:), ALLOCATABLE :: CODE !< ENCODED BASE64 DATAARRAY. + INTEGER(I4P) :: N !< COUNTER. + INTEGER(I4P) :: L !< LENGTH + INTEGER(I4P) :: SP !< STRING POINTER + INTEGER(I4P) :: SIZE_N!< DIMENSION 1 SIZE + + SIZE_N = SIZE(X, DIM=1) + L = DR16P*3 + 2 + SP = 0 + CODE = REPEAT(' ',L*SIZE_N) + DO N=1, SIZE_N + CODE(SP+1:SP+L) = STR(N=X(N))//' '//STR(N=Y(N))//' '//STR(N=Z(N)) + SP = SP + L + ENDDO + ENDFUNCTION ENCODE_ASCII_DATAARRAY3_RANK1_R16P + + FUNCTION ENCODE_ASCII_DATAARRAY3_RANK1_R8P(X, Y, Z) RESULT(CODE) + !< ENCODE (BASE64) A DATAARRAY WITH 3 COMPONENTS OF RANK 1 (R8P). + REAL(R8P), INTENT(IN) :: X(1:) !< X COMPONENT. + REAL(R8P), INTENT(IN) :: Y(1:) !< Y COMPONENT. + REAL(R8P), INTENT(IN) :: Z(1:) !< Z COMPONENT. + CHARACTER(LEN=:), ALLOCATABLE :: CODE !< ENCODED BASE64 DATAARRAY. + INTEGER(I4P) :: N !< COUNTER. + INTEGER(I4P) :: L !< LENGTH + INTEGER(I4P) :: SP !< STRING POINTER + INTEGER(I4P) :: SIZE_N!< DIMENSION 1 SIZE + + SIZE_N = SIZE(X, DIM=1) + L = DR8P*3 + 2 + SP = 0 + CODE = REPEAT(' ',L*SIZE_N) + DO N=1, SIZE_N + CODE(SP+1:SP+L) = STR(N=X(N))//' '//STR(N=Y(N))//' '//STR(N=Z(N)) + SP = SP + L + ENDDO + ENDFUNCTION ENCODE_ASCII_DATAARRAY3_RANK1_R8P + + FUNCTION ENCODE_ASCII_DATAARRAY3_RANK1_R4P(X, Y, Z) RESULT(CODE) + !< ENCODE (BASE64) A DATAARRAY WITH 3 COMPONENTS OF RANK 1 (R4P). + REAL(R4P), INTENT(IN) :: X(1:) !< X COMPONENT. + REAL(R4P), INTENT(IN) :: Y(1:) !< Y COMPONENT. + REAL(R4P), INTENT(IN) :: Z(1:) !< Z COMPONENT. + CHARACTER(LEN=:), ALLOCATABLE :: CODE !< ENCODED BASE64 DATAARRAY. + INTEGER(I4P) :: N !< COUNTER. + INTEGER(I4P) :: L !< LENGTH + INTEGER(I4P) :: SP !< STRING POINTER + INTEGER(I4P) :: SIZE_N!< DIMENSION 1 SIZE + + SIZE_N = SIZE(X, DIM=1) + L = DR4P*3 + 2 + SP = 0 + CODE = REPEAT(' ',L*SIZE_N) + DO N=1, SIZE_N + CODE(SP+1:SP+L) = STR(N=X(N))//' '//STR(N=Y(N))//' '//STR(N=Z(N)) + SP = SP + L + ENDDO + ENDFUNCTION ENCODE_ASCII_DATAARRAY3_RANK1_R4P + + FUNCTION ENCODE_ASCII_DATAARRAY3_RANK1_I8P(X, Y, Z) RESULT(CODE) + !< ENCODE (BASE64) A DATAARRAY WITH 3 COMPONENTS OF RANK 1 (I8P). + INTEGER(I8P), INTENT(IN) :: X(1:) !< X COMPONENT. + INTEGER(I8P), INTENT(IN) :: Y(1:) !< Y COMPONENT. + INTEGER(I8P), INTENT(IN) :: Z(1:) !< Z COMPONENT. + CHARACTER(LEN=:), ALLOCATABLE :: CODE !< ENCODED BASE64 DATAARRAY. + INTEGER(I4P) :: N !< COUNTER. + INTEGER(I4P) :: L !< LENGTH + INTEGER(I4P) :: SP !< STRING POINTER + INTEGER(I4P) :: SIZE_N!< DIMENSION 1 SIZE + + SIZE_N = SIZE(X, DIM=1) + L = DI8P*3 + 2 + SP = 0 + CODE = REPEAT(' ',L*SIZE_N) + DO N=1, SIZE_N + CODE(SP+1:SP+L) = STR(N=X(N))//' '//STR(N=Y(N))//' '//STR(N=Z(N)) + SP = SP + L + ENDDO + ENDFUNCTION ENCODE_ASCII_DATAARRAY3_RANK1_I8P + + FUNCTION ENCODE_ASCII_DATAARRAY3_RANK1_I4P(X, Y, Z) RESULT(CODE) + !< ENCODE (BASE64) A DATAARRAY WITH 3 COMPONENTS OF RANK 1 (I4P). + INTEGER(I4P), INTENT(IN) :: X(1:) !< X COMPONENT. + INTEGER(I4P), INTENT(IN) :: Y(1:) !< Y COMPONENT. + INTEGER(I4P), INTENT(IN) :: Z(1:) !< Z COMPONENT. + CHARACTER(LEN=:), ALLOCATABLE :: CODE !< ENCODED BASE64 DATAARRAY. + INTEGER(I4P) :: N !< COUNTER. + INTEGER(I4P) :: L !< LENGTH + INTEGER(I4P) :: SP !< STRING POINTER + INTEGER(I4P) :: SIZE_N!< DIMENSION 1 SIZE + + SIZE_N = SIZE(X, DIM=1) + L = DI4P*3 + 2 + SP = 0 + CODE = REPEAT(' ',L*SIZE_N) + DO N=1, SIZE_N + CODE(SP+1:SP+L) = STR(N=X(N))//' '//STR(N=Y(N))//' '//STR(N=Z(N)) + SP = SP + L + ENDDO + ENDFUNCTION ENCODE_ASCII_DATAARRAY3_RANK1_I4P + + FUNCTION ENCODE_ASCII_DATAARRAY3_RANK1_I2P(X, Y, Z) RESULT(CODE) + !< ENCODE (BASE64) A DATAARRAY WITH 3 COMPONENTS OF RANK 1 (I2P). + INTEGER(I2P), INTENT(IN) :: X(1:) !< X COMPONENT. + INTEGER(I2P), INTENT(IN) :: Y(1:) !< Y COMPONENT. + INTEGER(I2P), INTENT(IN) :: Z(1:) !< Z COMPONENT. + CHARACTER(LEN=:), ALLOCATABLE :: CODE !< ENCODED BASE64 DATAARRAY. + INTEGER(I4P) :: N !< COUNTER. + INTEGER(I4P) :: L !< LENGTH + INTEGER(I4P) :: SP !< STRING POINTER + INTEGER(I4P) :: SIZE_N!< DIMENSION 1 SIZE + + SIZE_N = SIZE(X, DIM=1) + L = DI2P*3 + 2 + SP = 0 + CODE = REPEAT(' ',L*SIZE_N) + DO N=1, SIZE_N + CODE(SP+1:SP+L) = STR(N=X(N))//' '//STR(N=Y(N))//' '//STR(N=Z(N)) + SP = SP + L + ENDDO + ENDFUNCTION ENCODE_ASCII_DATAARRAY3_RANK1_I2P + + FUNCTION ENCODE_ASCII_DATAARRAY3_RANK1_I1P(X, Y, Z) RESULT(CODE) + !< ENCODE (BASE64) A DATAARRAY WITH 3 COMPONENTS OF RANK 1 (I1P). + INTEGER(I1P), INTENT(IN) :: X(1:) !< X COMPONENT. + INTEGER(I1P), INTENT(IN) :: Y(1:) !< Y COMPONENT. + INTEGER(I1P), INTENT(IN) :: Z(1:) !< Z COMPONENT. + CHARACTER(LEN=:), ALLOCATABLE :: CODE !< ENCODED BASE64 DATAARRAY. + INTEGER(I4P) :: N !< COUNTER. + INTEGER(I4P) :: L !< LENGTH + INTEGER(I4P) :: SP !< STRING POINTER + INTEGER(I4P) :: SIZE_N!< DIMENSION 1 SIZE + + SIZE_N = SIZE(X, DIM=1) + L = DI1P*3 + 2 + SP = 0 + CODE = REPEAT(' ',L*SIZE_N) + DO N=1, SIZE_N + CODE(SP+1:SP+L) = STR(N=X(N))//' '//STR(N=Y(N))//' '//STR(N=Z(N)) + SP = SP + L + ENDDO + ENDFUNCTION ENCODE_ASCII_DATAARRAY3_RANK1_I1P + + FUNCTION ENCODE_ASCII_DATAARRAY3_RANK3_R16P(X, Y, Z) RESULT(CODE) + !< ENCODE (BASE64) A DATAARRAY WITH 3 COMPONENTS OF RANK 3 (R8P). + REAL(R16P), INTENT(IN) :: X(1:,1:,1:) !< X COMPONENT. + REAL(R16P), INTENT(IN) :: Y(1:,1:,1:) !< Y COMPONENT. + REAL(R16P), INTENT(IN) :: Z(1:,1:,1:) !< Z COMPONENT. + CHARACTER(LEN=:), ALLOCATABLE :: CODE !< ENCODED BASE64 DATAARRAY. + INTEGER(I4P) :: N1 !< COUNTER. + INTEGER(I4P) :: N2 !< COUNTER. + INTEGER(I4P) :: N3 !< COUNTER. + INTEGER(I4P) :: L !< LENGTH + INTEGER(I4P) :: SP !< STRING POINTER + INTEGER(I4P) :: SIZE_N1 !< DIMENSION 1 SIZE + INTEGER(I4P) :: SIZE_N2 !< DIMENSION 2 SIZE + INTEGER(I4P) :: SIZE_N3 !< DIMENSION 3 SIZE + + SIZE_N1 = SIZE(X, DIM=1) + SIZE_N2 = SIZE(X, DIM=2) + SIZE_N3 = SIZE(X, DIM=3) + + L = DR16P*3 + 2 + SP = 0 + CODE = REPEAT(' ',L*SIZE_N1*SIZE_N2*SIZE_N3) + DO N3=1, SIZE(X, DIM=3) + DO N2=1, SIZE(X, DIM=2) + DO N1=1, SIZE(X, DIM=1) + CODE(SP+1:SP+L) = STR(N=X(N1, N2, N3))//' '//STR(N=Y(N1, N2, N3))//' '//STR(N=Z(N1, N2, N3)) + SP = SP + L + ENDDO + ENDDO + ENDDO + ENDFUNCTION ENCODE_ASCII_DATAARRAY3_RANK3_R16P + + FUNCTION ENCODE_ASCII_DATAARRAY3_RANK3_R8P(X, Y, Z) RESULT(CODE) + !< ENCODE (BASE64) A DATAARRAY WITH 3 COMPONENTS OF RANK 3 (R8P). + REAL(R8P), INTENT(IN) :: X(1:,1:,1:) !< X COMPONENT. + REAL(R8P), INTENT(IN) :: Y(1:,1:,1:) !< Y COMPONENT. + REAL(R8P), INTENT(IN) :: Z(1:,1:,1:) !< Z COMPONENT. + CHARACTER(LEN=:), ALLOCATABLE :: CODE !< ENCODED BASE64 DATAARRAY. + INTEGER(I4P) :: N1 !< COUNTER. + INTEGER(I4P) :: N2 !< COUNTER. + INTEGER(I4P) :: N3 !< COUNTER. + INTEGER(I4P) :: L !< LENGTH + INTEGER(I4P) :: SP !< STRING POINTER + INTEGER(I4P) :: SIZE_N1 !< DIMENSION 1 SIZE + INTEGER(I4P) :: SIZE_N2 !< DIMENSION 2 SIZE + INTEGER(I4P) :: SIZE_N3 !< DIMENSION 3 SIZE + + SIZE_N1 = SIZE(X, DIM=1) + SIZE_N2 = SIZE(X, DIM=2) + SIZE_N3 = SIZE(X, DIM=3) + + L = DR8P*3 + 2 + SP = 0 + CODE = REPEAT(' ',L*SIZE_N1*SIZE_N2*SIZE_N3) + DO N3=1, SIZE(X, DIM=3) + DO N2=1, SIZE(X, DIM=2) + DO N1=1, SIZE(X, DIM=1) + CODE(SP+1:SP+L) = STR(N=X(N1, N2, N3))//' '//STR(N=Y(N1, N2, N3))//' '//STR(N=Z(N1, N2, N3)) + SP = SP + L + ENDDO + ENDDO + ENDDO + ENDFUNCTION ENCODE_ASCII_DATAARRAY3_RANK3_R8P + + FUNCTION ENCODE_ASCII_DATAARRAY3_RANK3_R4P(X, Y, Z) RESULT(CODE) + !< ENCODE (BASE64) A DATAARRAY WITH 3 COMPONENTS OF RANK 3 (R4P). + REAL(R4P), INTENT(IN) :: X(1:,1:,1:) !< X COMPONENT. + REAL(R4P), INTENT(IN) :: Y(1:,1:,1:) !< Y COMPONENT. + REAL(R4P), INTENT(IN) :: Z(1:,1:,1:) !< Z COMPONENT. + CHARACTER(LEN=:), ALLOCATABLE :: CODE !< ENCODED BASE64 DATAARRAY. + INTEGER(I4P) :: N1 !< COUNTER. + INTEGER(I4P) :: N2 !< COUNTER. + INTEGER(I4P) :: N3 !< COUNTER. + INTEGER(I4P) :: L !< LENGTH + INTEGER(I4P) :: SP !< STRING POINTER + INTEGER(I4P) :: SIZE_N1 !< DIMENSION 1 SIZE + INTEGER(I4P) :: SIZE_N2 !< DIMENSION 2 SIZE + INTEGER(I4P) :: SIZE_N3 !< DIMENSION 3 SIZE + + SIZE_N1 = SIZE(X, DIM=1) + SIZE_N2 = SIZE(X, DIM=2) + SIZE_N3 = SIZE(X, DIM=3) + + L = DR4P*3 + 2 + SP = 0 + CODE = REPEAT(' ',L*SIZE_N1*SIZE_N2*SIZE_N3) + DO N3=1, SIZE(X, DIM=3) + DO N2=1, SIZE(X, DIM=2) + DO N1=1, SIZE(X, DIM=1) + CODE(SP+1:SP+L) = STR(N=X(N1, N2, N3))//' '//STR(N=Y(N1, N2, N3))//' '//STR(N=Z(N1, N2, N3)) + SP = SP + L + ENDDO + ENDDO + ENDDO + ENDFUNCTION ENCODE_ASCII_DATAARRAY3_RANK3_R4P + + FUNCTION ENCODE_ASCII_DATAARRAY3_RANK3_I8P(X, Y, Z) RESULT(CODE) + !< ENCODE (BASE64) A DATAARRAY WITH 3 COMPONENTS OF RANK 3 (I8P). + INTEGER(I8P), INTENT(IN) :: X(1:,1:,1:) !< X COMPONENT. + INTEGER(I8P), INTENT(IN) :: Y(1:,1:,1:) !< Y COMPONENT. + INTEGER(I8P), INTENT(IN) :: Z(1:,1:,1:) !< Z COMPONENT. + CHARACTER(LEN=:), ALLOCATABLE :: CODE !< ENCODED BASE64 DATAARRAY. + INTEGER(I4P) :: N1 !< COUNTER. + INTEGER(I4P) :: N2 !< COUNTER. + INTEGER(I4P) :: N3 !< COUNTER. + INTEGER(I4P) :: L !< LENGTH + INTEGER(I4P) :: SP !< STRING POINTER + INTEGER(I4P) :: SIZE_N1 !< DIMENSION 1 SIZE + INTEGER(I4P) :: SIZE_N2 !< DIMENSION 2 SIZE + INTEGER(I4P) :: SIZE_N3 !< DIMENSION 3 SIZE + + SIZE_N1 = SIZE(X, DIM=1) + SIZE_N2 = SIZE(X, DIM=2) + SIZE_N3 = SIZE(X, DIM=3) + + L = DI8P*3 + 2 + SP = 0 + CODE = REPEAT(' ',L*SIZE_N1*SIZE_N2*SIZE_N3) + DO N3=1, SIZE(X, DIM=3) + DO N2=1, SIZE(X, DIM=2) + DO N1=1, SIZE(X, DIM=1) + CODE(SP+1:SP+L) = STR(N=X(N1, N2, N3))//' '//STR(N=Y(N1, N2, N3))//' '//STR(N=Z(N1, N2, N3)) + SP = SP + L + ENDDO + ENDDO + ENDDO + ENDFUNCTION ENCODE_ASCII_DATAARRAY3_RANK3_I8P + + FUNCTION ENCODE_ASCII_DATAARRAY3_RANK3_I4P(X, Y, Z) RESULT(CODE) + !< ENCODE (BASE64) A DATAARRAY WITH 3 COMPONENTS OF RANK 3 (I4P). + INTEGER(I4P), INTENT(IN) :: X(1:,1:,1:) !< X COMPONENT. + INTEGER(I4P), INTENT(IN) :: Y(1:,1:,1:) !< Y COMPONENT. + INTEGER(I4P), INTENT(IN) :: Z(1:,1:,1:) !< Z COMPONENT. + CHARACTER(LEN=:), ALLOCATABLE :: CODE !< ENCODED BASE64 DATAARRAY. + INTEGER(I4P) :: N1 !< COUNTER. + INTEGER(I4P) :: N2 !< COUNTER. + INTEGER(I4P) :: N3 !< COUNTER. + INTEGER(I4P) :: L !< LENGTH + INTEGER(I4P) :: SP !< STRING POINTER + INTEGER(I4P) :: SIZE_N1 !< DIMENSION 1 SIZE + INTEGER(I4P) :: SIZE_N2 !< DIMENSION 2 SIZE + INTEGER(I4P) :: SIZE_N3 !< DIMENSION 3 SIZE + + SIZE_N1 = SIZE(X, DIM=1) + SIZE_N2 = SIZE(X, DIM=2) + SIZE_N3 = SIZE(X, DIM=3) + + L = DI4P*3 + 2 + SP = 0 + CODE = REPEAT(' ',L*SIZE_N1*SIZE_N2*SIZE_N3) + DO N3=1, SIZE(X, DIM=3) + DO N2=1, SIZE(X, DIM=2) + DO N1=1, SIZE(X, DIM=1) + CODE(SP+1:SP+L) = STR(N=X(N1, N2, N3))//' '//STR(N=Y(N1, N2, N3))//' '//STR(N=Z(N1, N2, N3)) + SP = SP + L + ENDDO + ENDDO + ENDDO + ENDFUNCTION ENCODE_ASCII_DATAARRAY3_RANK3_I4P + + FUNCTION ENCODE_ASCII_DATAARRAY3_RANK3_I2P(X, Y, Z) RESULT(CODE) + !< ENCODE (BASE64) A DATAARRAY WITH 3 COMPONENTS OF RANK 3 (I2P). + INTEGER(I2P), INTENT(IN) :: X(1:,1:,1:) !< X COMPONENT. + INTEGER(I2P), INTENT(IN) :: Y(1:,1:,1:) !< Y COMPONENT. + INTEGER(I2P), INTENT(IN) :: Z(1:,1:,1:) !< Z COMPONENT. + CHARACTER(LEN=:), ALLOCATABLE :: CODE !< ENCODED BASE64 DATAARRAY. + INTEGER(I4P) :: N1 !< COUNTER. + INTEGER(I4P) :: N2 !< COUNTER. + INTEGER(I4P) :: N3 !< COUNTER. + INTEGER(I4P) :: L !< LENGTH + INTEGER(I4P) :: SP !< STRING POINTER + INTEGER(I4P) :: SIZE_N1 !< DIMENSION 1 SIZE + INTEGER(I4P) :: SIZE_N2 !< DIMENSION 2 SIZE + INTEGER(I4P) :: SIZE_N3 !< DIMENSION 3 SIZE + + SIZE_N1 = SIZE(X, DIM=1) + SIZE_N2 = SIZE(X, DIM=2) + SIZE_N3 = SIZE(X, DIM=3) + + L = DI2P*3 + 2 + SP = 0 + CODE = REPEAT(' ',L*SIZE_N1*SIZE_N2*SIZE_N3) + DO N3=1, SIZE(X, DIM=3) + DO N2=1, SIZE(X, DIM=2) + DO N1=1, SIZE(X, DIM=1) + CODE(SP+1:SP+L) = STR(N=X(N1, N2, N3))//' '//STR(N=Y(N1, N2, N3))//' '//STR(N=Z(N1, N2, N3)) + SP = SP + L + ENDDO + ENDDO + ENDDO + ENDFUNCTION ENCODE_ASCII_DATAARRAY3_RANK3_I2P + + FUNCTION ENCODE_ASCII_DATAARRAY3_RANK3_I1P(X, Y, Z) RESULT(CODE) + !< ENCODE (BASE64) A DATAARRAY WITH 3 COMPONENTS OF RANK 3 (I1P). + INTEGER(I1P), INTENT(IN) :: X(1:,1:,1:) !< X COMPONENT. + INTEGER(I1P), INTENT(IN) :: Y(1:,1:,1:) !< Y COMPONENT. + INTEGER(I1P), INTENT(IN) :: Z(1:,1:,1:) !< Z COMPONENT. + CHARACTER(LEN=:), ALLOCATABLE :: CODE !< ENCODED BASE64 DATAARRAY. + INTEGER(I4P) :: N1 !< COUNTER. + INTEGER(I4P) :: N2 !< COUNTER. + INTEGER(I4P) :: N3 !< COUNTER. + INTEGER(I4P) :: L !< LENGTH + INTEGER(I4P) :: SP !< STRING POINTER + INTEGER(I4P) :: SIZE_N1 !< DIMENSION 1 SIZE + INTEGER(I4P) :: SIZE_N2 !< DIMENSION 2 SIZE + INTEGER(I4P) :: SIZE_N3 !< DIMENSION 3 SIZE + + SIZE_N1 = SIZE(X, DIM=1) + SIZE_N2 = SIZE(X, DIM=2) + SIZE_N3 = SIZE(X, DIM=3) + + L = DI1P*3 + 2 + SP = 0 + CODE = REPEAT(' ',L*SIZE_N1*SIZE_N2*SIZE_N3) + DO N3=1, SIZE(X, DIM=3) + DO N2=1, SIZE(X, DIM=2) + DO N1=1, SIZE(X, DIM=1) + CODE(SP+1:SP+L) = STR(N=X(N1, N2, N3))//' '//STR(N=Y(N1, N2, N3))//' '//STR(N=Z(N1, N2, N3)) + SP = SP + L + ENDDO + ENDDO + ENDDO + ENDFUNCTION ENCODE_ASCII_DATAARRAY3_RANK3_I1P + + FUNCTION ENCODE_ASCII_DATAARRAY6_RANK1_R16P(U, V, W, X, Y, Z) RESULT(CODE) + !< ENCODE (BASE64) A DATAARRAY WITH 6 COMPONENTS OF RANK 1 (R16P). + REAL(R16P), INTENT(IN) :: U(1:) !< U COMPONENT. + REAL(R16P), INTENT(IN) :: V(1:) !< V COMPONENT. + REAL(R16P), INTENT(IN) :: W(1:) !< W COMPONENT. + REAL(R16P), INTENT(IN) :: X(1:) !< X COMPONENT. + REAL(R16P), INTENT(IN) :: Y(1:) !< Y COMPONENT. + REAL(R16P), INTENT(IN) :: Z(1:) !< Z COMPONENT. + CHARACTER(LEN=:), ALLOCATABLE :: CODE !< ENCODED BASE64 DATAARRAY. + INTEGER(I4P) :: N !< COUNTER. + INTEGER(I4P) :: L !< LENGTH + INTEGER(I4P) :: SP !< STRING POINTER + INTEGER(I4P) :: SIZE_N!< DIMENSION 1 SIZE + + SIZE_N = SIZE(X, DIM=1) + L = DR16P*6 + 5 + SP = 0 + CODE = REPEAT(' ',L*SIZE_N) + DO N=1, SIZE_N + CODE(SP+1:SP+L) = STR(N=U(N))//' '//STR(N=V(N))//' '//STR(N=W(N))// & + STR(N=X(N))//' '//STR(N=Y(N))//' '//STR(N=Z(N)) + SP = SP + L + ENDDO + ENDFUNCTION ENCODE_ASCII_DATAARRAY6_RANK1_R16P + + FUNCTION ENCODE_ASCII_DATAARRAY6_RANK1_R8P(U, V, W, X, Y, Z) RESULT(CODE) + !< ENCODE (BASE64) A DATAARRAY WITH 6 COMPONENTS OF RANK 1 (R8P). + REAL(R8P), INTENT(IN) :: U(1:) !< U COMPONENT. + REAL(R8P), INTENT(IN) :: V(1:) !< V COMPONENT. + REAL(R8P), INTENT(IN) :: W(1:) !< W COMPONENT. + REAL(R8P), INTENT(IN) :: X(1:) !< X COMPONENT. + REAL(R8P), INTENT(IN) :: Y(1:) !< Y COMPONENT. + REAL(R8P), INTENT(IN) :: Z(1:) !< Z COMPONENT. + CHARACTER(LEN=:), ALLOCATABLE :: CODE !< ENCODED BASE64 DATAARRAY. + INTEGER(I4P) :: N !< COUNTER. + INTEGER(I4P) :: L !< LENGTH + INTEGER(I4P) :: SP !< STRING POINTER + INTEGER(I4P) :: SIZE_N!< DIMENSION 1 SIZE + + SIZE_N = SIZE(X, DIM=1) + L = DR8P*6 + 5 + SP = 0 + CODE = REPEAT(' ',L*SIZE_N) + DO N=1, SIZE_N + CODE(SP+1:SP+L) = STR(N=U(N))//' '//STR(N=V(N))//' '//STR(N=W(N))// & + STR(N=X(N))//' '//STR(N=Y(N))//' '//STR(N=Z(N)) + SP = SP + L + ENDDO + ENDFUNCTION ENCODE_ASCII_DATAARRAY6_RANK1_R8P + + FUNCTION ENCODE_ASCII_DATAARRAY6_RANK1_R4P(U, V, W, X, Y, Z) RESULT(CODE) + !< ENCODE (BASE64) A DATAARRAY WITH 6 COMPONENTS OF RANK 1 (R4P). + REAL(R4P), INTENT(IN) :: U(1:) !< U COMPONENT. + REAL(R4P), INTENT(IN) :: V(1:) !< V COMPONENT. + REAL(R4P), INTENT(IN) :: W(1:) !< W COMPONENT. + REAL(R4P), INTENT(IN) :: X(1:) !< X COMPONENT. + REAL(R4P), INTENT(IN) :: Y(1:) !< Y COMPONENT. + REAL(R4P), INTENT(IN) :: Z(1:) !< Z COMPONENT. + CHARACTER(LEN=:), ALLOCATABLE :: CODE !< ENCODED BASE64 DATAARRAY. + INTEGER(I4P) :: N !< COUNTER. + INTEGER(I4P) :: L !< LENGTH + INTEGER(I4P) :: SP !< STRING POINTER + INTEGER(I4P) :: SIZE_N!< DIMENSION 1 SIZE + + SIZE_N = SIZE(X, DIM=1) + L = DR4P*6 + 5 + SP = 0 + CODE = REPEAT(' ',L*SIZE_N) + DO N=1, SIZE_N + CODE(SP+1:SP+L) = STR(N=U(N))//' '//STR(N=V(N))//' '//STR(N=W(N))// & + STR(N=X(N))//' '//STR(N=Y(N))//' '//STR(N=Z(N)) + SP = SP + L + ENDDO + ENDFUNCTION ENCODE_ASCII_DATAARRAY6_RANK1_R4P + + FUNCTION ENCODE_ASCII_DATAARRAY6_RANK1_I8P(U, V, W, X, Y, Z) RESULT(CODE) + !< ENCODE (BASE64) A DATAARRAY WITH 6 COMPONENTS OF RANK 1 (I8P). + INTEGER(I8P), INTENT(IN) :: U(1:) !< U COMPONENT. + INTEGER(I8P), INTENT(IN) :: V(1:) !< V COMPONENT. + INTEGER(I8P), INTENT(IN) :: W(1:) !< W COMPONENT. + INTEGER(I8P), INTENT(IN) :: X(1:) !< X COMPONENT. + INTEGER(I8P), INTENT(IN) :: Y(1:) !< Y COMPONENT. + INTEGER(I8P), INTENT(IN) :: Z(1:) !< Z COMPONENT. + CHARACTER(LEN=:), ALLOCATABLE :: CODE !< ENCODED BASE64 DATAARRAY. + INTEGER(I4P) :: N !< COUNTER. + INTEGER(I4P) :: L !< LENGTH + INTEGER(I4P) :: SP !< STRING POINTER + INTEGER(I4P) :: SIZE_N!< DIMENSION 1 SIZE + + SIZE_N = SIZE(X, DIM=1) + L = DI8P*6 + 5 + SP = 0 + CODE = REPEAT(' ',L*SIZE_N) + DO N=1, SIZE_N + CODE(SP+1:SP+L) = STR(N=U(N))//' '//STR(N=V(N))//' '//STR(N=W(N))// & + STR(N=X(N))//' '//STR(N=Y(N))//' '//STR(N=Z(N)) + SP = SP + L + ENDDO + ENDFUNCTION ENCODE_ASCII_DATAARRAY6_RANK1_I8P + + FUNCTION ENCODE_ASCII_DATAARRAY6_RANK1_I4P(U, V, W, X, Y, Z) RESULT(CODE) + !< ENCODE (BASE64) A DATAARRAY WITH 6 COMPONENTS OF RANK 1 (I4P). + INTEGER(I4P), INTENT(IN) :: U(1:) !< U COMPONENT. + INTEGER(I4P), INTENT(IN) :: V(1:) !< V COMPONENT. + INTEGER(I4P), INTENT(IN) :: W(1:) !< W COMPONENT. + INTEGER(I4P), INTENT(IN) :: X(1:) !< X COMPONENT. + INTEGER(I4P), INTENT(IN) :: Y(1:) !< Y COMPONENT. + INTEGER(I4P), INTENT(IN) :: Z(1:) !< Z COMPONENT. + CHARACTER(LEN=:), ALLOCATABLE :: CODE !< ENCODED BASE64 DATAARRAY. + INTEGER(I4P) :: N !< COUNTER. + INTEGER(I4P) :: L !< LENGTH + INTEGER(I4P) :: SP !< STRING POINTER + INTEGER(I4P) :: SIZE_N!< DIMENSION 1 SIZE + + SIZE_N = SIZE(X, DIM=1) + L = DI4P*6 + 5 + SP = 0 + CODE = REPEAT(' ',L*SIZE_N) + DO N=1, SIZE_N + CODE(SP+1:SP+L) = STR(N=U(N))//' '//STR(N=V(N))//' '//STR(N=W(N))// & + STR(N=X(N))//' '//STR(N=Y(N))//' '//STR(N=Z(N)) + SP = SP + L + ENDDO + ENDFUNCTION ENCODE_ASCII_DATAARRAY6_RANK1_I4P + + FUNCTION ENCODE_ASCII_DATAARRAY6_RANK1_I2P(U, V, W, X, Y, Z) RESULT(CODE) + !< ENCODE (BASE64) A DATAARRAY WITH 6 COMPONENTS OF RANK 1 (I2P). + INTEGER(I2P), INTENT(IN) :: U(1:) !< U COMPONENT. + INTEGER(I2P), INTENT(IN) :: V(1:) !< V COMPONENT. + INTEGER(I2P), INTENT(IN) :: W(1:) !< W COMPONENT. + INTEGER(I2P), INTENT(IN) :: X(1:) !< X COMPONENT. + INTEGER(I2P), INTENT(IN) :: Y(1:) !< Y COMPONENT. + INTEGER(I2P), INTENT(IN) :: Z(1:) !< Z COMPONENT. + CHARACTER(LEN=:), ALLOCATABLE :: CODE !< ENCODED BASE64 DATAARRAY. + INTEGER(I4P) :: N !< COUNTER. + INTEGER(I4P) :: L !< LENGTH + INTEGER(I4P) :: SP !< STRING POINTER + INTEGER(I4P) :: SIZE_N!< DIMENSION 1 SIZE + + SIZE_N = SIZE(X, DIM=1) + L = DI2P*6 + 5 + SP = 0 + CODE = REPEAT(' ',L*SIZE_N) + DO N=1, SIZE_N + CODE(SP+1:SP+L) = STR(N=U(N))//' '//STR(N=V(N))//' '//STR(N=W(N))// & + STR(N=X(N))//' '//STR(N=Y(N))//' '//STR(N=Z(N)) + SP = SP + L + ENDDO + ENDFUNCTION ENCODE_ASCII_DATAARRAY6_RANK1_I2P + + FUNCTION ENCODE_ASCII_DATAARRAY6_RANK1_I1P(U, V, W, X, Y, Z) RESULT(CODE) + !< ENCODE (BASE64) A DATAARRAY WITH 6 COMPONENTS OF RANK 1 (I1P). + INTEGER(I1P), INTENT(IN) :: U(1:) !< U COMPONENT. + INTEGER(I1P), INTENT(IN) :: V(1:) !< V COMPONENT. + INTEGER(I1P), INTENT(IN) :: W(1:) !< W COMPONENT. + INTEGER(I1P), INTENT(IN) :: X(1:) !< X COMPONENT. + INTEGER(I1P), INTENT(IN) :: Y(1:) !< Y COMPONENT. + INTEGER(I1P), INTENT(IN) :: Z(1:) !< Z COMPONENT. + CHARACTER(LEN=:), ALLOCATABLE :: CODE !< ENCODED BASE64 DATAARRAY. + INTEGER(I4P) :: N !< COUNTER. + INTEGER(I4P) :: L !< LENGTH + INTEGER(I4P) :: SP !< STRING POINTER + INTEGER(I4P) :: SIZE_N!< DIMENSION 1 SIZE + + SIZE_N = SIZE(X, DIM=1) + L = DI1P*6 + 5 + SP = 0 + CODE = REPEAT(' ',L*SIZE_N) + DO N=1, SIZE_N + CODE(SP+1:SP+L) = STR(N=U(N))//' '//STR(N=V(N))//' '//STR(N=W(N))// & + STR(N=X(N))//' '//STR(N=Y(N))//' '//STR(N=Z(N)) + SP = SP + L + ENDDO + ENDFUNCTION ENCODE_ASCII_DATAARRAY6_RANK1_I1P + + FUNCTION ENCODE_ASCII_DATAARRAY6_RANK3_R16P(U, V, W, X, Y, Z) RESULT(CODE) + !< ENCODE (BASE64) A DATAARRAY WITH 6 COMPONENTS OF RANK 3 (R8P). + REAL(R16P), INTENT(IN) :: U(1:,1:,1:) !< U COMPONENT. + REAL(R16P), INTENT(IN) :: V(1:,1:,1:) !< V COMPONENT. + REAL(R16P), INTENT(IN) :: W(1:,1:,1:) !< W COMPONENT. + REAL(R16P), INTENT(IN) :: X(1:,1:,1:) !< X COMPONENT. + REAL(R16P), INTENT(IN) :: Y(1:,1:,1:) !< Y COMPONENT. + REAL(R16P), INTENT(IN) :: Z(1:,1:,1:) !< Z COMPONENT. + CHARACTER(LEN=:), ALLOCATABLE :: CODE !< ENCODED BASE64 DATAARRAY. + INTEGER(I4P) :: N1 !< COUNTER. + INTEGER(I4P) :: N2 !< COUNTER. + INTEGER(I4P) :: N3 !< COUNTER. + INTEGER(I4P) :: L !< LENGTH + INTEGER(I4P) :: SP !< STRING POINTER + INTEGER(I4P) :: SIZE_N1 !< DIMENSION 1 SIZE + INTEGER(I4P) :: SIZE_N2 !< DIMENSION 2 SIZE + INTEGER(I4P) :: SIZE_N3 !< DIMENSION 3 SIZE + + SIZE_N1 = SIZE(X, DIM=1) + SIZE_N2 = SIZE(X, DIM=2) + SIZE_N3 = SIZE(X, DIM=3) + + L = DR16P*6 + 5 + SP = 0 + CODE = REPEAT(' ',L*SIZE_N1*SIZE_N2*SIZE_N3) + DO N3=1, SIZE_N3 + DO N2=1, SIZE_N2 + DO N1=1, SIZE_N1 + CODE(SP+1:SP+L) = STR(N=U(N1, N2, N3))//' '//STR(N=V(N1, N2, N3))//' '//STR(N=W(N1, N2, N3))// & + STR(N=X(N1, N2, N3))//' '//STR(N=Y(N1, N2, N3))//' '//STR(N=Z(N1, N2, N3)) + SP = SP + L + ENDDO + ENDDO + ENDDO + ENDFUNCTION ENCODE_ASCII_DATAARRAY6_RANK3_R16P + + FUNCTION ENCODE_ASCII_DATAARRAY6_RANK3_R8P(U, V, W, X, Y, Z) RESULT(CODE) + !< ENCODE (BASE64) A DATAARRAY WITH 6 COMPONENTS OF RANK 3 (R8P). + REAL(R8P), INTENT(IN) :: U(1:,1:,1:) !< U COMPONENT. + REAL(R8P), INTENT(IN) :: V(1:,1:,1:) !< V COMPONENT. + REAL(R8P), INTENT(IN) :: W(1:,1:,1:) !< W COMPONENT. + REAL(R8P), INTENT(IN) :: X(1:,1:,1:) !< X COMPONENT. + REAL(R8P), INTENT(IN) :: Y(1:,1:,1:) !< Y COMPONENT. + REAL(R8P), INTENT(IN) :: Z(1:,1:,1:) !< Z COMPONENT. + CHARACTER(LEN=:), ALLOCATABLE :: CODE !< ENCODED BASE64 DATAARRAY. + INTEGER(I4P) :: N1 !< COUNTER. + INTEGER(I4P) :: N2 !< COUNTER. + INTEGER(I4P) :: N3 !< COUNTER. + INTEGER(I4P) :: L !< LENGTH + INTEGER(I4P) :: SP !< STRING POINTER + INTEGER(I4P) :: SIZE_N1 !< DIMENSION 1 SIZE + INTEGER(I4P) :: SIZE_N2 !< DIMENSION 2 SIZE + INTEGER(I4P) :: SIZE_N3 !< DIMENSION 3 SIZE + + SIZE_N1 = SIZE(X, DIM=1) + SIZE_N2 = SIZE(X, DIM=2) + SIZE_N3 = SIZE(X, DIM=3) + + L = DR8P*6 + 5 + SP = 0 + CODE = REPEAT(' ',L*SIZE_N1*SIZE_N2*SIZE_N3) + DO N3=1, SIZE_N3 + DO N2=1, SIZE_N2 + DO N1=1, SIZE_N1 + CODE(SP+1:SP+L) = STR(N=U(N1, N2, N3))//' '//STR(N=V(N1, N2, N3))//' '//STR(N=W(N1, N2, N3))// & + STR(N=X(N1, N2, N3))//' '//STR(N=Y(N1, N2, N3))//' '//STR(N=Z(N1, N2, N3)) + SP = SP + L + ENDDO + ENDDO + ENDDO + ENDFUNCTION ENCODE_ASCII_DATAARRAY6_RANK3_R8P + + FUNCTION ENCODE_ASCII_DATAARRAY6_RANK3_R4P(U, V, W, X, Y, Z) RESULT(CODE) + !< ENCODE (BASE64) A DATAARRAY WITH 3 COMPONENTS OF RANK 3 (R4P). + REAL(R4P), INTENT(IN) :: U(1:,1:,1:) !< U COMPONENT. + REAL(R4P), INTENT(IN) :: V(1:,1:,1:) !< V COMPONENT. + REAL(R4P), INTENT(IN) :: W(1:,1:,1:) !< W COMPONENT. + REAL(R4P), INTENT(IN) :: X(1:,1:,1:) !< X COMPONENT. + REAL(R4P), INTENT(IN) :: Y(1:,1:,1:) !< Y COMPONENT. + REAL(R4P), INTENT(IN) :: Z(1:,1:,1:) !< Z COMPONENT. + CHARACTER(LEN=:), ALLOCATABLE :: CODE !< ENCODED BASE64 DATAARRAY. + INTEGER(I4P) :: N1 !< COUNTER. + INTEGER(I4P) :: N2 !< COUNTER. + INTEGER(I4P) :: N3 !< COUNTER. + INTEGER(I4P) :: L !< LENGTH + INTEGER(I4P) :: SP !< STRING POINTER + INTEGER(I4P) :: SIZE_N1 !< DIMENSION 1 SIZE + INTEGER(I4P) :: SIZE_N2 !< DIMENSION 2 SIZE + INTEGER(I4P) :: SIZE_N3 !< DIMENSION 3 SIZE + + SIZE_N1 = SIZE(X, DIM=1) + SIZE_N2 = SIZE(X, DIM=2) + SIZE_N3 = SIZE(X, DIM=3) + + L = DR4P*6 + 5 + SP = 0 + CODE = REPEAT(' ',L*SIZE_N1*SIZE_N2*SIZE_N3) + DO N3=1, SIZE_N3 + DO N2=1, SIZE_N2 + DO N1=1, SIZE_N1 + CODE(SP+1:SP+L) = STR(N=U(N1, N2, N3))//' '//STR(N=V(N1, N2, N3))//' '//STR(N=W(N1, N2, N3))// & + STR(N=X(N1, N2, N3))//' '//STR(N=Y(N1, N2, N3))//' '//STR(N=Z(N1, N2, N3)) + SP = SP + L + ENDDO + ENDDO + ENDDO + ENDFUNCTION ENCODE_ASCII_DATAARRAY6_RANK3_R4P + + FUNCTION ENCODE_ASCII_DATAARRAY6_RANK3_I8P(U, V, W, X, Y, Z) RESULT(CODE) + !< ENCODE (BASE64) A DATAARRAY WITH 6 COMPONENTS OF RANK 3 (I8P). + INTEGER(I8P), INTENT(IN) :: U(1:,1:,1:) !< U COMPONENT. + INTEGER(I8P), INTENT(IN) :: V(1:,1:,1:) !< V COMPONENT. + INTEGER(I8P), INTENT(IN) :: W(1:,1:,1:) !< W COMPONENT. + INTEGER(I8P), INTENT(IN) :: X(1:,1:,1:) !< X COMPONENT. + INTEGER(I8P), INTENT(IN) :: Y(1:,1:,1:) !< Y COMPONENT. + INTEGER(I8P), INTENT(IN) :: Z(1:,1:,1:) !< Z COMPONENT. + CHARACTER(LEN=:), ALLOCATABLE :: CODE !< ENCODED BASE64 DATAARRAY. + INTEGER(I4P) :: N1 !< COUNTER. + INTEGER(I4P) :: N2 !< COUNTER. + INTEGER(I4P) :: N3 !< COUNTER. + INTEGER(I4P) :: L !< LENGTH + INTEGER(I4P) :: SP !< STRING POINTER + INTEGER(I4P) :: SIZE_N1 !< DIMENSION 1 SIZE + INTEGER(I4P) :: SIZE_N2 !< DIMENSION 2 SIZE + INTEGER(I4P) :: SIZE_N3 !< DIMENSION 3 SIZE + + SIZE_N1 = SIZE(X, DIM=1) + SIZE_N2 = SIZE(X, DIM=2) + SIZE_N3 = SIZE(X, DIM=3) + + L = DI8P*6 + 5 + SP = 0 + CODE = REPEAT(' ',L*SIZE_N1*SIZE_N2*SIZE_N3) + DO N3=1, SIZE_N3 + DO N2=1, SIZE_N2 + DO N1=1, SIZE_N1 + CODE(SP+1:SP+L) = STR(N=U(N1, N2, N3))//' '//STR(N=V(N1, N2, N3))//' '//STR(N=W(N1, N2, N3))// & + STR(N=X(N1, N2, N3))//' '//STR(N=Y(N1, N2, N3))//' '//STR(N=Z(N1, N2, N3)) + SP = SP + L + ENDDO + ENDDO + ENDDO + ENDFUNCTION ENCODE_ASCII_DATAARRAY6_RANK3_I8P + + FUNCTION ENCODE_ASCII_DATAARRAY6_RANK3_I4P(U, V, W, X, Y, Z) RESULT(CODE) + !< ENCODE (BASE64) A DATAARRAY WITH 6 COMPONENTS OF RANK 3 (I4P). + INTEGER(I4P), INTENT(IN) :: U(1:,1:,1:) !< U COMPONENT. + INTEGER(I4P), INTENT(IN) :: V(1:,1:,1:) !< V COMPONENT. + INTEGER(I4P), INTENT(IN) :: W(1:,1:,1:) !< W COMPONENT. + INTEGER(I4P), INTENT(IN) :: X(1:,1:,1:) !< X COMPONENT. + INTEGER(I4P), INTENT(IN) :: Y(1:,1:,1:) !< Y COMPONENT. + INTEGER(I4P), INTENT(IN) :: Z(1:,1:,1:) !< Z COMPONENT. + CHARACTER(LEN=:), ALLOCATABLE :: CODE !< ENCODED BASE64 DATAARRAY. + INTEGER(I4P) :: N1 !< COUNTER. + INTEGER(I4P) :: N2 !< COUNTER. + INTEGER(I4P) :: N3 !< COUNTER. + INTEGER(I4P) :: L !< LENGTH + INTEGER(I4P) :: SP !< STRING POINTER + INTEGER(I4P) :: SIZE_N1 !< DIMENSION 1 SIZE + INTEGER(I4P) :: SIZE_N2 !< DIMENSION 2 SIZE + INTEGER(I4P) :: SIZE_N3 !< DIMENSION 3 SIZE + + SIZE_N1 = SIZE(X, DIM=1) + SIZE_N2 = SIZE(X, DIM=2) + SIZE_N3 = SIZE(X, DIM=3) + + L = DI4P*6 + 5 + SP = 0 + CODE = REPEAT(' ',L*SIZE_N1*SIZE_N2*SIZE_N3) + DO N3=1, SIZE_N3 + DO N2=1, SIZE_N2 + DO N1=1, SIZE_N1 + CODE(SP+1:SP+L) = STR(N=U(N1, N2, N3))//' '//STR(N=V(N1, N2, N3))//' '//STR(N=W(N1, N2, N3))// & + STR(N=X(N1, N2, N3))//' '//STR(N=Y(N1, N2, N3))//' '//STR(N=Z(N1, N2, N3)) + SP = SP + L + ENDDO + ENDDO + ENDDO + ENDFUNCTION ENCODE_ASCII_DATAARRAY6_RANK3_I4P + + FUNCTION ENCODE_ASCII_DATAARRAY6_RANK3_I2P(U, V, W, X, Y, Z) RESULT(CODE) + !< ENCODE (BASE64) A DATAARRAY WITH 6 COMPONENTS OF RANK 3 (I2P). + INTEGER(I2P), INTENT(IN) :: U(1:,1:,1:) !< U COMPONENT. + INTEGER(I2P), INTENT(IN) :: V(1:,1:,1:) !< V COMPONENT. + INTEGER(I2P), INTENT(IN) :: W(1:,1:,1:) !< W COMPONENT. + INTEGER(I2P), INTENT(IN) :: X(1:,1:,1:) !< X COMPONENT. + INTEGER(I2P), INTENT(IN) :: Y(1:,1:,1:) !< Y COMPONENT. + INTEGER(I2P), INTENT(IN) :: Z(1:,1:,1:) !< Z COMPONENT. + CHARACTER(LEN=:), ALLOCATABLE :: CODE !< ENCODED BASE64 DATAARRAY. + INTEGER(I4P) :: N1 !< COUNTER. + INTEGER(I4P) :: N2 !< COUNTER. + INTEGER(I4P) :: N3 !< COUNTER. + INTEGER(I4P) :: L !< LENGTH + INTEGER(I4P) :: SP !< STRING POINTER + INTEGER(I4P) :: SIZE_N1 !< DIMENSION 1 SIZE + INTEGER(I4P) :: SIZE_N2 !< DIMENSION 2 SIZE + INTEGER(I4P) :: SIZE_N3 !< DIMENSION 3 SIZE + + SIZE_N1 = SIZE(X, DIM=1) + SIZE_N2 = SIZE(X, DIM=2) + SIZE_N3 = SIZE(X, DIM=3) + + L = DI2P*6 + 5 + SP = 0 + CODE = REPEAT(' ',L*SIZE_N1*SIZE_N2*SIZE_N3) + DO N3=1, SIZE_N3 + DO N2=1, SIZE_N2 + DO N1=1, SIZE_N1 + CODE(SP+1:SP+L) = STR(N=U(N1, N2, N3))//' '//STR(N=V(N1, N2, N3))//' '//STR(N=W(N1, N2, N3))// & + STR(N=X(N1, N2, N3))//' '//STR(N=Y(N1, N2, N3))//' '//STR(N=Z(N1, N2, N3)) + SP = SP + L + ENDDO + ENDDO + ENDDO + ENDFUNCTION ENCODE_ASCII_DATAARRAY6_RANK3_I2P + + FUNCTION ENCODE_ASCII_DATAARRAY6_RANK3_I1P(U, V, W, X, Y, Z) RESULT(CODE) + !< ENCODE (BASE64) A DATAARRAY WITH 6 COMPONENTS OF RANK 3 (I1P). + INTEGER(I1P), INTENT(IN) :: U(1:,1:,1:) !< U COMPONENT. + INTEGER(I1P), INTENT(IN) :: V(1:,1:,1:) !< V COMPONENT. + INTEGER(I1P), INTENT(IN) :: W(1:,1:,1:) !< W COMPONENT. + INTEGER(I1P), INTENT(IN) :: X(1:,1:,1:) !< X COMPONENT. + INTEGER(I1P), INTENT(IN) :: Y(1:,1:,1:) !< Y COMPONENT. + INTEGER(I1P), INTENT(IN) :: Z(1:,1:,1:) !< Z COMPONENT. + CHARACTER(LEN=:), ALLOCATABLE :: CODE !< ENCODED BASE64 DATAARRAY. + INTEGER(I4P) :: N1 !< COUNTER. + INTEGER(I4P) :: N2 !< COUNTER. + INTEGER(I4P) :: N3 !< COUNTER. + INTEGER(I4P) :: L !< LENGTH + INTEGER(I4P) :: SP !< STRING POINTER + INTEGER(I4P) :: SIZE_N1 !< DIMENSION 1 SIZE + INTEGER(I4P) :: SIZE_N2 !< DIMENSION 2 SIZE + INTEGER(I4P) :: SIZE_N3 !< DIMENSION 3 SIZE + + SIZE_N1 = SIZE(X, DIM=1) + SIZE_N2 = SIZE(X, DIM=2) + SIZE_N3 = SIZE(X, DIM=3) + + L = DI1P*6 + 5 + SP = 0 + CODE = REPEAT(' ',L*SIZE_N1*SIZE_N2*SIZE_N3) + DO N3=1, SIZE_N3 + DO N2=1, SIZE_N2 + DO N1=1, SIZE_N1 + CODE(SP+1:SP+L) = STR(N=U(N1, N2, N3))//' '//STR(N=V(N1, N2, N3))//' '//STR(N=W(N1, N2, N3))// & + STR(N=X(N1, N2, N3))//' '//STR(N=Y(N1, N2, N3))//' '//STR(N=Z(N1, N2, N3)) + SP = SP + L + ENDDO + ENDDO + ENDDO + ENDFUNCTION ENCODE_ASCII_DATAARRAY6_RANK3_I1P + + !< BINARY ENCODER + FUNCTION ENCODE_BINARY_DATAARRAY1_RANK1_R8P(X) RESULT(CODE) + !< ENCODE (BASE64) A DATAARRAY WITH 1 COMPONENTS OF RANK 1 (R8P). + REAL(R8P), INTENT(IN) :: X(1:) !< DATA VARIABLE. + CHARACTER(LEN=:), ALLOCATABLE :: CODE !< ENCODED BASE64 DATAARRAY. + INTEGER(I1P), ALLOCATABLE :: XP(:) !< PACKED DATA. + INTEGER(I4P) :: NN !< NUMBER OF ELEMENTS. + + NN = SIZE(X, DIM=1) + CALL PACK_DATA(A1=[INT(NN*BYR8P, I4P)], A2=RESHAPE(X, [NN]), PACKED=XP) + CALL B64_ENCODE(N=XP, CODE=CODE) + ENDFUNCTION ENCODE_BINARY_DATAARRAY1_RANK1_R8P + + FUNCTION ENCODE_BINARY_DATAARRAY1_RANK1_R4P(X) RESULT(CODE) + !< ENCODE (BASE64) A DATAARRAY WITH 1 COMPONENTS OF RANK 1 (R4P). + REAL(R4P), INTENT(IN) :: X(1:) !< DATA VARIABLE. + CHARACTER(LEN=:), ALLOCATABLE :: CODE !< ENCODED BASE64 DATAARRAY. + INTEGER(I1P), ALLOCATABLE :: XP(:) !< PACKED DATA. + INTEGER(I4P) :: NN !< NUMBER OF ELEMENTS. + + NN = SIZE(X, DIM=1) + CALL PACK_DATA(A1=[INT(NN*BYR4P, I4P)], A2=RESHAPE(X, [NN]), PACKED=XP) + CALL B64_ENCODE(N=XP, CODE=CODE) + ENDFUNCTION ENCODE_BINARY_DATAARRAY1_RANK1_R4P + + FUNCTION ENCODE_BINARY_DATAARRAY1_RANK1_I8P(X) RESULT(CODE) + !< ENCODE (BASE64) A DATAARRAY WITH 1 COMPONENTS OF RANK 1 (I8P). + INTEGER(I8P), INTENT(IN) :: X(1:) !< DATA VARIABLE. + CHARACTER(LEN=:), ALLOCATABLE :: CODE !< ENCODED BASE64 DATAARRAY. + INTEGER(I1P), ALLOCATABLE :: XP(:) !< PACKED DATA. + INTEGER(I4P) :: NN !< NUMBER OF ELEMENTS. + + NN = SIZE(X, DIM=1) + CALL PACK_DATA(A1=[INT(NN*BYI8P, I4P)], A2=RESHAPE(X, [NN]), PACKED=XP) + CALL B64_ENCODE(N=XP, CODE=CODE) + ENDFUNCTION ENCODE_BINARY_DATAARRAY1_RANK1_I8P + + FUNCTION ENCODE_BINARY_DATAARRAY1_RANK1_I4P(X) RESULT(CODE) + !< ENCODE (BASE64) A DATAARRAY WITH 1 COMPONENTS OF RANK 1 (I4P). + INTEGER(I4P), INTENT(IN) :: X(1:) !< DATA VARIABLE. + CHARACTER(LEN=:), ALLOCATABLE :: CODE !< ENCODED BASE64 DATAARRAY. + INTEGER(I1P), ALLOCATABLE :: XP(:) !< PACKED DATA. + INTEGER(I4P) :: NN !< NUMBER OF ELEMENTS. + + NN = SIZE(X, DIM=1) + XP = TRANSFER([INT(NN*BYI4P, I4P), RESHAPE(X, [NN])], XP) + CALL B64_ENCODE(N=XP, CODE=CODE) + ENDFUNCTION ENCODE_BINARY_DATAARRAY1_RANK1_I4P + + FUNCTION ENCODE_BINARY_DATAARRAY1_RANK1_I2P(X) RESULT(CODE) + !< ENCODE (BASE64) A DATAARRAY WITH 1 COMPONENTS OF RANK 1 (I2P). + INTEGER(I2P), INTENT(IN) :: X(1:) !< DATA VARIABLE. + CHARACTER(LEN=:), ALLOCATABLE :: CODE !< ENCODED BASE64 DATAARRAY. + INTEGER(I1P), ALLOCATABLE :: XP(:) !< PACKED DATA. + INTEGER(I4P) :: NN !< NUMBER OF ELEMENTS. + + NN = SIZE(X, DIM=1) + CALL PACK_DATA(A1=[INT(NN*BYI2P, I4P)], A2=RESHAPE(X, [NN]), PACKED=XP) + CALL B64_ENCODE(N=XP, CODE=CODE) + ENDFUNCTION ENCODE_BINARY_DATAARRAY1_RANK1_I2P + + FUNCTION ENCODE_BINARY_DATAARRAY1_RANK1_I1P(X) RESULT(CODE) + !< ENCODE (BASE64) A DATAARRAY WITH 1 COMPONENTS OF RANK 1 (I1P). + INTEGER(I1P), INTENT(IN) :: X(1:) !< DATA VARIABLE. + CHARACTER(LEN=:), ALLOCATABLE :: CODE !< ENCODED BASE64 DATAARRAY. + INTEGER(I1P), ALLOCATABLE :: XP(:) !< PACKED DATA. + INTEGER(I4P) :: NN !< NUMBER OF ELEMENTS. + + NN = SIZE(X, DIM=1) + CALL PACK_DATA(A1=[INT(NN*BYI1P, I4P)], A2=RESHAPE(X, [NN]), PACKED=XP) + CALL B64_ENCODE(N=XP, CODE=CODE) + ENDFUNCTION ENCODE_BINARY_DATAARRAY1_RANK1_I1P + + FUNCTION ENCODE_BINARY_DATAARRAY1_RANK2_R8P(X) RESULT(CODE) + !< ENCODE (BASE64) A DATAARRAY WITH 1 COMPONENTS OF RANK 2 (R8P). + REAL(R8P), INTENT(IN) :: X(1:,1:) !< DATA VARIABLE + CHARACTER(LEN=:), ALLOCATABLE :: CODE !< ENCODED BASE64 DATAARRAY. + INTEGER(I1P), ALLOCATABLE :: XP(:) !< PACKED DATA. + INTEGER(I4P) :: NN !< NUMBER OF ELEMENTS. + + NN = SIZE(X, DIM=1)*SIZE(X, DIM=2) + CALL PACK_DATA(A1=[INT(NN*BYR8P, I4P)], A2=RESHAPE(X, [NN]), PACKED=XP) + CALL B64_ENCODE(N=XP, CODE=CODE) + ENDFUNCTION ENCODE_BINARY_DATAARRAY1_RANK2_R8P + + FUNCTION ENCODE_BINARY_DATAARRAY1_RANK2_R4P(X) RESULT(CODE) + !< ENCODE (BASE64) A DATAARRAY WITH 1 COMPONENTS OF RANK 2 (R4P). + REAL(R4P), INTENT(IN) :: X(1:,1:) !< DATA VARIABLE + CHARACTER(LEN=:), ALLOCATABLE :: CODE !< ENCODED BASE64 DATAARRAY. + INTEGER(I1P), ALLOCATABLE :: XP(:) !< PACKED DATA. + INTEGER(I4P) :: NN !< NUMBER OF ELEMENTS. + + NN = SIZE(X, DIM=1)*SIZE(X, DIM=2) + CALL PACK_DATA(A1=[INT(NN*BYR4P, I4P)], A2=RESHAPE(X, [NN]), PACKED=XP) + CALL B64_ENCODE(N=XP, CODE=CODE) + ENDFUNCTION ENCODE_BINARY_DATAARRAY1_RANK2_R4P + + FUNCTION ENCODE_BINARY_DATAARRAY1_RANK2_I8P(X) RESULT(CODE) + !< ENCODE (BASE64) A DATAARRAY WITH 1 COMPONENTS OF RANK 2 (I8P). + INTEGER(I8P), INTENT(IN) :: X(1:,1:) !< DATA VARIABLE + CHARACTER(LEN=:), ALLOCATABLE :: CODE !< ENCODED BASE64 DATAARRAY. + INTEGER(I1P), ALLOCATABLE :: XP(:) !< PACKED DATA. + INTEGER(I4P) :: NN !< NUMBER OF ELEMENTS. + + NN = SIZE(X, DIM=1)*SIZE(X, DIM=2) + CALL PACK_DATA(A1=[INT(NN*BYI8P, I4P)], A2=RESHAPE(X, [NN]), PACKED=XP) + CALL B64_ENCODE(N=XP, CODE=CODE) + ENDFUNCTION ENCODE_BINARY_DATAARRAY1_RANK2_I8P + + FUNCTION ENCODE_BINARY_DATAARRAY1_RANK2_I4P(X) RESULT(CODE) + !< ENCODE (BASE64) A DATAARRAY WITH 1 COMPONENTS OF RANK 2 (I4P). + INTEGER(I4P), INTENT(IN) :: X(1:,1:) !< DATA VARIABLE + CHARACTER(LEN=:), ALLOCATABLE :: CODE !< ENCODED BASE64 DATAARRAY. + INTEGER(I1P), ALLOCATABLE :: XP(:) !< PACKED DATA. + INTEGER(I4P) :: NN !< NUMBER OF ELEMENTS. + + NN = SIZE(X, DIM=1)*SIZE(X, DIM=2) + XP = TRANSFER([INT(NN*BYI4P, I4P), RESHAPE(X, [NN])], XP) + CALL B64_ENCODE(N=XP, CODE=CODE) + ENDFUNCTION ENCODE_BINARY_DATAARRAY1_RANK2_I4P + + FUNCTION ENCODE_BINARY_DATAARRAY1_RANK2_I2P(X) RESULT(CODE) + !< ENCODE (BASE64) A DATAARRAY WITH 1 COMPONENTS OF RANK 2 (I2P). + INTEGER(I2P), INTENT(IN) :: X(1:,1:) !< DATA VARIABLE + CHARACTER(LEN=:), ALLOCATABLE :: CODE !< ENCODED BASE64 DATAARRAY. + INTEGER(I1P), ALLOCATABLE :: XP(:) !< PACKED DATA. + INTEGER(I4P) :: NN !< NUMBER OF ELEMENTS. + + NN = SIZE(X, DIM=1)*SIZE(X, DIM=2) + CALL PACK_DATA(A1=[INT(NN*BYI2P, I4P)], A2=RESHAPE(X, [NN]), PACKED=XP) + CALL B64_ENCODE(N=XP, CODE=CODE) + ENDFUNCTION ENCODE_BINARY_DATAARRAY1_RANK2_I2P + + FUNCTION ENCODE_BINARY_DATAARRAY1_RANK2_I1P(X) RESULT(CODE) + !< ENCODE (BASE64) A DATAARRAY WITH 1 COMPONENTS OF RANK 2 (I1P). + INTEGER(I1P), INTENT(IN) :: X(1:,1:) !< DATA VARIABLE + CHARACTER(LEN=:), ALLOCATABLE :: CODE !< ENCODED BASE64 DATAARRAY. + INTEGER(I1P), ALLOCATABLE :: XP(:) !< PACKED DATA. + INTEGER(I4P) :: NN !< NUMBER OF ELEMENTS. + + NN = SIZE(X, DIM=1)*SIZE(X, DIM=2) + CALL PACK_DATA(A1=[INT(NN*BYI1P, I4P)], A2=RESHAPE(X, [NN]), PACKED=XP) + CALL B64_ENCODE(N=XP, CODE=CODE) + ENDFUNCTION ENCODE_BINARY_DATAARRAY1_RANK2_I1P + + FUNCTION ENCODE_BINARY_DATAARRAY1_RANK3_R8P(X) RESULT(CODE) + !< ENCODE (BASE64) A DATAARRAY WITH 1 COMPONENTS OF RANK 3 (R8P). + REAL(R8P), INTENT(IN) :: X(1:,1:,1:) !< DATA VARIABLE + CHARACTER(LEN=:), ALLOCATABLE :: CODE !< ENCODED BASE64 DATAARRAY. + INTEGER(I1P), ALLOCATABLE :: XP(:) !< PACKED DATA. + INTEGER(I4P) :: NN !< NUMBER OF ELEMENTS. + + NN = SIZE(X, DIM=1)*SIZE(X, DIM=2)*SIZE(X, DIM=3) + CALL PACK_DATA(A1=[INT(NN*BYR8P, I4P)], A2=RESHAPE(X, [NN]), PACKED=XP) + CALL B64_ENCODE(N=XP, CODE=CODE) + ENDFUNCTION ENCODE_BINARY_DATAARRAY1_RANK3_R8P + + FUNCTION ENCODE_BINARY_DATAARRAY1_RANK3_R4P(X) RESULT(CODE) + !< ENCODE (BASE64) A DATAARRAY WITH 1 COMPONENTS OF RANK 3 (R4P). + REAL(R4P), INTENT(IN) :: X(1:,1:,1:) !< DATA VARIABLE + CHARACTER(LEN=:), ALLOCATABLE :: CODE !< ENCODED BASE64 DATAARRAY. + INTEGER(I1P), ALLOCATABLE :: XP(:) !< PACKED DATA. + INTEGER(I4P) :: NN !< NUMBER OF ELEMENTS. + + NN = SIZE(X, DIM=1)*SIZE(X, DIM=2)*SIZE(X, DIM=3) + CALL PACK_DATA(A1=[INT(NN*BYR4P, I4P)], A2=RESHAPE(X, [NN]), PACKED=XP) + CALL B64_ENCODE(N=XP, CODE=CODE) + ENDFUNCTION ENCODE_BINARY_DATAARRAY1_RANK3_R4P + + FUNCTION ENCODE_BINARY_DATAARRAY1_RANK3_I8P(X) RESULT(CODE) + !< ENCODE (BASE64) A DATAARRAY WITH 1 COMPONENTS OF RANK 3 (I8P). + INTEGER(I8P), INTENT(IN) :: X(1:,1:,1:) !< DATA VARIABLE + CHARACTER(LEN=:), ALLOCATABLE :: CODE !< ENCODED BASE64 DATAARRAY. + INTEGER(I1P), ALLOCATABLE :: XP(:) !< PACKED DATA. + INTEGER(I4P) :: NN !< NUMBER OF ELEMENTS. + + NN = SIZE(X, DIM=1)*SIZE(X, DIM=2)*SIZE(X, DIM=3) + CALL PACK_DATA(A1=[INT(NN*BYI8P, I4P)], A2=RESHAPE(X, [NN]), PACKED=XP) + CALL B64_ENCODE(N=XP, CODE=CODE) + ENDFUNCTION ENCODE_BINARY_DATAARRAY1_RANK3_I8P + + FUNCTION ENCODE_BINARY_DATAARRAY1_RANK3_I4P(X) RESULT(CODE) + !< ENCODE (BASE64) A DATAARRAY WITH 1 COMPONENTS OF RANK 3 (I4P). + INTEGER(I4P), INTENT(IN) :: X(1:,1:,1:) !< DATA VARIABLE + CHARACTER(LEN=:), ALLOCATABLE :: CODE !< ENCODED BASE64 DATAARRAY. + INTEGER(I1P), ALLOCATABLE :: XP(:) !< PACKED DATA. + INTEGER(I4P) :: NN !< NUMBER OF ELEMENTS. + + NN = SIZE(X, DIM=1)*SIZE(X, DIM=2)*SIZE(X, DIM=3) + XP = TRANSFER([INT(NN*BYI4P, I4P), RESHAPE(X, [NN])], XP) + CALL B64_ENCODE(N=XP, CODE=CODE) + ENDFUNCTION ENCODE_BINARY_DATAARRAY1_RANK3_I4P + + FUNCTION ENCODE_BINARY_DATAARRAY1_RANK3_I2P(X) RESULT(CODE) + !< ENCODE (BASE64) A DATAARRAY WITH 1 COMPONENTS OF RANK 3 (I2P). + INTEGER(I2P), INTENT(IN) :: X(1:,1:,1:) !< DATA VARIABLE + CHARACTER(LEN=:), ALLOCATABLE :: CODE !< ENCODED BASE64 DATAARRAY. + INTEGER(I1P), ALLOCATABLE :: XP(:) !< PACKED DATA. + INTEGER(I4P) :: NN !< NUMBER OF ELEMENTS. + + NN = SIZE(X, DIM=1)*SIZE(X, DIM=2)*SIZE(X, DIM=3) + CALL PACK_DATA(A1=[INT(NN*BYI2P, I4P)], A2=RESHAPE(X, [NN]), PACKED=XP) + CALL B64_ENCODE(N=XP, CODE=CODE) + ENDFUNCTION ENCODE_BINARY_DATAARRAY1_RANK3_I2P + + FUNCTION ENCODE_BINARY_DATAARRAY1_RANK3_I1P(X) RESULT(CODE) + !< ENCODE (BASE64) A DATAARRAY WITH 1 COMPONENTS OF RANK 3 (I1P). + INTEGER(I1P), INTENT(IN) :: X(1:,1:,1:) !< DATA VARIABLE + CHARACTER(LEN=:), ALLOCATABLE :: CODE !< ENCODED BASE64 DATAARRAY. + INTEGER(I1P), ALLOCATABLE :: XP(:) !< PACKED DATA. + INTEGER(I4P) :: NN !< NUMBER OF ELEMENTS. + + NN = SIZE(X, DIM=1)*SIZE(X, DIM=2)*SIZE(X, DIM=3) + CALL PACK_DATA(A1=[INT(NN*BYI1P, I4P)], A2=RESHAPE(X, [NN]), PACKED=XP) + CALL B64_ENCODE(N=XP, CODE=CODE) + ENDFUNCTION ENCODE_BINARY_DATAARRAY1_RANK3_I1P + + FUNCTION ENCODE_BINARY_DATAARRAY1_RANK4_R8P(X) RESULT(CODE) + !< ENCODE (BASE64) A DATAARRAY WITH 1 COMPONENTS OF RANK 4 (R8P). + REAL(R8P), INTENT(IN) :: X(1:,1:,1:,1:) !< DATA VARIABLE. + CHARACTER(LEN=:), ALLOCATABLE :: CODE !< ENCODED BASE64 DATAARRAY. + INTEGER(I1P), ALLOCATABLE :: XP(:) !< PACKED DATA. + INTEGER(I4P) :: NN !< NUMBER OF ELEMENTS. + + NN = SIZE(X, DIM=1)*SIZE(X, DIM=2)*SIZE(X, DIM=3)*SIZE(X, DIM=4) + CALL PACK_DATA(A1=[INT(NN*BYR8P, I4P)], A2=RESHAPE(X, [NN]), PACKED=XP) + CALL B64_ENCODE(N=XP, CODE=CODE) + ENDFUNCTION ENCODE_BINARY_DATAARRAY1_RANK4_R8P + + FUNCTION ENCODE_BINARY_DATAARRAY1_RANK4_R4P(X) RESULT(CODE) + !< ENCODE (BASE64) A DATAARRAY WITH 1 COMPONENTS OF RANK 4 (R4P). + REAL(R4P), INTENT(IN) :: X(1:,1:,1:,1:) !< DATA VARIABLE. + CHARACTER(LEN=:), ALLOCATABLE :: CODE !< ENCODED BASE64 DATAARRAY. + INTEGER(I1P), ALLOCATABLE :: XP(:) !< PACKED DATA. + INTEGER(I4P) :: NN !< NUMBER OF ELEMENTS. + + NN = SIZE(X, DIM=1)*SIZE(X, DIM=2)*SIZE(X, DIM=3)*SIZE(X, DIM=4) + CALL PACK_DATA(A1=[INT(NN*BYR4P, I4P)], A2=RESHAPE(X, [NN]), PACKED=XP) + CALL B64_ENCODE(N=XP, CODE=CODE) + ENDFUNCTION ENCODE_BINARY_DATAARRAY1_RANK4_R4P + + FUNCTION ENCODE_BINARY_DATAARRAY1_RANK4_I8P(X) RESULT(CODE) + !< ENCODE (BASE64) A DATAARRAY WITH 1 COMPONENTS OF RANK 4 (I8P). + INTEGER(I8P), INTENT(IN) :: X(1:,1:,1:,1:) !< DATA VARIABLE. + CHARACTER(LEN=:), ALLOCATABLE :: CODE !< ENCODED BASE64 DATAARRAY. + INTEGER(I1P), ALLOCATABLE :: XP(:) !< PACKED DATA. + INTEGER(I4P) :: NN !< NUMBER OF ELEMENTS. + + NN = SIZE(X, DIM=1)*SIZE(X, DIM=2)*SIZE(X, DIM=3)*SIZE(X, DIM=4) + CALL PACK_DATA(A1=[INT(NN*BYI8P, I4P)], A2=RESHAPE(X, [NN]), PACKED=XP) + CALL B64_ENCODE(N=XP, CODE=CODE) + ENDFUNCTION ENCODE_BINARY_DATAARRAY1_RANK4_I8P + + FUNCTION ENCODE_BINARY_DATAARRAY1_RANK4_I4P(X) RESULT(CODE) + !< ENCODE (BASE64) A DATAARRAY WITH 1 COMPONENTS OF RANK 4 (I4P). + INTEGER(I4P), INTENT(IN) :: X(1:,1:,1:,1:) !< DATA VARIABLE. + CHARACTER(LEN=:), ALLOCATABLE :: CODE !< ENCODED BASE64 DATAARRAY. + INTEGER(I1P), ALLOCATABLE :: XP(:) !< PACKED DATA. + INTEGER(I4P) :: NN !< NUMBER OF ELEMENTS. + + NN = SIZE(X, DIM=1)*SIZE(X, DIM=2)*SIZE(X, DIM=3)*SIZE(X, DIM=4) + XP = TRANSFER([INT(NN*BYI4P, I4P), RESHAPE(X, [NN])], XP) + CALL B64_ENCODE(N=XP, CODE=CODE) + ENDFUNCTION ENCODE_BINARY_DATAARRAY1_RANK4_I4P + + FUNCTION ENCODE_BINARY_DATAARRAY1_RANK4_I2P(X) RESULT(CODE) + !< ENCODE (BASE64) A DATAARRAY WITH 1 COMPONENTS OF RANK 4 (I2P). + INTEGER(I2P), INTENT(IN) :: X(1:,1:,1:,1:) !< DATA VARIABLE. + CHARACTER(LEN=:), ALLOCATABLE :: CODE !< ENCODED BASE64 DATAARRAY. + INTEGER(I1P), ALLOCATABLE :: XP(:) !< PACKED DATA. + INTEGER(I4P) :: NN !< NUMBER OF ELEMENTS. + + NN = SIZE(X, DIM=1)*SIZE(X, DIM=2)*SIZE(X, DIM=3)*SIZE(X, DIM=4) + CALL PACK_DATA(A1=[INT(NN*BYI2P, I4P)], A2=RESHAPE(X, [NN]), PACKED=XP) + CALL B64_ENCODE(N=XP, CODE=CODE) + ENDFUNCTION ENCODE_BINARY_DATAARRAY1_RANK4_I2P + + FUNCTION ENCODE_BINARY_DATAARRAY1_RANK4_I1P(X) RESULT(CODE) + !< ENCODE (BASE64) A DATAARRAY WITH 1 COMPONENTS OF RANK 4 (I1P). + INTEGER(I1P), INTENT(IN) :: X(1:,1:,1:,1:) !< DATA VARIABLE. + CHARACTER(LEN=:), ALLOCATABLE :: CODE !< ENCODED BASE64 DATAARRAY. + INTEGER(I1P), ALLOCATABLE :: XP(:) !< PACKED DATA. + INTEGER(I4P) :: NN !< NUMBER OF ELEMENTS. + + NN = SIZE(X, DIM=1)*SIZE(X, DIM=2)*SIZE(X, DIM=3)*SIZE(X, DIM=4) + CALL PACK_DATA(A1=[INT(NN*BYI1P, I4P)], A2=RESHAPE(X, [NN]), PACKED=XP) + CALL B64_ENCODE(N=XP, CODE=CODE) + ENDFUNCTION ENCODE_BINARY_DATAARRAY1_RANK4_I1P + + FUNCTION ENCODE_BINARY_DATAARRAY3_RANK1_R8P(X, Y, Z) RESULT(CODE) + !< ENCODE (BASE64) A DATAARRAY WITH 3 COMPONENTS OF RANK 1 (R8P). + REAL(R8P), INTENT(IN) :: X(1:) !< X COMPONENT. + REAL(R8P), INTENT(IN) :: Y(1:) !< Y COMPONENT. + REAL(R8P), INTENT(IN) :: Z(1:) !< Z COMPONENT. + CHARACTER(LEN=:), ALLOCATABLE :: CODE !< ENCODED BASE64 DATAARRAY. + INTEGER(I1P), ALLOCATABLE :: XYZ(:) !< PACKED DATA. + INTEGER(I4P) :: NN !< NUMBER OF ELEMENTS. + INTEGER(I4P) :: N !< COUNTER. + + NN = SIZE(X, DIM=1) + CALL PACK_DATA(A1=[INT(3*NN*BYR8P, I4P)], A2=[(X(N), Y(N), Z(N), N=1, NN)], PACKED=XYZ) + CALL B64_ENCODE(N=XYZ, CODE=CODE) + ENDFUNCTION ENCODE_BINARY_DATAARRAY3_RANK1_R8P + + FUNCTION ENCODE_BINARY_DATAARRAY3_RANK1_R4P(X, Y, Z) RESULT(CODE) + !< ENCODE (BASE64) A DATAARRAY WITH 3 COMPONENTS OF RANK 1 (R4P). + REAL(R4P), INTENT(IN) :: X(1:) !< X COMPONENT. + REAL(R4P), INTENT(IN) :: Y(1:) !< Y COMPONENT. + REAL(R4P), INTENT(IN) :: Z(1:) !< Z COMPONENT. + CHARACTER(LEN=:), ALLOCATABLE :: CODE !< ENCODED BASE64 DATAARRAY. + INTEGER(I1P), ALLOCATABLE :: XYZ(:) !< PACKED DATA. + INTEGER(I4P) :: NN !< NUMBER OF ELEMENTS. + INTEGER(I4P) :: N !< COUNTER. + + NN = SIZE(X, DIM=1) + CALL PACK_DATA(A1=[INT(3*NN*BYR4P, I4P)], A2=[(X(N), Y(N), Z(N), N=1, NN)], PACKED=XYZ) + CALL B64_ENCODE(N=XYZ, CODE=CODE) + ENDFUNCTION ENCODE_BINARY_DATAARRAY3_RANK1_R4P + + FUNCTION ENCODE_BINARY_DATAARRAY3_RANK1_I8P(X, Y, Z) RESULT(CODE) + !< ENCODE (BASE64) A DATAARRAY WITH 3 COMPONENTS OF RANK 1 (I8P). + INTEGER(I8P), INTENT(IN) :: X(1:) !< X COMPONENT. + INTEGER(I8P), INTENT(IN) :: Y(1:) !< Y COMPONENT. + INTEGER(I8P), INTENT(IN) :: Z(1:) !< Z COMPONENT. + CHARACTER(LEN=:), ALLOCATABLE :: CODE !< ENCODED BASE64 DATAARRAY. + INTEGER(I1P), ALLOCATABLE :: XYZ(:) !< PACKED DATA. + INTEGER(I4P) :: NN !< NUMBER OF ELEMENTS. + INTEGER(I4P) :: N !< COUNTER. + + NN = SIZE(X, DIM=1) + CALL PACK_DATA(A1=[INT(3*NN*BYI8P, I4P)], A2=[(X(N), Y(N), Z(N), N=1, NN)], PACKED=XYZ) + CALL B64_ENCODE(N=XYZ, CODE=CODE) + ENDFUNCTION ENCODE_BINARY_DATAARRAY3_RANK1_I8P + + FUNCTION ENCODE_BINARY_DATAARRAY3_RANK1_I4P(X, Y, Z) RESULT(CODE) + !< ENCODE (BASE64) A DATAARRAY WITH 3 COMPONENTS OF RANK 1 (I4P). + INTEGER(I4P), INTENT(IN) :: X(1:) !< X COMPONENT. + INTEGER(I4P), INTENT(IN) :: Y(1:) !< Y COMPONENT. + INTEGER(I4P), INTENT(IN) :: Z(1:) !< Z COMPONENT. + CHARACTER(LEN=:), ALLOCATABLE :: CODE !< ENCODED BASE64 DATAARRAY. + INTEGER(I1P), ALLOCATABLE :: XYZ(:) !< PACKED DATA. + INTEGER(I4P) :: NN !< NUMBER OF ELEMENTS. + INTEGER(I4P) :: N !< COUNTER. + + NN = SIZE(X, DIM=1) + XYZ = TRANSFER([INT(3*NN*BYI4P, I4P), [(X(N), Y(N), Z(N), N=1, NN)]], XYZ) + CALL B64_ENCODE(N=XYZ, CODE=CODE) + ENDFUNCTION ENCODE_BINARY_DATAARRAY3_RANK1_I4P + + FUNCTION ENCODE_BINARY_DATAARRAY3_RANK1_I2P(X, Y, Z) RESULT(CODE) + !< ENCODE (BASE64) A DATAARRAY WITH 3 COMPONENTS OF RANK 1 (I2P). + INTEGER(I2P), INTENT(IN) :: X(1:) !< X COMPONENT. + INTEGER(I2P), INTENT(IN) :: Y(1:) !< Y COMPONENT. + INTEGER(I2P), INTENT(IN) :: Z(1:) !< Z COMPONENT. + CHARACTER(LEN=:), ALLOCATABLE :: CODE !< ENCODED BASE64 DATAARRAY. + INTEGER(I1P), ALLOCATABLE :: XYZ(:) !< PACKED DATA. + INTEGER(I4P) :: NN !< NUMBER OF ELEMENTS. + INTEGER(I4P) :: N !< COUNTER. + + NN = SIZE(X, DIM=1) + CALL PACK_DATA(A1=[INT(3*NN*BYI2P, I4P)], A2=[(X(N), Y(N), Z(N), N=1, NN)], PACKED=XYZ) + CALL B64_ENCODE(N=XYZ, CODE=CODE) + ENDFUNCTION ENCODE_BINARY_DATAARRAY3_RANK1_I2P + + FUNCTION ENCODE_BINARY_DATAARRAY3_RANK1_I1P(X, Y, Z) RESULT(CODE) + !< ENCODE (BASE64) A DATAARRAY WITH 3 COMPONENTS OF RANK 1 (I1P). + INTEGER(I1P), INTENT(IN) :: X(1:) !< X COMPONENT. + INTEGER(I1P), INTENT(IN) :: Y(1:) !< Y COMPONENT. + INTEGER(I1P), INTENT(IN) :: Z(1:) !< Z COMPONENT. + CHARACTER(LEN=:), ALLOCATABLE :: CODE !< ENCODED BASE64 DATAARRAY. + INTEGER(I1P), ALLOCATABLE :: XYZ(:) !< PACKED DATA. + INTEGER(I4P) :: NN !< NUMBER OF ELEMENTS. + INTEGER(I4P) :: N !< COUNTER. + + NN = SIZE(X, DIM=1) + CALL PACK_DATA(A1=[INT(3*NN*BYI1P, I4P)], A2=[(X(N), Y(N), Z(N), N=1, NN)], PACKED=XYZ) + CALL B64_ENCODE(N=XYZ, CODE=CODE) + ENDFUNCTION ENCODE_BINARY_DATAARRAY3_RANK1_I1P + + FUNCTION ENCODE_BINARY_DATAARRAY3_RANK3_R8P(X, Y, Z) RESULT(CODE) + !< ENCODE (BASE64) A DATAARRAY WITH 3 COMPONENTS OF RANK 3 (R8P). + REAL(R8P), INTENT(IN) :: X(1:,1:,1:) !< X COMPONENT. + REAL(R8P), INTENT(IN) :: Y(1:,1:,1:) !< Y COMPONENT. + REAL(R8P), INTENT(IN) :: Z(1:,1:,1:) !< Z COMPONENT. + CHARACTER(LEN=:), ALLOCATABLE :: CODE !< ENCODED BASE64 DATAARRAY. + INTEGER(I1P), ALLOCATABLE :: XYZ(:) !< PACKED DATA. + INTEGER(I4P) :: NN1 !< NUMBER OF ELEMENTS ALONG DIM 1. + INTEGER(I4P) :: NN2 !< NUMBER OF ELEMENTS ALONG DIM 2. + INTEGER(I4P) :: NN3 !< NUMBER OF ELEMENTS ALONG DIM 3. + INTEGER(I4P) :: NN !< NUMBER OF ELEMENTS. + INTEGER(I4P) :: N1 !< COUNTER. + INTEGER(I4P) :: N2 !< COUNTER. + INTEGER(I4P) :: N3 !< COUNTER. + + NN1 = SIZE(X, DIM=1) + NN2 = SIZE(X, DIM=2) + NN3 = SIZE(X, DIM=3) + NN = NN1*NN2*NN3 + CALL PACK_DATA(A1=[INT(3*NN*BYR8P, I4P)], A2=[(((X(N1, N2, N3), Y(N1, N2, N3), Z(N1, N2, N3), N1=1, NN1), & + N2=1, NN2), & + N3=1, NN3)], & + PACKED=XYZ) + CALL B64_ENCODE(N=XYZ,CODE=CODE) + ENDFUNCTION ENCODE_BINARY_DATAARRAY3_RANK3_R8P + + FUNCTION ENCODE_BINARY_DATAARRAY3_RANK3_R4P(X, Y, Z) RESULT(CODE) + !< ENCODE (BASE64) A DATAARRAY WITH 3 COMPONENTS OF RANK 3 (R4P). + REAL(R4P), INTENT(IN) :: X(1:,1:,1:) !< X COMPONENT. + REAL(R4P), INTENT(IN) :: Y(1:,1:,1:) !< Y COMPONENT. + REAL(R4P), INTENT(IN) :: Z(1:,1:,1:) !< Z COMPONENT. + CHARACTER(LEN=:), ALLOCATABLE :: CODE !< ENCODED BASE64 DATAARRAY. + INTEGER(I1P), ALLOCATABLE :: XYZ(:) !< PACKED DATA. + INTEGER(I4P) :: NN1 !< NUMBER OF ELEMENTS ALONG DIM 1. + INTEGER(I4P) :: NN2 !< NUMBER OF ELEMENTS ALONG DIM 2. + INTEGER(I4P) :: NN3 !< NUMBER OF ELEMENTS ALONG DIM 3. + INTEGER(I4P) :: NN !< NUMBER OF ELEMENTS. + INTEGER(I4P) :: N1 !< COUNTER. + INTEGER(I4P) :: N2 !< COUNTER. + INTEGER(I4P) :: N3 !< COUNTER. + + NN1 = SIZE(X, DIM=1) + NN2 = SIZE(X, DIM=2) + NN3 = SIZE(X, DIM=3) + NN = NN1*NN2*NN3 + CALL PACK_DATA(A1=[INT(3*NN*BYR4P, I4P)], A2=[(((X(N1, N2, N3), Y(N1, N2, N3), Z(N1, N2, N3), N1=1, NN1), & + N2=1, NN2), & + N3=1, NN3)], & + PACKED=XYZ) + CALL B64_ENCODE(N=XYZ,CODE=CODE) + ENDFUNCTION ENCODE_BINARY_DATAARRAY3_RANK3_R4P + + FUNCTION ENCODE_BINARY_DATAARRAY3_RANK3_I8P(X, Y, Z) RESULT(CODE) + !< ENCODE (BASE64) A DATAARRAY WITH 3 COMPONENTS OF RANK 3 (I8P). + INTEGER(I8P), INTENT(IN) :: X(1:,1:,1:) !< X COMPONENT. + INTEGER(I8P), INTENT(IN) :: Y(1:,1:,1:) !< Y COMPONENT. + INTEGER(I8P), INTENT(IN) :: Z(1:,1:,1:) !< Z COMPONENT. + CHARACTER(LEN=:), ALLOCATABLE :: CODE !< ENCODED BASE64 DATAARRAY. + INTEGER(I1P), ALLOCATABLE :: XYZ(:) !< PACKED DATA. + INTEGER(I4P) :: NN1 !< NUMBER OF ELEMENTS ALONG DIM 1. + INTEGER(I4P) :: NN2 !< NUMBER OF ELEMENTS ALONG DIM 2. + INTEGER(I4P) :: NN3 !< NUMBER OF ELEMENTS ALONG DIM 3. + INTEGER(I4P) :: NN !< NUMBER OF ELEMENTS. + INTEGER(I4P) :: N1 !< COUNTER. + INTEGER(I4P) :: N2 !< COUNTER. + INTEGER(I4P) :: N3 !< COUNTER. + + NN1 = SIZE(X, DIM=1) + NN2 = SIZE(X, DIM=2) + NN3 = SIZE(X, DIM=3) + NN = NN1*NN2*NN3 + CALL PACK_DATA(A1=[INT(3*NN*BYI8P, I4P)], A2=[(((X(N1, N2, N3), Y(N1, N2, N3), Z(N1, N2, N3), N1=1, NN1), & + N2=1, NN2), & + N3=1, NN3)], & + PACKED=XYZ) + CALL B64_ENCODE(N=XYZ,CODE=CODE) + ENDFUNCTION ENCODE_BINARY_DATAARRAY3_RANK3_I8P + + FUNCTION ENCODE_BINARY_DATAARRAY3_RANK3_I4P(X, Y, Z) RESULT(CODE) + !< ENCODE (BASE64) A DATAARRAY WITH 3 COMPONENTS OF RANK 3 (I4P). + INTEGER(I4P), INTENT(IN) :: X(1:,1:,1:) !< X COMPONENT. + INTEGER(I4P), INTENT(IN) :: Y(1:,1:,1:) !< Y COMPONENT. + INTEGER(I4P), INTENT(IN) :: Z(1:,1:,1:) !< Z COMPONENT. + CHARACTER(LEN=:), ALLOCATABLE :: CODE !< ENCODED BASE64 DATAARRAY. + INTEGER(I1P), ALLOCATABLE :: XYZ(:) !< PACKED DATA. + INTEGER(I4P) :: NN1 !< NUMBER OF ELEMENTS ALONG DIM 1. + INTEGER(I4P) :: NN2 !< NUMBER OF ELEMENTS ALONG DIM 2. + INTEGER(I4P) :: NN3 !< NUMBER OF ELEMENTS ALONG DIM 3. + INTEGER(I4P) :: NN !< NUMBER OF ELEMENTS. + INTEGER(I4P) :: N1 !< COUNTER. + INTEGER(I4P) :: N2 !< COUNTER. + INTEGER(I4P) :: N3 !< COUNTER. + + NN1 = SIZE(X, DIM=1) + NN2 = SIZE(X, DIM=2) + NN3 = SIZE(X, DIM=3) + NN = NN1*NN2*NN3 + XYZ = TRANSFER([INT(3*NN*BYI4P, I4P), [(((X(N1, N2, N3), Y(N1, N2, N3), Z(N1, N2, N3), N1=1, NN1), & + N2=1, NN2), & + N3=1, NN3)]], XYZ) + CALL B64_ENCODE(N=XYZ,CODE=CODE) + ENDFUNCTION ENCODE_BINARY_DATAARRAY3_RANK3_I4P + + FUNCTION ENCODE_BINARY_DATAARRAY3_RANK3_I2P(X, Y, Z) RESULT(CODE) + !< ENCODE (BASE64) A DATAARRAY WITH 3 COMPONENTS OF RANK 3 (I2P). + INTEGER(I2P), INTENT(IN) :: X(1:,1:,1:) !< X COMPONENT. + INTEGER(I2P), INTENT(IN) :: Y(1:,1:,1:) !< Y COMPONENT. + INTEGER(I2P), INTENT(IN) :: Z(1:,1:,1:) !< Z COMPONENT. + CHARACTER(LEN=:), ALLOCATABLE :: CODE !< ENCODED BASE64 DATAARRAY. + INTEGER(I1P), ALLOCATABLE :: XYZ(:) !< PACKED DATA. + INTEGER(I4P) :: NN1 !< NUMBER OF ELEMENTS ALONG DIM 1. + INTEGER(I4P) :: NN2 !< NUMBER OF ELEMENTS ALONG DIM 2. + INTEGER(I4P) :: NN3 !< NUMBER OF ELEMENTS ALONG DIM 3. + INTEGER(I4P) :: NN !< NUMBER OF ELEMENTS. + INTEGER(I4P) :: N1 !< COUNTER. + INTEGER(I4P) :: N2 !< COUNTER. + INTEGER(I4P) :: N3 !< COUNTER. + + NN1 = SIZE(X, DIM=1) + NN2 = SIZE(X, DIM=2) + NN3 = SIZE(X, DIM=3) + NN = NN1*NN2*NN3 + CALL PACK_DATA(A1=[INT(3*NN*BYI2P, I4P)], A2=[(((X(N1, N2, N3), Y(N1, N2, N3), Z(N1, N2, N3), N1=1, NN1), & + N2=1, NN2), & + N3=1, NN3)], & + PACKED=XYZ) + CALL B64_ENCODE(N=XYZ,CODE=CODE) + ENDFUNCTION ENCODE_BINARY_DATAARRAY3_RANK3_I2P + + FUNCTION ENCODE_BINARY_DATAARRAY3_RANK3_I1P(X, Y, Z) RESULT(CODE) + !< ENCODE (BASE64) A DATAARRAY WITH 3 COMPONENTS OF RANK 3 (I1P). + INTEGER(I1P), INTENT(IN) :: X(1:,1:,1:) !< X COMPONENT. + INTEGER(I1P), INTENT(IN) :: Y(1:,1:,1:) !< Y COMPONENT. + INTEGER(I1P), INTENT(IN) :: Z(1:,1:,1:) !< Z COMPONENT. + CHARACTER(LEN=:), ALLOCATABLE :: CODE !< ENCODED BASE64 DATAARRAY. + INTEGER(I1P), ALLOCATABLE :: XYZ(:) !< PACKED DATA. + INTEGER(I4P) :: NN1 !< NUMBER OF ELEMENTS ALONG DIM 1. + INTEGER(I4P) :: NN2 !< NUMBER OF ELEMENTS ALONG DIM 2. + INTEGER(I4P) :: NN3 !< NUMBER OF ELEMENTS ALONG DIM 3. + INTEGER(I4P) :: NN !< NUMBER OF ELEMENTS. + INTEGER(I4P) :: N1 !< COUNTER. + INTEGER(I4P) :: N2 !< COUNTER. + INTEGER(I4P) :: N3 !< COUNTER. + + NN1 = SIZE(X, DIM=1) + NN2 = SIZE(X, DIM=2) + NN3 = SIZE(X, DIM=3) + NN = NN1*NN2*NN3 + CALL PACK_DATA(A1=[INT(3*NN*BYI1P, I4P)], A2=[(((X(N1, N2, N3), Y(N1, N2, N3), Z(N1, N2, N3), N1=1, NN1), & + N2=1, NN2), & + N3=1, NN3)], & + PACKED=XYZ) + CALL B64_ENCODE(N=XYZ,CODE=CODE) + ENDFUNCTION ENCODE_BINARY_DATAARRAY3_RANK3_I1P + + FUNCTION ENCODE_BINARY_DATAARRAY6_RANK1_R8P(U, V, W, X, Y, Z) RESULT(CODE) + !< ENCODE (BASE64) A DATAARRAY WITH 6 COMPONENTS OF RANK 1 (R8P). + REAL(R8P), INTENT(IN) :: U(1:) !< U COMPONENT. + REAL(R8P), INTENT(IN) :: V(1:) !< V COMPONENT. + REAL(R8P), INTENT(IN) :: W(1:) !< W COMPONENT. + REAL(R8P), INTENT(IN) :: X(1:) !< X COMPONENT. + REAL(R8P), INTENT(IN) :: Y(1:) !< Y COMPONENT. + REAL(R8P), INTENT(IN) :: Z(1:) !< Z COMPONENT. + CHARACTER(LEN=:), ALLOCATABLE :: CODE !< ENCODED BASE64 DATAARRAY. + INTEGER(I1P), ALLOCATABLE :: XYZ(:) !< PACKED DATA. + INTEGER(I4P) :: NN !< NUMBER OF ELEMENTS. + INTEGER(I4P) :: N !< COUNTER. + + NN = SIZE(X, DIM=1) + CALL PACK_DATA(A1=[INT(6*NN*BYR8P, I4P)], A2=[(U(N), V(N), W(N), X(N), Y(N), Z(N), N=1, NN)], PACKED=XYZ) + CALL B64_ENCODE(N=XYZ, CODE=CODE) + ENDFUNCTION ENCODE_BINARY_DATAARRAY6_RANK1_R8P + + FUNCTION ENCODE_BINARY_DATAARRAY6_RANK1_R4P(U, V, W, X, Y, Z) RESULT(CODE) + !< ENCODE (BASE64) A DATAARRAY WITH 6 COMPONENTS OF RANK 1 (R4P). + REAL(R4P), INTENT(IN) :: U(1:) !< U COMPONENT. + REAL(R4P), INTENT(IN) :: V(1:) !< V COMPONENT. + REAL(R4P), INTENT(IN) :: W(1:) !< W COMPONENT. + REAL(R4P), INTENT(IN) :: X(1:) !< X COMPONENT. + REAL(R4P), INTENT(IN) :: Y(1:) !< Y COMPONENT. + REAL(R4P), INTENT(IN) :: Z(1:) !< Z COMPONENT. + CHARACTER(LEN=:), ALLOCATABLE :: CODE !< ENCODED BASE64 DATAARRAY. + INTEGER(I1P), ALLOCATABLE :: XYZ(:) !< PACKED DATA. + INTEGER(I4P) :: NN !< NUMBER OF ELEMENTS. + INTEGER(I4P) :: N !< COUNTER. + + NN = SIZE(X, DIM=1) + CALL PACK_DATA(A1=[INT(6*NN*BYR4P, I4P)], A2=[(U(N), V(N), W(N), X(N), Y(N), Z(N), N=1, NN)], PACKED=XYZ) + CALL B64_ENCODE(N=XYZ, CODE=CODE) + ENDFUNCTION ENCODE_BINARY_DATAARRAY6_RANK1_R4P + + FUNCTION ENCODE_BINARY_DATAARRAY6_RANK1_I8P(U, V, W, X, Y, Z) RESULT(CODE) + !< ENCODE (BASE64) A DATAARRAY WITH 6 COMPONENTS OF RANK 1 (I8P). + INTEGER(I8P), INTENT(IN) :: U(1:) !< U COMPONENT. + INTEGER(I8P), INTENT(IN) :: V(1:) !< V COMPONENT. + INTEGER(I8P), INTENT(IN) :: W(1:) !< W COMPONENT. + INTEGER(I8P), INTENT(IN) :: X(1:) !< X COMPONENT. + INTEGER(I8P), INTENT(IN) :: Y(1:) !< Y COMPONENT. + INTEGER(I8P), INTENT(IN) :: Z(1:) !< Z COMPONENT. + CHARACTER(LEN=:), ALLOCATABLE :: CODE !< ENCODED BASE64 DATAARRAY. + INTEGER(I1P), ALLOCATABLE :: XYZ(:) !< PACKED DATA. + INTEGER(I4P) :: NN !< NUMBER OF ELEMENTS. + INTEGER(I4P) :: N !< COUNTER. + + NN = SIZE(X, DIM=1) + CALL PACK_DATA(A1=[INT(6*NN*BYI8P, I4P)], A2=[(U(N), V(N), W(N), X(N), Y(N), Z(N), N=1, NN)], PACKED=XYZ) + CALL B64_ENCODE(N=XYZ, CODE=CODE) + ENDFUNCTION ENCODE_BINARY_DATAARRAY6_RANK1_I8P + + FUNCTION ENCODE_BINARY_DATAARRAY6_RANK1_I4P(U, V, W, X, Y, Z) RESULT(CODE) + !< ENCODE (BASE64) A DATAARRAY WITH 6 COMPONENTS OF RANK 1 (I4P). + INTEGER(I4P), INTENT(IN) :: U(1:) !< U COMPONENT. + INTEGER(I4P), INTENT(IN) :: V(1:) !< V COMPONENT. + INTEGER(I4P), INTENT(IN) :: W(1:) !< W COMPONENT. + INTEGER(I4P), INTENT(IN) :: X(1:) !< X COMPONENT. + INTEGER(I4P), INTENT(IN) :: Y(1:) !< Y COMPONENT. + INTEGER(I4P), INTENT(IN) :: Z(1:) !< Z COMPONENT. + CHARACTER(LEN=:), ALLOCATABLE :: CODE !< ENCODED BASE64 DATAARRAY. + INTEGER(I1P), ALLOCATABLE :: XYZ(:) !< PACKED DATA. + INTEGER(I4P) :: NN !< NUMBER OF ELEMENTS. + INTEGER(I4P) :: N !< COUNTER. + + NN = SIZE(X, DIM=1) + XYZ = TRANSFER([INT(6*NN*BYI4P, I4P), [(U(N), V(N), W(N), X(N), Y(N), Z(N), N=1, NN)]], XYZ) + CALL B64_ENCODE(N=XYZ, CODE=CODE) + ENDFUNCTION ENCODE_BINARY_DATAARRAY6_RANK1_I4P + + FUNCTION ENCODE_BINARY_DATAARRAY6_RANK1_I2P(U, V, W, X, Y, Z) RESULT(CODE) + !< ENCODE (BASE64) A DATAARRAY WITH 6 COMPONENTS OF RANK 1 (I2P). + INTEGER(I2P), INTENT(IN) :: U(1:) !< U COMPONENT. + INTEGER(I2P), INTENT(IN) :: V(1:) !< V COMPONENT. + INTEGER(I2P), INTENT(IN) :: W(1:) !< W COMPONENT. + INTEGER(I2P), INTENT(IN) :: X(1:) !< X COMPONENT. + INTEGER(I2P), INTENT(IN) :: Y(1:) !< Y COMPONENT. + INTEGER(I2P), INTENT(IN) :: Z(1:) !< Z COMPONENT. + CHARACTER(LEN=:), ALLOCATABLE :: CODE !< ENCODED BASE64 DATAARRAY. + INTEGER(I1P), ALLOCATABLE :: XYZ(:) !< PACKED DATA. + INTEGER(I4P) :: NN !< NUMBER OF ELEMENTS. + INTEGER(I4P) :: N !< COUNTER. + + NN = SIZE(X, DIM=1) + CALL PACK_DATA(A1=[INT(6*NN*BYI2P, I4P)], A2=[(U(N), V(N), W(N), X(N), Y(N), Z(N), N=1, NN)], PACKED=XYZ) + CALL B64_ENCODE(N=XYZ, CODE=CODE) + ENDFUNCTION ENCODE_BINARY_DATAARRAY6_RANK1_I2P + + FUNCTION ENCODE_BINARY_DATAARRAY6_RANK1_I1P(U, V, W, X, Y, Z) RESULT(CODE) + !< ENCODE (BASE64) A DATAARRAY WITH 6 COMPONENTS OF RANK 1 (I1P). + INTEGER(I1P), INTENT(IN) :: U(1:) !< U COMPONENT. + INTEGER(I1P), INTENT(IN) :: V(1:) !< V COMPONENT. + INTEGER(I1P), INTENT(IN) :: W(1:) !< W COMPONENT. + INTEGER(I1P), INTENT(IN) :: X(1:) !< X COMPONENT. + INTEGER(I1P), INTENT(IN) :: Y(1:) !< Y COMPONENT. + INTEGER(I1P), INTENT(IN) :: Z(1:) !< Z COMPONENT. + CHARACTER(LEN=:), ALLOCATABLE :: CODE !< ENCODED BASE64 DATAARRAY. + INTEGER(I1P), ALLOCATABLE :: XYZ(:) !< PACKED DATA. + INTEGER(I4P) :: NN !< NUMBER OF ELEMENTS. + INTEGER(I4P) :: N !< COUNTER. + + NN = SIZE(X, DIM=1) + CALL PACK_DATA(A1=[INT(6*NN*BYI1P, I4P)], A2=[(U(N), V(N), W(N), X(N), Y(N), Z(N), N=1, NN)], PACKED=XYZ) + CALL B64_ENCODE(N=XYZ, CODE=CODE) + ENDFUNCTION ENCODE_BINARY_DATAARRAY6_RANK1_I1P + + FUNCTION ENCODE_BINARY_DATAARRAY6_RANK3_R8P(U, V, W, X, Y, Z) RESULT(CODE) + !< ENCODE (BASE64) A DATAARRAY WITH 6 COMPONENTS OF RANK 3 (R8P). + REAL(R8P), INTENT(IN) :: U(1:,1:,1:) !< U COMPONENT. + REAL(R8P), INTENT(IN) :: V(1:,1:,1:) !< V COMPONENT. + REAL(R8P), INTENT(IN) :: W(1:,1:,1:) !< W COMPONENT. + REAL(R8P), INTENT(IN) :: X(1:,1:,1:) !< X COMPONENT. + REAL(R8P), INTENT(IN) :: Y(1:,1:,1:) !< Y COMPONENT. + REAL(R8P), INTENT(IN) :: Z(1:,1:,1:) !< Z COMPONENT. + CHARACTER(LEN=:), ALLOCATABLE :: CODE !< ENCODED BASE64 DATAARRAY. + INTEGER(I1P), ALLOCATABLE :: XYZ(:) !< PACKED DATA. + INTEGER(I4P) :: NN1 !< NUMBER OF ELEMENTS ALONG DIM 1. + INTEGER(I4P) :: NN2 !< NUMBER OF ELEMENTS ALONG DIM 2. + INTEGER(I4P) :: NN3 !< NUMBER OF ELEMENTS ALONG DIM 3. + INTEGER(I4P) :: NN !< NUMBER OF ELEMENTS. + INTEGER(I4P) :: N1 !< COUNTER. + INTEGER(I4P) :: N2 !< COUNTER. + INTEGER(I4P) :: N3 !< COUNTER. + + NN1 = SIZE(X, DIM=1) + NN2 = SIZE(X, DIM=2) + NN3 = SIZE(X, DIM=3) + NN = NN1*NN2*NN3 + CALL PACK_DATA(A1=[INT(6*NN*BYR8P, I4P)], A2=[(((U(N1, N2, N3), V(N1, N2, N3), W(N1, N2, N3), & + X(N1, N2, N3), Y(N1, N2, N3), Z(N1, N2, N3), N1=1, NN1), & + N2=1, NN2), & + N3=1, NN3)], & + PACKED=XYZ) + CALL B64_ENCODE(N=XYZ,CODE=CODE) + ENDFUNCTION ENCODE_BINARY_DATAARRAY6_RANK3_R8P + + FUNCTION ENCODE_BINARY_DATAARRAY6_RANK3_R4P(U, V, W, X, Y, Z) RESULT(CODE) + !< ENCODE (BASE64) A DATAARRAY WITH 6 COMPONENTS OF RANK 3 (R4P). + REAL(R4P), INTENT(IN) :: U(1:,1:,1:) !< U COMPONENT. + REAL(R4P), INTENT(IN) :: V(1:,1:,1:) !< V COMPONENT. + REAL(R4P), INTENT(IN) :: W(1:,1:,1:) !< W COMPONENT. + REAL(R4P), INTENT(IN) :: X(1:,1:,1:) !< X COMPONENT. + REAL(R4P), INTENT(IN) :: Y(1:,1:,1:) !< Y COMPONENT. + REAL(R4P), INTENT(IN) :: Z(1:,1:,1:) !< Z COMPONENT. + CHARACTER(LEN=:), ALLOCATABLE :: CODE !< ENCODED BASE64 DATAARRAY. + INTEGER(I1P), ALLOCATABLE :: XYZ(:) !< PACKED DATA. + INTEGER(I4P) :: NN1 !< NUMBER OF ELEMENTS ALONG DIM 1. + INTEGER(I4P) :: NN2 !< NUMBER OF ELEMENTS ALONG DIM 2. + INTEGER(I4P) :: NN3 !< NUMBER OF ELEMENTS ALONG DIM 3. + INTEGER(I4P) :: NN !< NUMBER OF ELEMENTS. + INTEGER(I4P) :: N1 !< COUNTER. + INTEGER(I4P) :: N2 !< COUNTER. + INTEGER(I4P) :: N3 !< COUNTER. + + NN1 = SIZE(X, DIM=1) + NN2 = SIZE(X, DIM=2) + NN3 = SIZE(X, DIM=3) + NN = NN1*NN2*NN3 + CALL PACK_DATA(A1=[INT(6*NN*BYR4P, I4P)], A2=[(((U(N1, N2, N3), V(N1, N2, N3), W(N1, N2, N3), & + X(N1, N2, N3), Y(N1, N2, N3), Z(N1, N2, N3), N1=1, NN1), & + N2=1, NN2), & + N3=1, NN3)], & + PACKED=XYZ) + CALL B64_ENCODE(N=XYZ,CODE=CODE) + ENDFUNCTION ENCODE_BINARY_DATAARRAY6_RANK3_R4P + + FUNCTION ENCODE_BINARY_DATAARRAY6_RANK3_I8P(U, V, W, X, Y, Z) RESULT(CODE) + !< ENCODE (BASE64) A DATAARRAY WITH 6 COMPONENTS OF RANK 3 (I8P). + INTEGER(I8P), INTENT(IN) :: U(1:,1:,1:) !< U COMPONENT. + INTEGER(I8P), INTENT(IN) :: V(1:,1:,1:) !< V COMPONENT. + INTEGER(I8P), INTENT(IN) :: W(1:,1:,1:) !< W COMPONENT. + INTEGER(I8P), INTENT(IN) :: X(1:,1:,1:) !< X COMPONENT. + INTEGER(I8P), INTENT(IN) :: Y(1:,1:,1:) !< Y COMPONENT. + INTEGER(I8P), INTENT(IN) :: Z(1:,1:,1:) !< Z COMPONENT. + CHARACTER(LEN=:), ALLOCATABLE :: CODE !< ENCODED BASE64 DATAARRAY. + INTEGER(I1P), ALLOCATABLE :: XYZ(:) !< PACKED DATA. + INTEGER(I4P) :: NN1 !< NUMBER OF ELEMENTS ALONG DIM 1. + INTEGER(I4P) :: NN2 !< NUMBER OF ELEMENTS ALONG DIM 2. + INTEGER(I4P) :: NN3 !< NUMBER OF ELEMENTS ALONG DIM 3. + INTEGER(I4P) :: NN !< NUMBER OF ELEMENTS. + INTEGER(I4P) :: N1 !< COUNTER. + INTEGER(I4P) :: N2 !< COUNTER. + INTEGER(I4P) :: N3 !< COUNTER. + + NN1 = SIZE(X, DIM=1) + NN2 = SIZE(X, DIM=2) + NN3 = SIZE(X, DIM=3) + NN = NN1*NN2*NN3 + CALL PACK_DATA(A1=[INT(6*NN*BYI8P, I4P)], A2=[(((U(N1, N2, N3), V(N1, N2, N3), W(N1, N2, N3), & + X(N1, N2, N3), Y(N1, N2, N3), Z(N1, N2, N3), N1=1, NN1), & + N2=1, NN2), & + N3=1, NN3)], & + PACKED=XYZ) + CALL B64_ENCODE(N=XYZ,CODE=CODE) + ENDFUNCTION ENCODE_BINARY_DATAARRAY6_RANK3_I8P + + FUNCTION ENCODE_BINARY_DATAARRAY6_RANK3_I4P(U, V, W, X, Y, Z) RESULT(CODE) + !< ENCODE (BASE64) A DATAARRAY WITH 6 COMPONENTS OF RANK 3 (I4P). + INTEGER(I4P), INTENT(IN) :: U(1:,1:,1:) !< U COMPONENT. + INTEGER(I4P), INTENT(IN) :: V(1:,1:,1:) !< V COMPONENT. + INTEGER(I4P), INTENT(IN) :: W(1:,1:,1:) !< W COMPONENT. + INTEGER(I4P), INTENT(IN) :: X(1:,1:,1:) !< X COMPONENT. + INTEGER(I4P), INTENT(IN) :: Y(1:,1:,1:) !< Y COMPONENT. + INTEGER(I4P), INTENT(IN) :: Z(1:,1:,1:) !< Z COMPONENT. + CHARACTER(LEN=:), ALLOCATABLE :: CODE !< ENCODED BASE64 DATAARRAY. + INTEGER(I1P), ALLOCATABLE :: XYZ(:) !< PACKED DATA. + INTEGER(I4P) :: NN1 !< NUMBER OF ELEMENTS ALONG DIM 1. + INTEGER(I4P) :: NN2 !< NUMBER OF ELEMENTS ALONG DIM 2. + INTEGER(I4P) :: NN3 !< NUMBER OF ELEMENTS ALONG DIM 3. + INTEGER(I4P) :: NN !< NUMBER OF ELEMENTS. + INTEGER(I4P) :: N1 !< COUNTER. + INTEGER(I4P) :: N2 !< COUNTER. + INTEGER(I4P) :: N3 !< COUNTER. + + NN1 = SIZE(X, DIM=1) + NN2 = SIZE(X, DIM=2) + NN3 = SIZE(X, DIM=3) + NN = NN1*NN2*NN3 + XYZ = TRANSFER([INT(6*NN*BYI4P, I4P), [(((U(N1, N2, N3), V(N1, N2, N3), W(N1, N2, N3), & + X(N1, N2, N3), Y(N1, N2, N3), Z(N1, N2, N3), N1=1, NN1), & + N2=1, NN2), & + N3=1, NN3)]], XYZ) + CALL B64_ENCODE(N=XYZ,CODE=CODE) + ENDFUNCTION ENCODE_BINARY_DATAARRAY6_RANK3_I4P + + FUNCTION ENCODE_BINARY_DATAARRAY6_RANK3_I2P(U, V, W, X, Y, Z) RESULT(CODE) + !< ENCODE (BASE64) A DATAARRAY WITH 6 COMPONENTS OF RANK 3 (I2P). + INTEGER(I2P), INTENT(IN) :: U(1:,1:,1:) !< U COMPONENT. + INTEGER(I2P), INTENT(IN) :: V(1:,1:,1:) !< V COMPONENT. + INTEGER(I2P), INTENT(IN) :: W(1:,1:,1:) !< W COMPONENT. + INTEGER(I2P), INTENT(IN) :: X(1:,1:,1:) !< X COMPONENT. + INTEGER(I2P), INTENT(IN) :: Y(1:,1:,1:) !< Y COMPONENT. + INTEGER(I2P), INTENT(IN) :: Z(1:,1:,1:) !< Z COMPONENT. + CHARACTER(LEN=:), ALLOCATABLE :: CODE !< ENCODED BASE64 DATAARRAY. + INTEGER(I1P), ALLOCATABLE :: XYZ(:) !< PACKED DATA. + INTEGER(I4P) :: NN1 !< NUMBER OF ELEMENTS ALONG DIM 1. + INTEGER(I4P) :: NN2 !< NUMBER OF ELEMENTS ALONG DIM 2. + INTEGER(I4P) :: NN3 !< NUMBER OF ELEMENTS ALONG DIM 3. + INTEGER(I4P) :: NN !< NUMBER OF ELEMENTS. + INTEGER(I4P) :: N1 !< COUNTER. + INTEGER(I4P) :: N2 !< COUNTER. + INTEGER(I4P) :: N3 !< COUNTER. + + NN1 = SIZE(X, DIM=1) + NN2 = SIZE(X, DIM=2) + NN3 = SIZE(X, DIM=3) + NN = NN1*NN2*NN3 + CALL PACK_DATA(A1=[INT(6*NN*BYI2P, I4P)], A2=[(((U(N1, N2, N3), V(N1, N2, N3), W(N1, N2, N3), & + X(N1, N2, N3), Y(N1, N2, N3), Z(N1, N2, N3), N1=1, NN1), & + N2=1, NN2), & + N3=1, NN3)], & + PACKED=XYZ) + CALL B64_ENCODE(N=XYZ,CODE=CODE) + ENDFUNCTION ENCODE_BINARY_DATAARRAY6_RANK3_I2P + + FUNCTION ENCODE_BINARY_DATAARRAY6_RANK3_I1P(U, V, W, X, Y, Z) RESULT(CODE) + !< ENCODE (BASE64) A DATAARRAY WITH 6 COMPONENTS OF RANK 3 (I1P). + INTEGER(I1P), INTENT(IN) :: U(1:,1:,1:) !< U COMPONENT. + INTEGER(I1P), INTENT(IN) :: V(1:,1:,1:) !< V COMPONENT. + INTEGER(I1P), INTENT(IN) :: W(1:,1:,1:) !< W COMPONENT. + INTEGER(I1P), INTENT(IN) :: X(1:,1:,1:) !< X COMPONENT. + INTEGER(I1P), INTENT(IN) :: Y(1:,1:,1:) !< Y COMPONENT. + INTEGER(I1P), INTENT(IN) :: Z(1:,1:,1:) !< Z COMPONENT. + CHARACTER(LEN=:), ALLOCATABLE :: CODE !< ENCODED BASE64 DATAARRAY. + INTEGER(I1P), ALLOCATABLE :: XYZ(:) !< PACKED DATA. + INTEGER(I4P) :: NN1 !< NUMBER OF ELEMENTS ALONG DIM 1. + INTEGER(I4P) :: NN2 !< NUMBER OF ELEMENTS ALONG DIM 2. + INTEGER(I4P) :: NN3 !< NUMBER OF ELEMENTS ALONG DIM 3. + INTEGER(I4P) :: NN !< NUMBER OF ELEMENTS. + INTEGER(I4P) :: N1 !< COUNTER. + INTEGER(I4P) :: N2 !< COUNTER. + INTEGER(I4P) :: N3 !< COUNTER. + + NN1 = SIZE(X, DIM=1) + NN2 = SIZE(X, DIM=2) + NN3 = SIZE(X, DIM=3) + NN = NN1*NN2*NN3 + CALL PACK_DATA(A1=[INT(6*NN*BYI1P, I4P)], A2=[(((U(N1, N2, N3), V(N1, N2, N3), W(N1, N2, N3), & + X(N1, N2, N3), Y(N1, N2, N3), Z(N1, N2, N3), N1=1, NN1), & + N2=1, NN2), & + N3=1, NN3)], & + PACKED=XYZ) + CALL B64_ENCODE(N=XYZ,CODE=CODE) + ENDFUNCTION ENCODE_BINARY_DATAARRAY6_RANK3_I1P +ENDMODULE VTK_FORTRAN_DATAARRAY_ENCODER + + + +!< VTK FILE XML WRITER, ASCII LOCAL. +MODULE VTKF_FILE_XML_WRITER_ASCII_LOCAL +!< VTK FILE XML WRITER, ASCII LOCAL. +USE PENF +USE STRINGIFOR +USE VTK_FORTRAN_DATAARRAY_ENCODER +USE VTKF_FILE_XML_WRITER_ABSTRACT + +IMPLICIT NONE +PRIVATE +PUBLIC :: XML_WRITER_ASCII_LOCAL + +TYPE, EXTENDS(XML_WRITER_ABSTRACT) :: XML_WRITER_ASCII_LOCAL + !< VTK FILE XML WRITER, ASCII LOCAL. + CONTAINS + ! DEFERRED METHODS + PROCEDURE, PASS(SELF) :: INITIALIZE !< INITIALIZE WRITER. + PROCEDURE, PASS(SELF) :: FINALIZE !< FINALIZE WRITER. + PROCEDURE, PASS(SELF) :: W_DATA1_RANK1_R8P !< WRITE DATAARRAY 1, RANK 1, R8P. + PROCEDURE, PASS(SELF) :: W_DATA1_RANK1_R4P !< WRITE DATAARRAY 1, RANK 1, R4P. + PROCEDURE, PASS(SELF) :: W_DATA1_RANK1_I8P !< WRITE DATAARRAY 1, RANK 1, I8P. + PROCEDURE, PASS(SELF) :: W_DATA1_RANK1_I4P !< WRITE DATAARRAY 1, RANK 1, I4P. + PROCEDURE, PASS(SELF) :: W_DATA1_RANK1_I2P !< WRITE DATAARRAY 1, RANK 1, I2P. + PROCEDURE, PASS(SELF) :: W_DATA1_RANK1_I1P !< WRITE DATAARRAY 1, RANK 1, I1P. + PROCEDURE, PASS(SELF) :: W_DATA1_RANK2_R8P !< WRITE DATAARRAY 1, RANK 2, R8P. + PROCEDURE, PASS(SELF) :: W_DATA1_RANK2_R4P !< WRITE DATAARRAY 1, RANK 2, R4P. + PROCEDURE, PASS(SELF) :: W_DATA1_RANK2_I8P !< WRITE DATAARRAY 1, RANK 2, I8P. + PROCEDURE, PASS(SELF) :: W_DATA1_RANK2_I4P !< WRITE DATAARRAY 1, RANK 2, I4P. + PROCEDURE, PASS(SELF) :: W_DATA1_RANK2_I2P !< WRITE DATAARRAY 1, RANK 2, I2P. + PROCEDURE, PASS(SELF) :: W_DATA1_RANK2_I1P !< WRITE DATAARRAY 1, RANK 2, I1P. + PROCEDURE, PASS(SELF) :: W_DATA1_RANK3_R8P !< WRITE DATAARRAY 1, RANK 3, R8P. + PROCEDURE, PASS(SELF) :: W_DATA1_RANK3_R4P !< WRITE DATAARRAY 1, RANK 3, R4P. + PROCEDURE, PASS(SELF) :: W_DATA1_RANK3_I8P !< WRITE DATAARRAY 1, RANK 3, I8P. + PROCEDURE, PASS(SELF) :: W_DATA1_RANK3_I4P !< WRITE DATAARRAY 1, RANK 3, I4P. + PROCEDURE, PASS(SELF) :: W_DATA1_RANK3_I2P !< WRITE DATAARRAY 1, RANK 3, I2P. + PROCEDURE, PASS(SELF) :: W_DATA1_RANK3_I1P !< WRITE DATAARRAY 1, RANK 3, I1P. + PROCEDURE, PASS(SELF) :: W_DATA1_RANK4_R8P !< WRITE DATAARRAY 1, RANK 4, R8P. + PROCEDURE, PASS(SELF) :: W_DATA1_RANK4_R4P !< WRITE DATAARRAY 1, RANK 4, R4P. + PROCEDURE, PASS(SELF) :: W_DATA1_RANK4_I8P !< WRITE DATAARRAY 1, RANK 4, I8P. + PROCEDURE, PASS(SELF) :: W_DATA1_RANK4_I4P !< WRITE DATAARRAY 1, RANK 4, I4P. + PROCEDURE, PASS(SELF) :: W_DATA1_RANK4_I2P !< WRITE DATAARRAY 1, RANK 4, I2P. + PROCEDURE, PASS(SELF) :: W_DATA1_RANK4_I1P !< WRITE DATAARRAY 1, RANK 4, I1P. + PROCEDURE, PASS(SELF) :: W_DATA3_RANK1_R8P !< WRITE DATAARRAY 3, RANK 1, R8P. + PROCEDURE, PASS(SELF) :: W_DATA3_RANK1_R4P !< WRITE DATAARRAY 3, RANK 1, R4P. + PROCEDURE, PASS(SELF) :: W_DATA3_RANK1_I8P !< WRITE DATAARRAY 3, RANK 1, I8P. + PROCEDURE, PASS(SELF) :: W_DATA3_RANK1_I4P !< WRITE DATAARRAY 3, RANK 1, I4P. + PROCEDURE, PASS(SELF) :: W_DATA3_RANK1_I2P !< WRITE DATAARRAY 3, RANK 1, I2P. + PROCEDURE, PASS(SELF) :: W_DATA3_RANK1_I1P !< WRITE DATAARRAY 3, RANK 1, I1P. + PROCEDURE, PASS(SELF) :: W_DATA3_RANK3_R8P !< WRITE DATAARRAY 3, RANK 3, R8P. + PROCEDURE, PASS(SELF) :: W_DATA3_RANK3_R4P !< WRITE DATAARRAY 3, RANK 3, R4P. + PROCEDURE, PASS(SELF) :: W_DATA3_RANK3_I8P !< WRITE DATAARRAY 3, RANK 3, I8P. + PROCEDURE, PASS(SELF) :: W_DATA3_RANK3_I4P !< WRITE DATAARRAY 3, RANK 3, I4P. + PROCEDURE, PASS(SELF) :: W_DATA3_RANK3_I2P !< WRITE DATAARRAY 3, RANK 3, I2P. + PROCEDURE, PASS(SELF) :: W_DATA3_RANK3_I1P !< WRITE DATAARRAY 3, RANK 3, I1P. + PROCEDURE, PASS(SELF) :: W_DATA6_RANK1_R8P !< WRITE DATAARRAY 6, RANK 1, R8P. + PROCEDURE, PASS(SELF) :: W_DATA6_RANK1_R4P !< WRITE DATAARRAY 6, RANK 1, R4P. + PROCEDURE, PASS(SELF) :: W_DATA6_RANK1_I8P !< WRITE DATAARRAY 6, RANK 1, I8P. + PROCEDURE, PASS(SELF) :: W_DATA6_RANK1_I4P !< WRITE DATAARRAY 6, RANK 1, I4P. + PROCEDURE, PASS(SELF) :: W_DATA6_RANK1_I2P !< WRITE DATAARRAY 6, RANK 1, I2P. + PROCEDURE, PASS(SELF) :: W_DATA6_RANK1_I1P !< WRITE DATAARRAY 6, RANK 1, I1P. + PROCEDURE, PASS(SELF) :: W_DATA6_RANK3_R8P !< WRITE DATAARRAY 6, RANK 3, R8P. + PROCEDURE, PASS(SELF) :: W_DATA6_RANK3_R4P !< WRITE DATAARRAY 6, RANK 3, R4P. + PROCEDURE, PASS(SELF) :: W_DATA6_RANK3_I8P !< WRITE DATAARRAY 6, RANK 3, I8P. + PROCEDURE, PASS(SELF) :: W_DATA6_RANK3_I4P !< WRITE DATAARRAY 6, RANK 3, I4P. + PROCEDURE, PASS(SELF) :: W_DATA6_RANK3_I2P !< WRITE DATAARRAY 6, RANK 3, I2P. + PROCEDURE, PASS(SELF) :: W_DATA6_RANK3_I1P !< WRITE DATAARRAY 6, RANK 3, I1P. + PROCEDURE, PASS(SELF) :: W_DATA_APPENDED !< WRITE APPENDED. +ENDTYPE XML_WRITER_ASCII_LOCAL +CONTAINS + FUNCTION INITIALIZE(SELF, FORMAT, FILENAME, MESH_TOPOLOGY, NX1, NX2, NY1, NY2, NZ1, NZ2, & + IS_VOLATILE, MESH_KIND) RESULT(ERROR) + !< INITIALIZE WRITER. + CLASS(XML_WRITER_ASCII_LOCAL), INTENT(INOUT) :: SELF !< WRITER. + CHARACTER(*), INTENT(IN) :: FORMAT !< FILE FORMAT: ASCII. + CHARACTER(*), INTENT(IN) :: FILENAME !< FILE NAME. + CHARACTER(*), INTENT(IN) :: MESH_TOPOLOGY !< MESH TOPOLOGY. + INTEGER(I4P), INTENT(IN), OPTIONAL :: NX1 !< INITIAL NODE OF X AXIS. + INTEGER(I4P), INTENT(IN), OPTIONAL :: NX2 !< FINAL NODE OF X AXIS. + INTEGER(I4P), INTENT(IN), OPTIONAL :: NY1 !< INITIAL NODE OF Y AXIS. + INTEGER(I4P), INTENT(IN), OPTIONAL :: NY2 !< FINAL NODE OF Y AXIS. + INTEGER(I4P), INTENT(IN), OPTIONAL :: NZ1 !< INITIAL NODE OF Z AXIS. + INTEGER(I4P), INTENT(IN), OPTIONAL :: NZ2 !< FINAL NODE OF Z AXIS. + CHARACTER(*), INTENT(IN), OPTIONAL :: MESH_KIND !< KIND OF MESH DATA: FLOAT64, FLOAT32, ECC. + LOGICAL, INTENT(IN), OPTIONAL :: IS_VOLATILE !< FLAG TO CHECK VOLATILE WRITER. + INTEGER(I4P) :: ERROR !< ERROR STATUS. + + SELF%TOPOLOGY = TRIM(ADJUSTL(MESH_TOPOLOGY)) + SELF%FORMAT_CH = FORMAT + SELF%FORMAT_CH = SELF%FORMAT_CH%LOWER() + CALL SELF%OPEN_XML_FILE(FILENAME=FILENAME) + CALL SELF%WRITE_HEADER_TAG + CALL SELF%WRITE_TOPOLOGY_TAG(NX1=NX1, NX2=NX2, NY1=NY1, NY2=NY2, NZ1=NZ1, NZ2=NZ2, MESH_KIND=MESH_KIND) + ERROR = SELF%ERROR + ENDFUNCTION INITIALIZE + + FUNCTION FINALIZE(SELF) RESULT(ERROR) + !< FINALIZE WRITER. + CLASS(XML_WRITER_ASCII_LOCAL), INTENT(INOUT) :: SELF !< WRITER. + INTEGER(I4P) :: ERROR !< ERROR STATUS. + + CALL SELF%WRITE_END_TAG(NAME=SELF%TOPOLOGY%CHARS()) + CALL SELF%WRITE_END_TAG(NAME='VTKFile') + CALL SELF%CLOSE_XML_FILE + ERROR = SELF%ERROR + ENDFUNCTION FINALIZE + + ! W_DATA METHODS + FUNCTION W_DATA1_RANK1_R8P(SELF, DATA_NAME, X, IS_TUPLES) RESULT(ERROR) + !< WRITE `<DATAARRAY... NumberOfComponents="1"...>...</DATAARRAY>` TAG (R8P). + CLASS(XML_WRITER_ASCII_LOCAL), INTENT(INOUT) :: SELF !< WRITER. + CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. + REAL(R8P), INTENT(IN) :: X(1:) !< DATA VARIABLE. + LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". + INTEGER(I4P) :: ERROR !< ERROR STATUS. + CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. + INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. + CHARACTER(LEN=:), ALLOCATABLE :: CODE !< DATA VARIABLE ENCODED, ASCII OR BASE64 CODEC. + + DATA_TYPE = 'Float64' + N_COMPONENTS = 1 + CODE = ENCODE_ASCII_DATAARRAY(X=X) + CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, & + IS_TUPLES=IS_TUPLES) + ERROR = SELF%ERROR + ENDFUNCTION W_DATA1_RANK1_R8P + + FUNCTION W_DATA1_RANK1_R4P(SELF, DATA_NAME, X, IS_TUPLES) RESULT(ERROR) + !< WRITE `<DATAARRAY... NumberOfComponents="1"...>...</DATAARRAY>` TAG (R4P). + CLASS(XML_WRITER_ASCII_LOCAL), INTENT(INOUT) :: SELF !< WRITER. + CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. + REAL(R4P), INTENT(IN) :: X(1:) !< DATA VARIABLE. + LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". + INTEGER(I4P) :: ERROR !< ERROR STATUS. + CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. + INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. + CHARACTER(LEN=:), ALLOCATABLE :: CODE !< DATA VARIABLE ENCODED, ASCII OR BASE64 CODEC. + + DATA_TYPE = 'Float32' + N_COMPONENTS = 1 + CODE = ENCODE_ASCII_DATAARRAY(X=X) + CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, & + IS_TUPLES=IS_TUPLES) + ERROR = SELF%ERROR + ENDFUNCTION W_DATA1_RANK1_R4P + + FUNCTION W_DATA1_RANK1_I8P(SELF, DATA_NAME, X, IS_TUPLES) RESULT(ERROR) + !< WRITE `<DATAARRAY... NumberOfComponents="1"...>...</DATAARRAY>` TAG (I8P). + CLASS(XML_WRITER_ASCII_LOCAL), INTENT(INOUT) :: SELF !< WRITER. + CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. + INTEGER(I8P), INTENT(IN) :: X(1:) !< DATA VARIABLE. + LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". + INTEGER(I4P) :: ERROR !< ERROR STATUS. + CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. + INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. + CHARACTER(LEN=:), ALLOCATABLE :: CODE !< DATA VARIABLE ENCODED, ASCII OR BASE64 CODEC. + + DATA_TYPE = 'Int64' + N_COMPONENTS = 1 + CODE = ENCODE_ASCII_DATAARRAY(X=X) + CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, & + IS_TUPLES=IS_TUPLES) + ERROR = SELF%ERROR + ENDFUNCTION W_DATA1_RANK1_I8P + + FUNCTION W_DATA1_RANK1_I4P(SELF, DATA_NAME, X, IS_TUPLES) RESULT(ERROR) + !< WRITE `<DATAARRAY... NumberOfComponents="1"...>...</DATAARRAY>` TAG (I4P). + CLASS(XML_WRITER_ASCII_LOCAL), INTENT(INOUT) :: SELF !< WRITER. + CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. + INTEGER(I4P), INTENT(IN) :: X(1:) !< DATA VARIABLE. + LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". + INTEGER(I4P) :: ERROR !< ERROR STATUS. + CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. + INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. + CHARACTER(LEN=:), ALLOCATABLE :: CODE !< DATA VARIABLE ENCODED, ASCII OR BASE64 CODEC. + + DATA_TYPE = 'Int32' + N_COMPONENTS = 1 + CODE = ENCODE_ASCII_DATAARRAY(X=X) + CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, & + IS_TUPLES=IS_TUPLES) + ERROR = SELF%ERROR + ENDFUNCTION W_DATA1_RANK1_I4P + + FUNCTION W_DATA1_RANK1_I2P(SELF, DATA_NAME, X, IS_TUPLES) RESULT(ERROR) + !< WRITE `<DATAARRAY... NumberOfComponents="1"...>...</DATAARRAY>` TAG (I2P). + CLASS(XML_WRITER_ASCII_LOCAL), INTENT(INOUT) :: SELF !< WRITER. + CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. + INTEGER(I2P), INTENT(IN) :: X(1:) !< DATA VARIABLE. + LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". + INTEGER(I4P) :: ERROR !< ERROR STATUS. + CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. + INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. + CHARACTER(LEN=:), ALLOCATABLE :: CODE !< DATA VARIABLE ENCODED, ASCII OR BASE64 CODEC. + + DATA_TYPE = 'Int16' + N_COMPONENTS = 1 + CODE = ENCODE_ASCII_DATAARRAY(X=X) + CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, & + IS_TUPLES=IS_TUPLES) + ERROR = SELF%ERROR + ENDFUNCTION W_DATA1_RANK1_I2P + + FUNCTION W_DATA1_RANK1_I1P(SELF, DATA_NAME, X, IS_TUPLES) RESULT(ERROR) + !< WRITE `<DATAARRAY... NumberOfComponents="1"...>...</DATAARRAY>` TAG (I1P). + CLASS(XML_WRITER_ASCII_LOCAL), INTENT(INOUT) :: SELF !< WRITER. + CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. + INTEGER(I1P), INTENT(IN) :: X(1:) !< DATA VARIABLE. + LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". + INTEGER(I4P) :: ERROR !< ERROR STATUS. + CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. + INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. + CHARACTER(LEN=:), ALLOCATABLE :: CODE !< DATA VARIABLE ENCODED, ASCII OR BASE64 CODEC. + + DATA_TYPE = 'Int8' + N_COMPONENTS = 1 + CODE = ENCODE_ASCII_DATAARRAY(X=X) + CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, & + IS_TUPLES=IS_TUPLES) + ERROR = SELF%ERROR + ENDFUNCTION W_DATA1_RANK1_I1P + + FUNCTION W_DATA1_RANK2_R8P(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR) + !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (R8P). + CLASS(XML_WRITER_ASCII_LOCAL), INTENT(INOUT) :: SELF !< WRITER. + CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. + REAL(R8P), INTENT(IN) :: X(1:,1:) !< DATA VARIABLE. + LOGICAL, INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT. + LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". + INTEGER(I4P) :: ERROR !< ERROR STATUS. + CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. + INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. + CHARACTER(LEN=:), ALLOCATABLE :: CODE !< DATA VARIABLE ENCODED, ASCII OR BASE64 CODEC. + + DATA_TYPE = 'Float64' + N_COMPONENTS = SIZE(X, DIM=1) + IF (PRESENT(ONE_COMPONENT)) THEN + IF (ONE_COMPONENT) N_COMPONENTS = 1 + ENDIF + CODE = ENCODE_ASCII_DATAARRAY(X=X) + CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, & + IS_TUPLES=IS_TUPLES) + ERROR = SELF%ERROR + ENDFUNCTION W_DATA1_RANK2_R8P + + FUNCTION W_DATA1_RANK2_R4P(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR) + !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (R4P). + CLASS(XML_WRITER_ASCII_LOCAL), INTENT(INOUT) :: SELF !< WRITER. + CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. + REAL(R4P), INTENT(IN) :: X(1:,1:) !< DATA VARIABLE. + LOGICAL, INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT. + LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". + INTEGER(I4P) :: ERROR !< ERROR STATUS. + CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. + INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. + CHARACTER(LEN=:), ALLOCATABLE :: CODE !< DATA VARIABLE ENCODED, ASCII OR BASE64 CODEC. + + DATA_TYPE = 'Float32' + N_COMPONENTS = SIZE(X, DIM=1) + IF (PRESENT(ONE_COMPONENT)) THEN + IF (ONE_COMPONENT) N_COMPONENTS = 1 + ENDIF + CODE = ENCODE_ASCII_DATAARRAY(X=X) + CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, & + IS_TUPLES=IS_TUPLES) + ERROR = SELF%ERROR + ENDFUNCTION W_DATA1_RANK2_R4P + + FUNCTION W_DATA1_RANK2_I8P(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR) + !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (I8P). + CLASS(XML_WRITER_ASCII_LOCAL), INTENT(INOUT) :: SELF !< WRITER. + CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. + INTEGER(I8P), INTENT(IN) :: X(1:,1:) !< DATA VARIABLE. + LOGICAL, INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT. + LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". + INTEGER(I4P) :: ERROR !< ERROR STATUS. + CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. + INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. + CHARACTER(LEN=:), ALLOCATABLE :: CODE !< DATA VARIABLE ENCODED, ASCII OR BASE64 CODEC. + + DATA_TYPE = 'Int64' + N_COMPONENTS = SIZE(X, DIM=1) + IF (PRESENT(ONE_COMPONENT)) THEN + IF (ONE_COMPONENT) N_COMPONENTS = 1 + ENDIF + CODE = ENCODE_ASCII_DATAARRAY(X=X) + CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, & + IS_TUPLES=IS_TUPLES) + ERROR = SELF%ERROR + ENDFUNCTION W_DATA1_RANK2_I8P + + FUNCTION W_DATA1_RANK2_I4P(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR) + !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (I4P). + CLASS(XML_WRITER_ASCII_LOCAL), INTENT(INOUT) :: SELF !< WRITER. + CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. + INTEGER(I4P), INTENT(IN) :: X(1:,1:) !< DATA VARIABLE. + LOGICAL, INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT. + LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". + INTEGER(I4P) :: ERROR !< ERROR STATUS. + CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. + INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. + CHARACTER(LEN=:), ALLOCATABLE :: CODE !< DATA VARIABLE ENCODED, ASCII OR BASE64 CODEC. + + DATA_TYPE = 'Int32' + N_COMPONENTS = SIZE(X, DIM=1) + IF (PRESENT(ONE_COMPONENT)) THEN + IF (ONE_COMPONENT) N_COMPONENTS = 1 + ENDIF + CODE = ENCODE_ASCII_DATAARRAY(X=X) + CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, & + IS_TUPLES=IS_TUPLES) + ERROR = SELF%ERROR + ENDFUNCTION W_DATA1_RANK2_I4P + + FUNCTION W_DATA1_RANK2_I2P(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR) + !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (I2P). + CLASS(XML_WRITER_ASCII_LOCAL), INTENT(INOUT) :: SELF !< WRITER. + CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. + INTEGER(I2P), INTENT(IN) :: X(1:,1:) !< DATA VARIABLE. + LOGICAL, INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT. + LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". + INTEGER(I4P) :: ERROR !< ERROR STATUS. + CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. + INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. + CHARACTER(LEN=:), ALLOCATABLE :: CODE !< DATA VARIABLE ENCODED, ASCII OR BASE64 CODEC. + + DATA_TYPE = 'Int16' + N_COMPONENTS = SIZE(X, DIM=1) + IF (PRESENT(ONE_COMPONENT)) THEN + IF (ONE_COMPONENT) N_COMPONENTS = 1 + ENDIF + CODE = ENCODE_ASCII_DATAARRAY(X=X) + CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, & + IS_TUPLES=IS_TUPLES) + ERROR = SELF%ERROR + ENDFUNCTION W_DATA1_RANK2_I2P + + FUNCTION W_DATA1_RANK2_I1P(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR) + !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (I1P). + CLASS(XML_WRITER_ASCII_LOCAL), INTENT(INOUT) :: SELF !< WRITER. + CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. + INTEGER(I1P), INTENT(IN) :: X(1:,1:) !< DATA VARIABLE. + LOGICAL, INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT. + LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". + INTEGER(I4P) :: ERROR !< ERROR STATUS. + CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. + INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. + CHARACTER(LEN=:), ALLOCATABLE :: CODE !< DATA VARIABLE ENCODED, ASCII OR BASE64 CODEC. + + DATA_TYPE = 'Int8' + N_COMPONENTS = SIZE(X, DIM=1) + IF (PRESENT(ONE_COMPONENT)) THEN + IF (ONE_COMPONENT) N_COMPONENTS = 1 + ENDIF + CODE = ENCODE_ASCII_DATAARRAY(X=X) + CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, & + IS_TUPLES=IS_TUPLES) + ERROR = SELF%ERROR + ENDFUNCTION W_DATA1_RANK2_I1P + + FUNCTION W_DATA1_RANK3_R8P(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR) + !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (R8P). + CLASS(XML_WRITER_ASCII_LOCAL), INTENT(INOUT) :: SELF !< WRITER. + CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. + REAL(R8P), INTENT(IN) :: X(1:,1:,1:) !< DATA VARIABLE. + LOGICAL, INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT. + LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". + INTEGER(I4P) :: ERROR !< ERROR STATUS. + CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. + INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. + CHARACTER(LEN=:), ALLOCATABLE :: CODE !< DATA VARIABLE ENCODED, ASCII OR BASE64 CODEC. + + DATA_TYPE = 'Float64' + N_COMPONENTS = SIZE(X, DIM=1) + IF (PRESENT(ONE_COMPONENT)) THEN + IF (ONE_COMPONENT) N_COMPONENTS = 1 + ENDIF + CODE = ENCODE_ASCII_DATAARRAY(X=X) + CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, & + IS_TUPLES=IS_TUPLES) + ERROR = SELF%ERROR + ENDFUNCTION W_DATA1_RANK3_R8P + + FUNCTION W_DATA1_RANK3_R4P(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR) + !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (R4P). + CLASS(XML_WRITER_ASCII_LOCAL), INTENT(INOUT) :: SELF !< WRITER. + CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. + REAL(R4P), INTENT(IN) :: X(1:,1:,1:) !< DATA VARIABLE. + LOGICAL, INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT. + LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". + INTEGER(I4P) :: ERROR !< ERROR STATUS. + CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. + INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. + CHARACTER(LEN=:), ALLOCATABLE :: CODE !< DATA VARIABLE ENCODED, ASCII OR BASE64 CODEC. + + DATA_TYPE = 'Float32' + N_COMPONENTS = SIZE(X, DIM=1) + IF (PRESENT(ONE_COMPONENT)) THEN + IF (ONE_COMPONENT) N_COMPONENTS = 1 + ENDIF + CODE = ENCODE_ASCII_DATAARRAY(X=X) + CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, & + IS_TUPLES=IS_TUPLES) + ERROR = SELF%ERROR + ENDFUNCTION W_DATA1_RANK3_R4P + + FUNCTION W_DATA1_RANK3_I8P(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR) + !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (I8P). + CLASS(XML_WRITER_ASCII_LOCAL), INTENT(INOUT) :: SELF !< WRITER. + CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. + INTEGER(I8P), INTENT(IN) :: X(1:,1:,1:) !< DATA VARIABLE. + LOGICAL, INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT. + LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". + INTEGER(I4P) :: ERROR !< ERROR STATUS. + CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. + INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. + CHARACTER(LEN=:), ALLOCATABLE :: CODE !< DATA VARIABLE ENCODED, ASCII OR BASE64 CODEC. + + DATA_TYPE = 'Int64' + N_COMPONENTS = SIZE(X, DIM=1) + IF (PRESENT(ONE_COMPONENT)) THEN + IF (ONE_COMPONENT) N_COMPONENTS = 1 + ENDIF + CODE = ENCODE_ASCII_DATAARRAY(X=X) + CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, & + IS_TUPLES=IS_TUPLES) + ERROR = SELF%ERROR + ENDFUNCTION W_DATA1_RANK3_I8P + + FUNCTION W_DATA1_RANK3_I4P(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR) + !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (I4P). + CLASS(XML_WRITER_ASCII_LOCAL), INTENT(INOUT) :: SELF !< WRITER. + CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. + INTEGER(I4P), INTENT(IN) :: X(1:,1:,1:) !< DATA VARIABLE. + LOGICAL, INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT. + LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". + INTEGER(I4P) :: ERROR !< ERROR STATUS. + CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. + INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. + CHARACTER(LEN=:), ALLOCATABLE :: CODE !< DATA VARIABLE ENCODED, ASCII OR BASE64 CODEC. + + DATA_TYPE = 'Int32' + N_COMPONENTS = SIZE(X, DIM=1) + IF (PRESENT(ONE_COMPONENT)) THEN + IF (ONE_COMPONENT) N_COMPONENTS = 1 + ENDIF + CODE = ENCODE_ASCII_DATAARRAY(X=X) + CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, & + IS_TUPLES=IS_TUPLES) + ERROR = SELF%ERROR + ENDFUNCTION W_DATA1_RANK3_I4P + + FUNCTION W_DATA1_RANK3_I2P(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR) + !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (I2P). + CLASS(XML_WRITER_ASCII_LOCAL), INTENT(INOUT) :: SELF !< WRITER. + CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. + INTEGER(I2P), INTENT(IN) :: X(1:,1:,1:) !< DATA VARIABLE. + LOGICAL, INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT. + LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". + INTEGER(I4P) :: ERROR !< ERROR STATUS. + CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. + INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. + CHARACTER(LEN=:), ALLOCATABLE :: CODE !< DATA VARIABLE ENCODED, ASCII OR BASE64 CODEC. + + DATA_TYPE = 'Int16' + N_COMPONENTS = SIZE(X, DIM=1) + IF (PRESENT(ONE_COMPONENT)) THEN + IF (ONE_COMPONENT) N_COMPONENTS = 1 + ENDIF + CODE = ENCODE_ASCII_DATAARRAY(X=X) + CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, & + IS_TUPLES=IS_TUPLES) + ERROR = SELF%ERROR + ENDFUNCTION W_DATA1_RANK3_I2P + + FUNCTION W_DATA1_RANK3_I1P(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR) + !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (I1P). + CLASS(XML_WRITER_ASCII_LOCAL), INTENT(INOUT) :: SELF !< WRITER. + CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. + INTEGER(I1P), INTENT(IN) :: X(1:,1:,1:) !< DATA VARIABLE. + LOGICAL, INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT. + LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". + INTEGER(I4P) :: ERROR !< ERROR STATUS. + CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. + INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. + CHARACTER(LEN=:), ALLOCATABLE :: CODE !< DATA VARIABLE ENCODED, ASCII OR BASE64 CODEC. + + DATA_TYPE = 'Int8' + N_COMPONENTS = SIZE(X, DIM=1) + IF (PRESENT(ONE_COMPONENT)) THEN + IF (ONE_COMPONENT) N_COMPONENTS = 1 + ENDIF + CODE = ENCODE_ASCII_DATAARRAY(X=X) + CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, & + IS_TUPLES=IS_TUPLES) + ERROR = SELF%ERROR + ENDFUNCTION W_DATA1_RANK3_I1P + + FUNCTION W_DATA1_RANK4_R8P(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR) + !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (R8P). + CLASS(XML_WRITER_ASCII_LOCAL), INTENT(INOUT) :: SELF !< WRITER. + CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. + REAL(R8P), INTENT(IN) :: X(1:,1:,1:,1:) !< DATA VARIABLE. + LOGICAL, INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT. + LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". + INTEGER(I4P) :: ERROR !< ERROR STATUS. + CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. + INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. + CHARACTER(LEN=:), ALLOCATABLE :: CODE !< DATA VARIABLE ENCODED, ASCII OR BASE64 CODEC. + + DATA_TYPE = 'Float64' + N_COMPONENTS = SIZE(X, DIM=1) + IF (PRESENT(ONE_COMPONENT)) THEN + IF (ONE_COMPONENT) N_COMPONENTS = 1 + ENDIF + CODE = ENCODE_ASCII_DATAARRAY(X=X) + CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, & + IS_TUPLES=IS_TUPLES) + ERROR = SELF%ERROR + ENDFUNCTION W_DATA1_RANK4_R8P + + FUNCTION W_DATA1_RANK4_R4P(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR) + !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (R4P). + CLASS(XML_WRITER_ASCII_LOCAL), INTENT(INOUT) :: SELF !< WRITER. + CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. + REAL(R4P), INTENT(IN) :: X(1:,1:,1:,1:) !< DATA VARIABLE. + LOGICAL, INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT. + LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". + INTEGER(I4P) :: ERROR !< ERROR STATUS. + CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. + INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. + CHARACTER(LEN=:), ALLOCATABLE :: CODE !< DATA VARIABLE ENCODED, ASCII OR BASE64 CODEC. + + DATA_TYPE = 'Float32' + N_COMPONENTS = SIZE(X, DIM=1) + IF (PRESENT(ONE_COMPONENT)) THEN + IF (ONE_COMPONENT) N_COMPONENTS = 1 + ENDIF + CODE = ENCODE_ASCII_DATAARRAY(X=X) + CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, & + IS_TUPLES=IS_TUPLES) + ERROR = SELF%ERROR + ENDFUNCTION W_DATA1_RANK4_R4P + + FUNCTION W_DATA1_RANK4_I8P(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR) + !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (I8P). + CLASS(XML_WRITER_ASCII_LOCAL), INTENT(INOUT) :: SELF !< WRITER. + CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. + INTEGER(I8P), INTENT(IN) :: X(1:,1:,1:,1:) !< DATA VARIABLE. + LOGICAL, INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT. + LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". + INTEGER(I4P) :: ERROR !< ERROR STATUS. + CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. + INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. + CHARACTER(LEN=:), ALLOCATABLE :: CODE !< DATA VARIABLE ENCODED, ASCII OR BASE64 CODEC. + + DATA_TYPE = 'Int64' + N_COMPONENTS = SIZE(X, DIM=1) + IF (PRESENT(ONE_COMPONENT)) THEN + IF (ONE_COMPONENT) N_COMPONENTS = 1 + ENDIF + CODE = ENCODE_ASCII_DATAARRAY(X=X) + CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, & + IS_TUPLES=IS_TUPLES) + ERROR = SELF%ERROR + ENDFUNCTION W_DATA1_RANK4_I8P + + FUNCTION W_DATA1_RANK4_I4P(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR) + !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (I4P). + CLASS(XML_WRITER_ASCII_LOCAL), INTENT(INOUT) :: SELF !< WRITER. + CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. + INTEGER(I4P), INTENT(IN) :: X(1:,1:,1:,1:) !< DATA VARIABLE. + LOGICAL, INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT. + LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". + INTEGER(I4P) :: ERROR !< ERROR STATUS. + CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. + INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. + CHARACTER(LEN=:), ALLOCATABLE :: CODE !< DATA VARIABLE ENCODED, ASCII OR BASE64 CODEC. + + DATA_TYPE = 'Int32' + N_COMPONENTS = SIZE(X, DIM=1) + IF (PRESENT(ONE_COMPONENT)) THEN + IF (ONE_COMPONENT) N_COMPONENTS = 1 + ENDIF + CODE = ENCODE_ASCII_DATAARRAY(X=X) + CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, & + IS_TUPLES=IS_TUPLES) + ERROR = SELF%ERROR + ENDFUNCTION W_DATA1_RANK4_I4P + + FUNCTION W_DATA1_RANK4_I2P(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR) + !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (I2P). + CLASS(XML_WRITER_ASCII_LOCAL), INTENT(INOUT) :: SELF !< WRITER. + CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. + INTEGER(I2P), INTENT(IN) :: X(1:,1:,1:,1:) !< DATA VARIABLE. + LOGICAL, INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT. + LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". + INTEGER(I4P) :: ERROR !< ERROR STATUS. + CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. + INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. + CHARACTER(LEN=:), ALLOCATABLE :: CODE !< DATA VARIABLE ENCODED, ASCII OR BASE64 CODEC. + + DATA_TYPE = 'Int16' + N_COMPONENTS = SIZE(X, DIM=1) + IF (PRESENT(ONE_COMPONENT)) THEN + IF (ONE_COMPONENT) N_COMPONENTS = 1 + ENDIF + CODE = ENCODE_ASCII_DATAARRAY(X=X) + CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, & + IS_TUPLES=IS_TUPLES) + ERROR = SELF%ERROR + ENDFUNCTION W_DATA1_RANK4_I2P + + FUNCTION W_DATA1_RANK4_I1P(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR) + !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (I1P). + CLASS(XML_WRITER_ASCII_LOCAL), INTENT(INOUT) :: SELF !< WRITER. + CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. + INTEGER(I1P), INTENT(IN) :: X(1:,1:,1:,1:) !< DATA VARIABLE. + LOGICAL, INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT. + LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". + INTEGER(I4P) :: ERROR !< ERROR STATUS. + CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. + INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. + CHARACTER(LEN=:), ALLOCATABLE :: CODE !< DATA VARIABLE ENCODED, ASCII OR BASE64 CODEC. + + DATA_TYPE = 'Int8' + N_COMPONENTS = SIZE(X, DIM=1) + IF (PRESENT(ONE_COMPONENT)) THEN + IF (ONE_COMPONENT) N_COMPONENTS = 1 + ENDIF + CODE = ENCODE_ASCII_DATAARRAY(X=X) + CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, & + IS_TUPLES=IS_TUPLES) + ERROR = SELF%ERROR + ENDFUNCTION W_DATA1_RANK4_I1P + + FUNCTION W_DATA3_RANK1_R8P(SELF, DATA_NAME, X, Y, Z, IS_TUPLES) RESULT(ERROR) + !< WRITE `<DATAARRAY... NumberOfComponents="3"...>...</DATAARRAY>` TAG (R8P). + CLASS(XML_WRITER_ASCII_LOCAL), INTENT(INOUT) :: SELF !< WRITER. + CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. + REAL(R8P), INTENT(IN) :: X(1:) !< X COMPONENT OF DATA VARIABLE. + REAL(R8P), INTENT(IN) :: Y(1:) !< Y COMPONENT OF DATA VARIABLE. + REAL(R8P), INTENT(IN) :: Z(1:) !< Z COMPONENT OF DATA VARIABLE. + LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". + INTEGER(I4P) :: ERROR !< ERROR STATUS. + CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. + INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. + CHARACTER(LEN=:), ALLOCATABLE :: CODE !< DATA VARIABLE ENCODED, ASCII OR BASE64 CODEC. + + DATA_TYPE = 'Float64' + N_COMPONENTS = 3 + CODE = ENCODE_ASCII_DATAARRAY(X=X, Y=Y, Z=Z) + CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, & + IS_TUPLES=IS_TUPLES) + ERROR = SELF%ERROR + ENDFUNCTION W_DATA3_RANK1_R8P + + FUNCTION W_DATA3_RANK1_R4P(SELF, DATA_NAME, X, Y, Z, IS_TUPLES) RESULT(ERROR) + !< WRITE `<DATAARRAY... NumberOfComponents="3"...>...</DATAARRAY>` TAG (R4P). + CLASS(XML_WRITER_ASCII_LOCAL), INTENT(INOUT) :: SELF !< WRITER. + CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. + REAL(R4P), INTENT(IN) :: X(1:) !< X COMPONENT OF DATA VARIABLE. + REAL(R4P), INTENT(IN) :: Y(1:) !< Y COMPONENT OF DATA VARIABLE. + REAL(R4P), INTENT(IN) :: Z(1:) !< Z COMPONENT OF DATA VARIABLE. + LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". + INTEGER(I4P) :: ERROR !< ERROR STATUS. + CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. + INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. + CHARACTER(LEN=:), ALLOCATABLE :: CODE !< DATA VARIABLE ENCODED, ASCII OR BASE64 CODEC. + + DATA_TYPE = 'Float32' + N_COMPONENTS = 3 + CODE = ENCODE_ASCII_DATAARRAY(X=X, Y=Y, Z=Z) + CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, & + IS_TUPLES=IS_TUPLES) + ERROR = SELF%ERROR + ENDFUNCTION W_DATA3_RANK1_R4P + + FUNCTION W_DATA3_RANK1_I8P(SELF, DATA_NAME, X, Y, Z, IS_TUPLES) RESULT(ERROR) + !< WRITE `<DATAARRAY... NumberOfComponents="3"...>...</DATAARRAY>` TAG (I8P). + CLASS(XML_WRITER_ASCII_LOCAL), INTENT(INOUT) :: SELF !< WRITER. + CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. + INTEGER(I8P), INTENT(IN) :: X(1:) !< X COMPONENT OF DATA VARIABLE. + INTEGER(I8P), INTENT(IN) :: Y(1:) !< Y COMPONENT OF DATA VARIABLE. + INTEGER(I8P), INTENT(IN) :: Z(1:) !< Z COMPONENT OF DATA VARIABLE. + LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". + INTEGER(I4P) :: ERROR !< ERROR STATUS. + CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. + INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. + CHARACTER(LEN=:), ALLOCATABLE :: CODE !< DATA VARIABLE ENCODED, ASCII OR BASE64 CODEC. + + DATA_TYPE = 'Int64' + N_COMPONENTS = 3 + CODE = ENCODE_ASCII_DATAARRAY(X=X, Y=Y, Z=Z) + CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, & + IS_TUPLES=IS_TUPLES) + ERROR = SELF%ERROR + ENDFUNCTION W_DATA3_RANK1_I8P + + FUNCTION W_DATA3_RANK1_I4P(SELF, DATA_NAME, X, Y, Z, IS_TUPLES) RESULT(ERROR) + !< WRITE `<DATAARRAY... NumberOfComponents="3"...>...</DATAARRAY>` TAG (I4P). + CLASS(XML_WRITER_ASCII_LOCAL), INTENT(INOUT) :: SELF !< WRITER. + CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. + INTEGER(I4P), INTENT(IN) :: X(1:) !< X COMPONENT OF DATA VARIABLE. + INTEGER(I4P), INTENT(IN) :: Y(1:) !< Y COMPONENT OF DATA VARIABLE. + INTEGER(I4P), INTENT(IN) :: Z(1:) !< Z COMPONENT OF DATA VARIABLE. + LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". + INTEGER(I4P) :: ERROR !< ERROR STATUS. + CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. + INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. + CHARACTER(LEN=:), ALLOCATABLE :: CODE !< DATA VARIABLE ENCODED, ASCII OR BASE64 CODEC. + + DATA_TYPE = 'Int32' + N_COMPONENTS = 3 + CODE = ENCODE_ASCII_DATAARRAY(X=X, Y=Y, Z=Z) + CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, & + IS_TUPLES=IS_TUPLES) + ERROR = SELF%ERROR + ENDFUNCTION W_DATA3_RANK1_I4P + + FUNCTION W_DATA3_RANK1_I2P(SELF, DATA_NAME, X, Y, Z, IS_TUPLES) RESULT(ERROR) + !< WRITE `<DATAARRAY... NumberOfComponents="3"...>...</DATAARRAY>` TAG (I2P). + CLASS(XML_WRITER_ASCII_LOCAL), INTENT(INOUT) :: SELF !< WRITER. + CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. + INTEGER(I2P), INTENT(IN) :: X(1:) !< X COMPONENT OF DATA VARIABLE. + INTEGER(I2P), INTENT(IN) :: Y(1:) !< Y COMPONENT OF DATA VARIABLE. + INTEGER(I2P), INTENT(IN) :: Z(1:) !< Z COMPONENT OF DATA VARIABLE. + LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". + INTEGER(I4P) :: ERROR !< ERROR STATUS. + CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. + INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. + CHARACTER(LEN=:), ALLOCATABLE :: CODE !< DATA VARIABLE ENCODED, ASCII OR BASE64 CODEC. + + DATA_TYPE = 'Int16' + N_COMPONENTS = 3 + CODE = ENCODE_ASCII_DATAARRAY(X=X, Y=Y, Z=Z) + CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, & + IS_TUPLES=IS_TUPLES) + ERROR = SELF%ERROR + ENDFUNCTION W_DATA3_RANK1_I2P + + FUNCTION W_DATA3_RANK1_I1P(SELF, DATA_NAME, X, Y, Z, IS_TUPLES) RESULT(ERROR) + !< WRITE `<DATAARRAY... NumberOfComponents="3"...>...</DATAARRAY>` TAG (I1P). + CLASS(XML_WRITER_ASCII_LOCAL), INTENT(INOUT) :: SELF !< WRITER. + CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. + INTEGER(I1P), INTENT(IN) :: X(1:) !< X COMPONENT OF DATA VARIABLE. + INTEGER(I1P), INTENT(IN) :: Y(1:) !< Y COMPONENT OF DATA VARIABLE. + INTEGER(I1P), INTENT(IN) :: Z(1:) !< Z COMPONENT OF DATA VARIABLE. + LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". + INTEGER(I4P) :: ERROR !< ERROR STATUS. + CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. + INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. + CHARACTER(LEN=:), ALLOCATABLE :: CODE !< DATA VARIABLE ENCODED, ASCII OR BASE64 CODEC. + + DATA_TYPE = 'Int8' + N_COMPONENTS = 3 + CODE = ENCODE_ASCII_DATAARRAY(X=X, Y=Y, Z=Z) + CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, & + IS_TUPLES=IS_TUPLES) + ERROR = SELF%ERROR + ENDFUNCTION W_DATA3_RANK1_I1P + + FUNCTION W_DATA3_RANK3_R8P(SELF, DATA_NAME, X, Y, Z, IS_TUPLES) RESULT(ERROR) + !< WRITE `<DATAARRAY... NumberOfComponents="3"...>...</DATAARRAY>` TAG (R8P). + CLASS(XML_WRITER_ASCII_LOCAL), INTENT(INOUT) :: SELF !< WRITER. + CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. + REAL(R8P), INTENT(IN) :: X(1:,1:,1:) !< X COMPONENT OF DATA VARIABLE. + REAL(R8P), INTENT(IN) :: Y(1:,1:,1:) !< Y COMPONENT OF DATA VARIABLE. + REAL(R8P), INTENT(IN) :: Z(1:,1:,1:) !< Z COMPONENT OF DATA VARIABLE. + LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". + INTEGER(I4P) :: ERROR !< ERROR STATUS. + CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. + INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. + CHARACTER(LEN=:), ALLOCATABLE :: CODE !< DATA VARIABLE ENCODED, ASCII OR BASE64 CODEC. + + DATA_TYPE = 'Float64' + N_COMPONENTS = 3 + CODE = ENCODE_ASCII_DATAARRAY(X=X, Y=Y, Z=Z) + CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, & + IS_TUPLES=IS_TUPLES) + ERROR = SELF%ERROR + ENDFUNCTION W_DATA3_RANK3_R8P + + FUNCTION W_DATA3_RANK3_R4P(SELF, DATA_NAME, X, Y, Z, IS_TUPLES) RESULT(ERROR) + !< WRITE `<DATAARRAY... NumberOfComponents="3"...>...</DATAARRAY>` TAG (R4P). + CLASS(XML_WRITER_ASCII_LOCAL), INTENT(INOUT) :: SELF !< WRITER. + CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. + REAL(R4P), INTENT(IN) :: X(1:,1:,1:) !< X COMPONENT OF DATA VARIABLE. + REAL(R4P), INTENT(IN) :: Y(1:,1:,1:) !< Y COMPONENT OF DATA VARIABLE. + REAL(R4P), INTENT(IN) :: Z(1:,1:,1:) !< Z COMPONENT OF DATA VARIABLE. + LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". + INTEGER(I4P) :: ERROR !< ERROR STATUS. + CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. + INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. + CHARACTER(LEN=:), ALLOCATABLE :: CODE !< DATA VARIABLE ENCODED, ASCII OR BASE64 CODEC. + + DATA_TYPE = 'Float32' + N_COMPONENTS = 3 + CODE = ENCODE_ASCII_DATAARRAY(X=X, Y=Y, Z=Z) + CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, & + IS_TUPLES=IS_TUPLES) + ERROR = SELF%ERROR + ENDFUNCTION W_DATA3_RANK3_R4P + + FUNCTION W_DATA3_RANK3_I8P(SELF, DATA_NAME, X, Y, Z, IS_TUPLES) RESULT(ERROR) + !< WRITE `<DATAARRAY... NumberOfComponents="3"...>...</DATAARRAY>` TAG (I8P). + CLASS(XML_WRITER_ASCII_LOCAL), INTENT(INOUT) :: SELF !< WRITER. + CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. + INTEGER(I8P), INTENT(IN) :: X(1:,1:,1:) !< X COMPONENT OF DATA VARIABLE. + INTEGER(I8P), INTENT(IN) :: Y(1:,1:,1:) !< Y COMPONENT OF DATA VARIABLE. + INTEGER(I8P), INTENT(IN) :: Z(1:,1:,1:) !< Z COMPONENT OF DATA VARIABLE. + LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". + INTEGER(I4P) :: ERROR !< ERROR STATUS. + CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. + INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. + CHARACTER(LEN=:), ALLOCATABLE :: CODE !< DATA VARIABLE ENCODED, ASCII OR BASE64 CODEC. + + DATA_TYPE = 'Int64' + N_COMPONENTS = 3 + CODE = ENCODE_ASCII_DATAARRAY(X=X, Y=Y, Z=Z) + CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, & + IS_TUPLES=IS_TUPLES) + ERROR = SELF%ERROR + ENDFUNCTION W_DATA3_RANK3_I8P + + FUNCTION W_DATA3_RANK3_I4P(SELF, DATA_NAME, X, Y, Z, IS_TUPLES) RESULT(ERROR) + !< WRITE `<DATAARRAY... NumberOfComponents="3"...>...</DATAARRAY>` TAG (I4P). + CLASS(XML_WRITER_ASCII_LOCAL), INTENT(INOUT) :: SELF !< WRITER. + CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. + INTEGER(I4P), INTENT(IN) :: X(1:,1:,1:) !< X COMPONENT OF DATA VARIABLE. + INTEGER(I4P), INTENT(IN) :: Y(1:,1:,1:) !< Y COMPONENT OF DATA VARIABLE. + INTEGER(I4P), INTENT(IN) :: Z(1:,1:,1:) !< Z COMPONENT OF DATA VARIABLE. + LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". + INTEGER(I4P) :: ERROR !< ERROR STATUS. + CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. + INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. + CHARACTER(LEN=:), ALLOCATABLE :: CODE !< DATA VARIABLE ENCODED, ASCII OR BASE64 CODEC. + + DATA_TYPE = 'Int32' + N_COMPONENTS = 3 + CODE = ENCODE_ASCII_DATAARRAY(X=X, Y=Y, Z=Z) + CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, & + IS_TUPLES=IS_TUPLES) + ERROR = SELF%ERROR + ENDFUNCTION W_DATA3_RANK3_I4P + + FUNCTION W_DATA3_RANK3_I2P(SELF, DATA_NAME, X, Y, Z, IS_TUPLES) RESULT(ERROR) + !< WRITE `<DATAARRAY... NumberOfComponents="3"...>...</DATAARRAY>` TAG (I2P). + CLASS(XML_WRITER_ASCII_LOCAL), INTENT(INOUT) :: SELF !< WRITER. + CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. + INTEGER(I2P), INTENT(IN) :: X(1:,1:,1:) !< X COMPONENT OF DATA VARIABLE. + INTEGER(I2P), INTENT(IN) :: Y(1:,1:,1:) !< Y COMPONENT OF DATA VARIABLE. + INTEGER(I2P), INTENT(IN) :: Z(1:,1:,1:) !< Z COMPONENT OF DATA VARIABLE. + LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". + INTEGER(I4P) :: ERROR !< ERROR STATUS. + CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. + INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. + CHARACTER(LEN=:), ALLOCATABLE :: CODE !< DATA VARIABLE ENCODED, ASCII OR BASE64 CODEC. + + DATA_TYPE = 'Int16' + N_COMPONENTS = 3 + CODE = ENCODE_ASCII_DATAARRAY(X=X, Y=Y, Z=Z) + CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, & + IS_TUPLES=IS_TUPLES) + ERROR = SELF%ERROR + ENDFUNCTION W_DATA3_RANK3_I2P + + FUNCTION W_DATA3_RANK3_I1P(SELF, DATA_NAME, X, Y, Z, IS_TUPLES) RESULT(ERROR) + !< WRITE `<DATAARRAY... NumberOfComponents="3"...>...</DATAARRAY>` TAG (I1P). + CLASS(XML_WRITER_ASCII_LOCAL), INTENT(INOUT) :: SELF !< WRITER. + CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. + INTEGER(I1P), INTENT(IN) :: X(1:,1:,1:) !< X COMPONENT OF DATA VARIABLE. + INTEGER(I1P), INTENT(IN) :: Y(1:,1:,1:) !< Y COMPONENT OF DATA VARIABLE. + INTEGER(I1P), INTENT(IN) :: Z(1:,1:,1:) !< Z COMPONENT OF DATA VARIABLE. + LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". + INTEGER(I4P) :: ERROR !< ERROR STATUS. + CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. + INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. + CHARACTER(LEN=:), ALLOCATABLE :: CODE !< DATA VARIABLE ENCODED, ASCII OR BASE64 CODEC. + + DATA_TYPE = 'Int8' + N_COMPONENTS = 3 + CODE = ENCODE_ASCII_DATAARRAY(X=X, Y=Y, Z=Z) + CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, & + IS_TUPLES=IS_TUPLES) + ERROR = SELF%ERROR + ENDFUNCTION W_DATA3_RANK3_I1P + + FUNCTION W_DATA6_RANK1_R8P(SELF, DATA_NAME, U, V, W, X, Y, Z, IS_TUPLES) RESULT(ERROR) + !< WRITE `<DATAARRAY... NumberOfComponents="6"...>...</DATAARRAY>` TAG (R8P). + CLASS(XML_WRITER_ASCII_LOCAL), INTENT(INOUT) :: SELF !< WRITER. + CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. + REAL(R8P), INTENT(IN) :: U(1:) !< U COMPONENT OF DATA VARIABLE. + REAL(R8P), INTENT(IN) :: V(1:) !< V COMPONENT OF DATA VARIABLE. + REAL(R8P), INTENT(IN) :: W(1:) !< W COMPONENT OF DATA VARIABLE. + REAL(R8P), INTENT(IN) :: X(1:) !< X COMPONENT OF DATA VARIABLE. + REAL(R8P), INTENT(IN) :: Y(1:) !< Y COMPONENT OF DATA VARIABLE. + REAL(R8P), INTENT(IN) :: Z(1:) !< Z COMPONENT OF DATA VARIABLE. + LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". + INTEGER(I4P) :: ERROR !< ERROR STATUS. + CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. + INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. + CHARACTER(LEN=:), ALLOCATABLE :: CODE !< DATA VARIABLE ENCODED, ASCII OR BASE64 CODEC. + + DATA_TYPE = 'Float64' + N_COMPONENTS = 6 + CODE = ENCODE_ASCII_DATAARRAY(U=U, V=V, W=W, X=X, Y=Y, Z=Z) + CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, & + IS_TUPLES=IS_TUPLES) + ERROR = SELF%ERROR + ENDFUNCTION W_DATA6_RANK1_R8P + + FUNCTION W_DATA6_RANK1_R4P(SELF, DATA_NAME, U, V, W,X, Y, Z, IS_TUPLES) RESULT(ERROR) + !< WRITE `<DATAARRAY... NumberOfComponents="6"...>...</DATAARRAY>` TAG (R4P). + CLASS(XML_WRITER_ASCII_LOCAL), INTENT(INOUT) :: SELF !< WRITER. + CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. + REAL(R4P), INTENT(IN) :: U(1:) !< U COMPONENT OF DATA VARIABLE. + REAL(R4P), INTENT(IN) :: V(1:) !< V COMPONENT OF DATA VARIABLE. + REAL(R4P), INTENT(IN) :: W(1:) !< W COMPONENT OF DATA VARIABLE. + REAL(R4P), INTENT(IN) :: X(1:) !< X COMPONENT OF DATA VARIABLE. + REAL(R4P), INTENT(IN) :: Y(1:) !< Y COMPONENT OF DATA VARIABLE. + REAL(R4P), INTENT(IN) :: Z(1:) !< Z COMPONENT OF DATA VARIABLE. + LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". + INTEGER(I4P) :: ERROR !< ERROR STATUS. + CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. + INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. + CHARACTER(LEN=:), ALLOCATABLE :: CODE !< DATA VARIABLE ENCODED, ASCII OR BASE64 CODEC. + + DATA_TYPE = 'Float32' + N_COMPONENTS = 6 + CODE = ENCODE_ASCII_DATAARRAY(U=U, V=V, W=W, X=X, Y=Y, Z=Z) + CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, & + IS_TUPLES=IS_TUPLES) + ERROR = SELF%ERROR + ENDFUNCTION W_DATA6_RANK1_R4P + + FUNCTION W_DATA6_RANK1_I8P(SELF, DATA_NAME, U, V, W, X, Y, Z, IS_TUPLES) RESULT(ERROR) + !< WRITE `<DATAARRAY... NumberOfComponents="6"...>...</DATAARRAY>` TAG (I8P). + CLASS(XML_WRITER_ASCII_LOCAL), INTENT(INOUT) :: SELF !< WRITER. + CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. + INTEGER(I8P), INTENT(IN) :: U(1:) !< U COMPONENT OF DATA VARIABLE. + INTEGER(I8P), INTENT(IN) :: V(1:) !< V COMPONENT OF DATA VARIABLE. + INTEGER(I8P), INTENT(IN) :: W(1:) !< W COMPONENT OF DATA VARIABLE. + INTEGER(I8P), INTENT(IN) :: X(1:) !< X COMPONENT OF DATA VARIABLE. + INTEGER(I8P), INTENT(IN) :: Y(1:) !< Y COMPONENT OF DATA VARIABLE. + INTEGER(I8P), INTENT(IN) :: Z(1:) !< Z COMPONENT OF DATA VARIABLE. + LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". + INTEGER(I4P) :: ERROR !< ERROR STATUS. + CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. + INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. + CHARACTER(LEN=:), ALLOCATABLE :: CODE !< DATA VARIABLE ENCODED, ASCII OR BASE64 CODEC. + + DATA_TYPE = 'Int64' + N_COMPONENTS = 6 + CODE = ENCODE_ASCII_DATAARRAY(U=U, V=V, W=W, X=X, Y=Y, Z=Z) + CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, & + IS_TUPLES=IS_TUPLES) + ERROR = SELF%ERROR + ENDFUNCTION W_DATA6_RANK1_I8P + + FUNCTION W_DATA6_RANK1_I4P(SELF, DATA_NAME, U, V, W, X, Y, Z, IS_TUPLES) RESULT(ERROR) + !< WRITE `<DATAARRAY... NumberOfComponents="6"...>...</DATAARRAY>` TAG (I4P). + CLASS(XML_WRITER_ASCII_LOCAL), INTENT(INOUT) :: SELF !< WRITER. + CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. + INTEGER(I4P), INTENT(IN) :: U(1:) !< U COMPONENT OF DATA VARIABLE. + INTEGER(I4P), INTENT(IN) :: V(1:) !< V COMPONENT OF DATA VARIABLE. + INTEGER(I4P), INTENT(IN) :: W(1:) !< W COMPONENT OF DATA VARIABLE. + INTEGER(I4P), INTENT(IN) :: X(1:) !< X COMPONENT OF DATA VARIABLE. + INTEGER(I4P), INTENT(IN) :: Y(1:) !< Y COMPONENT OF DATA VARIABLE. + INTEGER(I4P), INTENT(IN) :: Z(1:) !< Z COMPONENT OF DATA VARIABLE. + LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". + INTEGER(I4P) :: ERROR !< ERROR STATUS. + CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. + INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. + CHARACTER(LEN=:), ALLOCATABLE :: CODE !< DATA VARIABLE ENCODED, ASCII OR BASE64 CODEC. + + DATA_TYPE = 'Int32' + N_COMPONENTS = 6 + CODE = ENCODE_ASCII_DATAARRAY(U=U, V=V, W=W, X=X, Y=Y, Z=Z) + CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, & + IS_TUPLES=IS_TUPLES) + ERROR = SELF%ERROR + ENDFUNCTION W_DATA6_RANK1_I4P + + FUNCTION W_DATA6_RANK1_I2P(SELF, DATA_NAME, U, V, W, X, Y, Z, IS_TUPLES) RESULT(ERROR) + !< WRITE `<DATAARRAY... NumberOfComponents="6"...>...</DATAARRAY>` TAG (I2P). + CLASS(XML_WRITER_ASCII_LOCAL), INTENT(INOUT) :: SELF !< WRITER. + CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. + INTEGER(I2P), INTENT(IN) :: U(1:) !< U COMPONENT OF DATA VARIABLE. + INTEGER(I2P), INTENT(IN) :: V(1:) !< V COMPONENT OF DATA VARIABLE. + INTEGER(I2P), INTENT(IN) :: W(1:) !< W COMPONENT OF DATA VARIABLE. + INTEGER(I2P), INTENT(IN) :: X(1:) !< X COMPONENT OF DATA VARIABLE. + INTEGER(I2P), INTENT(IN) :: Y(1:) !< Y COMPONENT OF DATA VARIABLE. + INTEGER(I2P), INTENT(IN) :: Z(1:) !< Z COMPONENT OF DATA VARIABLE. + LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". + INTEGER(I4P) :: ERROR !< ERROR STATUS. + CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. + INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. + CHARACTER(LEN=:), ALLOCATABLE :: CODE !< DATA VARIABLE ENCODED, ASCII OR BASE64 CODEC. + + DATA_TYPE = 'Int16' + N_COMPONENTS = 6 + CODE = ENCODE_ASCII_DATAARRAY(U=U, V=V, W=W, X=X, Y=Y, Z=Z) + CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, & + IS_TUPLES=IS_TUPLES) + ERROR = SELF%ERROR + ENDFUNCTION W_DATA6_RANK1_I2P + + FUNCTION W_DATA6_RANK1_I1P(SELF, DATA_NAME, U, V, W, X, Y, Z, IS_TUPLES) RESULT(ERROR) + !< WRITE `<DATAARRAY... NumberOfComponents="6"...>...</DATAARRAY>` TAG (I1P). + CLASS(XML_WRITER_ASCII_LOCAL), INTENT(INOUT) :: SELF !< WRITER. + CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. + INTEGER(I1P), INTENT(IN) :: U(1:) !< U COMPONENT OF DATA VARIABLE. + INTEGER(I1P), INTENT(IN) :: V(1:) !< V COMPONENT OF DATA VARIABLE. + INTEGER(I1P), INTENT(IN) :: W(1:) !< W COMPONENT OF DATA VARIABLE. + INTEGER(I1P), INTENT(IN) :: X(1:) !< X COMPONENT OF DATA VARIABLE. + INTEGER(I1P), INTENT(IN) :: Y(1:) !< Y COMPONENT OF DATA VARIABLE. + INTEGER(I1P), INTENT(IN) :: Z(1:) !< Z COMPONENT OF DATA VARIABLE. + LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". + INTEGER(I4P) :: ERROR !< ERROR STATUS. + CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. + INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. + CHARACTER(LEN=:), ALLOCATABLE :: CODE !< DATA VARIABLE ENCODED, ASCII OR BASE64 CODEC. + + DATA_TYPE = 'Int8' + N_COMPONENTS = 6 + CODE = ENCODE_ASCII_DATAARRAY(U=U, V=V, W=W, X=X, Y=Y, Z=Z) + CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, & + IS_TUPLES=IS_TUPLES) + ERROR = SELF%ERROR + ENDFUNCTION W_DATA6_RANK1_I1P + + FUNCTION W_DATA6_RANK3_R8P(SELF, DATA_NAME, U, V, W, X, Y, Z, IS_TUPLES) RESULT(ERROR) + !< WRITE `<DATAARRAY... NumberOfComponents="6"...>...</DATAARRAY>` TAG (R8P). + CLASS(XML_WRITER_ASCII_LOCAL), INTENT(INOUT) :: SELF !< WRITER. + CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. + REAL(R8P), INTENT(IN) :: U(1:,1:,1:) !< U COMPONENT OF DATA VARIABLE. + REAL(R8P), INTENT(IN) :: V(1:,1:,1:) !< V COMPONENT OF DATA VARIABLE. + REAL(R8P), INTENT(IN) :: W(1:,1:,1:) !< W COMPONENT OF DATA VARIABLE. + REAL(R8P), INTENT(IN) :: X(1:,1:,1:) !< X COMPONENT OF DATA VARIABLE. + REAL(R8P), INTENT(IN) :: Y(1:,1:,1:) !< Y COMPONENT OF DATA VARIABLE. + REAL(R8P), INTENT(IN) :: Z(1:,1:,1:) !< Z COMPONENT OF DATA VARIABLE. + LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". + INTEGER(I4P) :: ERROR !< ERROR STATUS. + CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. + INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. + CHARACTER(LEN=:), ALLOCATABLE :: CODE !< DATA VARIABLE ENCODED, ASCII OR BASE64 CODEC. + + DATA_TYPE = 'Float64' + N_COMPONENTS = 6 + CODE = ENCODE_ASCII_DATAARRAY(U=U, V=V, W=W, X=X, Y=Y, Z=Z) + CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, & + IS_TUPLES=IS_TUPLES) + ERROR = SELF%ERROR + ENDFUNCTION W_DATA6_RANK3_R8P + + FUNCTION W_DATA6_RANK3_R4P(SELF, DATA_NAME, U, V, W, X, Y, Z, IS_TUPLES) RESULT(ERROR) + !< WRITE `<DATAARRAY... NumberOfComponents="6"...>...</DATAARRAY>` TAG (R4P). + CLASS(XML_WRITER_ASCII_LOCAL), INTENT(INOUT) :: SELF !< WRITER. + CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. + REAL(R4P), INTENT(IN) :: U(1:,1:,1:) !< U COMPONENT OF DATA VARIABLE. + REAL(R4P), INTENT(IN) :: V(1:,1:,1:) !< V COMPONENT OF DATA VARIABLE. + REAL(R4P), INTENT(IN) :: W(1:,1:,1:) !< W COMPONENT OF DATA VARIABLE. + REAL(R4P), INTENT(IN) :: X(1:,1:,1:) !< X COMPONENT OF DATA VARIABLE. + REAL(R4P), INTENT(IN) :: Y(1:,1:,1:) !< Y COMPONENT OF DATA VARIABLE. + REAL(R4P), INTENT(IN) :: Z(1:,1:,1:) !< Z COMPONENT OF DATA VARIABLE. + LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". + INTEGER(I4P) :: ERROR !< ERROR STATUS. + CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. + INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. + CHARACTER(LEN=:), ALLOCATABLE :: CODE !< DATA VARIABLE ENCODED, ASCII OR BASE64 CODEC. + + DATA_TYPE = 'Float32' + N_COMPONENTS = 6 + CODE = ENCODE_ASCII_DATAARRAY(U=U, V=V, W=W, X=X, Y=Y, Z=Z) + CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, & + IS_TUPLES=IS_TUPLES) + ERROR = SELF%ERROR + ENDFUNCTION W_DATA6_RANK3_R4P + + FUNCTION W_DATA6_RANK3_I8P(SELF, DATA_NAME, U, V, W, X, Y, Z, IS_TUPLES) RESULT(ERROR) + !< WRITE `<DATAARRAY... NumberOfComponents="6"...>...</DATAARRAY>` TAG (I8P). + CLASS(XML_WRITER_ASCII_LOCAL), INTENT(INOUT) :: SELF !< WRITER. + CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. + INTEGER(I8P), INTENT(IN) :: U(1:,1:,1:) !< U COMPONENT OF DATA VARIABLE. + INTEGER(I8P), INTENT(IN) :: V(1:,1:,1:) !< V COMPONENT OF DATA VARIABLE. + INTEGER(I8P), INTENT(IN) :: W(1:,1:,1:) !< W COMPONENT OF DATA VARIABLE. + INTEGER(I8P), INTENT(IN) :: X(1:,1:,1:) !< X COMPONENT OF DATA VARIABLE. + INTEGER(I8P), INTENT(IN) :: Y(1:,1:,1:) !< Y COMPONENT OF DATA VARIABLE. + INTEGER(I8P), INTENT(IN) :: Z(1:,1:,1:) !< Z COMPONENT OF DATA VARIABLE. + LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". + INTEGER(I4P) :: ERROR !< ERROR STATUS. + CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. + INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. + CHARACTER(LEN=:), ALLOCATABLE :: CODE !< DATA VARIABLE ENCODED, ASCII OR BASE64 CODEC. + + DATA_TYPE = 'Int64' + N_COMPONENTS = 6 + CODE = ENCODE_ASCII_DATAARRAY(U=U, V=V, W=W, X=X, Y=Y, Z=Z) + CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, & + IS_TUPLES=IS_TUPLES) + ERROR = SELF%ERROR + ENDFUNCTION W_DATA6_RANK3_I8P + + FUNCTION W_DATA6_RANK3_I4P(SELF, DATA_NAME, U, V, W, X, Y, Z, IS_TUPLES) RESULT(ERROR) + !< WRITE `<DATAARRAY... NumberOfComponents="6"...>...</DATAARRAY>` TAG (I4P). + CLASS(XML_WRITER_ASCII_LOCAL), INTENT(INOUT) :: SELF !< WRITER. + CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. + INTEGER(I4P), INTENT(IN) :: U(1:,1:,1:) !< U COMPONENT OF DATA VARIABLE. + INTEGER(I4P), INTENT(IN) :: V(1:,1:,1:) !< V COMPONENT OF DATA VARIABLE. + INTEGER(I4P), INTENT(IN) :: W(1:,1:,1:) !< W COMPONENT OF DATA VARIABLE. + INTEGER(I4P), INTENT(IN) :: X(1:,1:,1:) !< X COMPONENT OF DATA VARIABLE. + INTEGER(I4P), INTENT(IN) :: Y(1:,1:,1:) !< Y COMPONENT OF DATA VARIABLE. + INTEGER(I4P), INTENT(IN) :: Z(1:,1:,1:) !< Z COMPONENT OF DATA VARIABLE. + LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". + INTEGER(I4P) :: ERROR !< ERROR STATUS. + CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. + INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. + CHARACTER(LEN=:), ALLOCATABLE :: CODE !< DATA VARIABLE ENCODED, ASCII OR BASE64 CODEC. + + DATA_TYPE = 'Int32' + N_COMPONENTS = 6 + CODE = ENCODE_ASCII_DATAARRAY(U=U, V=V, W=W, X=X, Y=Y, Z=Z) + CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, & + IS_TUPLES=IS_TUPLES) + ERROR = SELF%ERROR + ENDFUNCTION W_DATA6_RANK3_I4P + + FUNCTION W_DATA6_RANK3_I2P(SELF, DATA_NAME, U, V, W, X, Y, Z, IS_TUPLES) RESULT(ERROR) + !< WRITE `<DATAARRAY... NumberOfComponents="6"...>...</DATAARRAY>` TAG (I2P). + CLASS(XML_WRITER_ASCII_LOCAL), INTENT(INOUT) :: SELF !< WRITER. + CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. + INTEGER(I2P), INTENT(IN) :: U(1:,1:,1:) !< U COMPONENT OF DATA VARIABLE. + INTEGER(I2P), INTENT(IN) :: V(1:,1:,1:) !< V COMPONENT OF DATA VARIABLE. + INTEGER(I2P), INTENT(IN) :: W(1:,1:,1:) !< W COMPONENT OF DATA VARIABLE. + INTEGER(I2P), INTENT(IN) :: X(1:,1:,1:) !< X COMPONENT OF DATA VARIABLE. + INTEGER(I2P), INTENT(IN) :: Y(1:,1:,1:) !< Y COMPONENT OF DATA VARIABLE. + INTEGER(I2P), INTENT(IN) :: Z(1:,1:,1:) !< Z COMPONENT OF DATA VARIABLE. + LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". + INTEGER(I4P) :: ERROR !< ERROR STATUS. + CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. + INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. + CHARACTER(LEN=:), ALLOCATABLE :: CODE !< DATA VARIABLE ENCODED, ASCII OR BASE64 CODEC. + + DATA_TYPE = 'Int16' + N_COMPONENTS = 6 + CODE = ENCODE_ASCII_DATAARRAY(U=U, V=V, W=W, X=X, Y=Y, Z=Z) + CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, & + IS_TUPLES=IS_TUPLES) + ERROR = SELF%ERROR + ENDFUNCTION W_DATA6_RANK3_I2P + + FUNCTION W_DATA6_RANK3_I1P(SELF, DATA_NAME, U, V, W, X, Y, Z, IS_TUPLES) RESULT(ERROR) + !< WRITE `<DATAARRAY... NumberOfComponents="6"...>...</DATAARRAY>` TAG (I1P). + CLASS(XML_WRITER_ASCII_LOCAL), INTENT(INOUT) :: SELF !< WRITER. + CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. + INTEGER(I1P), INTENT(IN) :: U(1:,1:,1:) !< U COMPONENT OF DATA VARIABLE. + INTEGER(I1P), INTENT(IN) :: V(1:,1:,1:) !< V COMPONENT OF DATA VARIABLE. + INTEGER(I1P), INTENT(IN) :: W(1:,1:,1:) !< W COMPONENT OF DATA VARIABLE. + INTEGER(I1P), INTENT(IN) :: X(1:,1:,1:) !< X COMPONENT OF DATA VARIABLE. + INTEGER(I1P), INTENT(IN) :: Y(1:,1:,1:) !< Y COMPONENT OF DATA VARIABLE. + INTEGER(I1P), INTENT(IN) :: Z(1:,1:,1:) !< Z COMPONENT OF DATA VARIABLE. + LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". + INTEGER(I4P) :: ERROR !< ERROR STATUS. + CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. + INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. + CHARACTER(LEN=:), ALLOCATABLE :: CODE !< DATA VARIABLE ENCODED, ASCII OR BASE64 CODEC. + + DATA_TYPE = 'Int8' + N_COMPONENTS = 6 + CODE = ENCODE_ASCII_DATAARRAY(U=U, V=V, W=W, X=X, Y=Y, Z=Z) + CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, & + IS_TUPLES=IS_TUPLES) + ERROR = SELF%ERROR + ENDFUNCTION W_DATA6_RANK3_I1P + + + SUBROUTINE W_DATA_APPENDED(SELF) + !< DO NOTHING, ASCII DATA CANNOT BE APPENDED. + CLASS(XML_WRITER_ASCII_LOCAL), INTENT(INOUT) :: SELF !< WRITER. + ENDSUBROUTINE W_DATA_APPENDED +ENDMODULE VTKF_FILE_XML_WRITER_ASCII_LOCAL + + + + + + +!< VTK FILE XML WRITER, APPENDED. +MODULE VTKF_FILE_XML_WRITER_APPENDED +!< VTK FILE XML WRITER, APPENDED. +USE PENF +USE STRINGIFOR +USE VTK_FORTRAN_DATAARRAY_ENCODER +USE VTK_FORTRAN_PARAMETERS +USE VTKF_FILE_XML_WRITER_ABSTRACT + +IMPLICIT NONE +PRIVATE +PUBLIC :: XML_WRITER_APPENDED + +TYPE, EXTENDS(XML_WRITER_ABSTRACT) :: XML_WRITER_APPENDED + !< VTK FILE XML WRITER, APPENDED. + TYPE(STRING) :: ENCODING !< APPENDED DATA ENCODING: "RAW" OR "BASE64". + INTEGER(I4P) :: SCRATCH=0_I4P !< SCRATCH LOGICAL UNIT. + CONTAINS + ! DEFERRED METHODS + PROCEDURE, PASS(SELF) :: INITIALIZE !< INITIALIZE WRITER. + PROCEDURE, PASS(SELF) :: FINALIZE !< FINALIZE WRITER. + PROCEDURE, PASS(SELF) :: W_DATA1_RANK1_R8P !< WRITE DATAARRAY 1, RANK 1, R8P. + PROCEDURE, PASS(SELF) :: W_DATA1_RANK1_R4P !< WRITE DATAARRAY 1, RANK 1, R4P. + PROCEDURE, PASS(SELF) :: W_DATA1_RANK1_I8P !< WRITE DATAARRAY 1, RANK 1, I8P. + PROCEDURE, PASS(SELF) :: W_DATA1_RANK1_I4P !< WRITE DATAARRAY 1, RANK 1, I4P. + PROCEDURE, PASS(SELF) :: W_DATA1_RANK1_I2P !< WRITE DATAARRAY 1, RANK 1, I2P. + PROCEDURE, PASS(SELF) :: W_DATA1_RANK1_I1P !< WRITE DATAARRAY 1, RANK 1, I1P. + PROCEDURE, PASS(SELF) :: W_DATA1_RANK2_R8P !< WRITE DATAARRAY 1, RANK 2, R8P. + PROCEDURE, PASS(SELF) :: W_DATA1_RANK2_R4P !< WRITE DATAARRAY 1, RANK 2, R4P. + PROCEDURE, PASS(SELF) :: W_DATA1_RANK2_I8P !< WRITE DATAARRAY 1, RANK 2, I8P. + PROCEDURE, PASS(SELF) :: W_DATA1_RANK2_I4P !< WRITE DATAARRAY 1, RANK 2, I4P. + PROCEDURE, PASS(SELF) :: W_DATA1_RANK2_I2P !< WRITE DATAARRAY 1, RANK 2, I2P. + PROCEDURE, PASS(SELF) :: W_DATA1_RANK2_I1P !< WRITE DATAARRAY 1, RANK 2, I1P. + PROCEDURE, PASS(SELF) :: W_DATA1_RANK3_R8P !< WRITE DATAARRAY 1, RANK 3, R8P. + PROCEDURE, PASS(SELF) :: W_DATA1_RANK3_R4P !< WRITE DATAARRAY 1, RANK 3, R4P. + PROCEDURE, PASS(SELF) :: W_DATA1_RANK3_I8P !< WRITE DATAARRAY 1, RANK 3, I8P. + PROCEDURE, PASS(SELF) :: W_DATA1_RANK3_I4P !< WRITE DATAARRAY 1, RANK 3, I4P. + PROCEDURE, PASS(SELF) :: W_DATA1_RANK3_I2P !< WRITE DATAARRAY 1, RANK 3, I2P. + PROCEDURE, PASS(SELF) :: W_DATA1_RANK3_I1P !< WRITE DATAARRAY 1, RANK 3, I1P. + PROCEDURE, PASS(SELF) :: W_DATA1_RANK4_R8P !< WRITE DATAARRAY 1, RANK 4, R8P. + PROCEDURE, PASS(SELF) :: W_DATA1_RANK4_R4P !< WRITE DATAARRAY 1, RANK 4, R4P. + PROCEDURE, PASS(SELF) :: W_DATA1_RANK4_I8P !< WRITE DATAARRAY 1, RANK 4, I8P. + PROCEDURE, PASS(SELF) :: W_DATA1_RANK4_I4P !< WRITE DATAARRAY 1, RANK 4, I4P. + PROCEDURE, PASS(SELF) :: W_DATA1_RANK4_I2P !< WRITE DATAARRAY 1, RANK 4, I2P. + PROCEDURE, PASS(SELF) :: W_DATA1_RANK4_I1P !< WRITE DATAARRAY 1, RANK 4, I1P. + PROCEDURE, PASS(SELF) :: W_DATA3_RANK1_R8P !< WRITE DATAARRAY 3, RANK 1, R8P. + PROCEDURE, PASS(SELF) :: W_DATA3_RANK1_R4P !< WRITE DATAARRAY 3, RANK 1, R4P. + PROCEDURE, PASS(SELF) :: W_DATA3_RANK1_I8P !< WRITE DATAARRAY 3, RANK 1, I8P. + PROCEDURE, PASS(SELF) :: W_DATA3_RANK1_I4P !< WRITE DATAARRAY 3, RANK 1, I4P. + PROCEDURE, PASS(SELF) :: W_DATA3_RANK1_I2P !< WRITE DATAARRAY 3, RANK 1, I2P. + PROCEDURE, PASS(SELF) :: W_DATA3_RANK1_I1P !< WRITE DATAARRAY 3, RANK 1, I1P. + PROCEDURE, PASS(SELF) :: W_DATA3_RANK3_R8P !< WRITE DATAARRAY 3, RANK 3, R8P. + PROCEDURE, PASS(SELF) :: W_DATA3_RANK3_R4P !< WRITE DATAARRAY 3, RANK 3, R4P. + PROCEDURE, PASS(SELF) :: W_DATA3_RANK3_I8P !< WRITE DATAARRAY 3, RANK 3, I8P. + PROCEDURE, PASS(SELF) :: W_DATA3_RANK3_I4P !< WRITE DATAARRAY 3, RANK 3, I4P. + PROCEDURE, PASS(SELF) :: W_DATA3_RANK3_I2P !< WRITE DATAARRAY 3, RANK 3, I2P. + PROCEDURE, PASS(SELF) :: W_DATA3_RANK3_I1P !< WRITE DATAARRAY 3, RANK 3, I1P. + PROCEDURE, PASS(SELF) :: W_DATA6_RANK1_R8P !< WRITE DATAARRAY 6, RANK 1, R8P. + PROCEDURE, PASS(SELF) :: W_DATA6_RANK1_R4P !< WRITE DATAARRAY 6, RANK 1, R4P. + PROCEDURE, PASS(SELF) :: W_DATA6_RANK1_I8P !< WRITE DATAARRAY 6, RANK 1, I8P. + PROCEDURE, PASS(SELF) :: W_DATA6_RANK1_I4P !< WRITE DATAARRAY 6, RANK 1, I4P. + PROCEDURE, PASS(SELF) :: W_DATA6_RANK1_I2P !< WRITE DATAARRAY 6, RANK 1, I2P. + PROCEDURE, PASS(SELF) :: W_DATA6_RANK1_I1P !< WRITE DATAARRAY 6, RANK 1, I1P. + PROCEDURE, PASS(SELF) :: W_DATA6_RANK3_R8P !< WRITE DATAARRAY 6, RANK 3, R8P. + PROCEDURE, PASS(SELF) :: W_DATA6_RANK3_R4P !< WRITE DATAARRAY 6, RANK 3, R4P. + PROCEDURE, PASS(SELF) :: W_DATA6_RANK3_I8P !< WRITE DATAARRAY 6, RANK 3, I8P. + PROCEDURE, PASS(SELF) :: W_DATA6_RANK3_I4P !< WRITE DATAARRAY 6, RANK 3, I4P. + PROCEDURE, PASS(SELF) :: W_DATA6_RANK3_I2P !< WRITE DATAARRAY 6, RANK 3, I2P. + PROCEDURE, PASS(SELF) :: W_DATA6_RANK3_I1P !< WRITE DATAARRAY 6, RANK 3, I1P. + PROCEDURE, PASS(SELF) :: W_DATA_APPENDED !< WRITE APPENDED. + ! PRIVATE METHODS + PROCEDURE, PASS(SELF), PRIVATE :: IOFFSET_UPDATE !< UPDATE IOFFSET COUNT. + PROCEDURE, PASS(SELF), PRIVATE :: OPEN_SCRATCH_FILE !< OPEN SCRATCH FILE. + PROCEDURE, PASS(SELF), PRIVATE :: CLOSE_SCRATCH_FILE !< CLOSE SCRATCH FILE. + GENERIC, PRIVATE :: WRITE_ON_SCRATCH_DATAARRAY => & + WRITE_ON_SCRATCH_DATAARRAY1_RANK1, & + WRITE_ON_SCRATCH_DATAARRAY1_RANK2, & + WRITE_ON_SCRATCH_DATAARRAY1_RANK3, & + WRITE_ON_SCRATCH_DATAARRAY1_RANK4, & + WRITE_ON_SCRATCH_DATAARRAY3_RANK1_R8P, & + WRITE_ON_SCRATCH_DATAARRAY3_RANK1_R4P, & + WRITE_ON_SCRATCH_DATAARRAY3_RANK1_I8P, & + WRITE_ON_SCRATCH_DATAARRAY3_RANK1_I4P, & + WRITE_ON_SCRATCH_DATAARRAY3_RANK1_I2P, & + WRITE_ON_SCRATCH_DATAARRAY3_RANK1_I1P, & + WRITE_ON_SCRATCH_DATAARRAY3_RANK2_R8P, & + WRITE_ON_SCRATCH_DATAARRAY3_RANK2_R4P, & + WRITE_ON_SCRATCH_DATAARRAY3_RANK2_I8P, & + WRITE_ON_SCRATCH_DATAARRAY3_RANK2_I4P, & + WRITE_ON_SCRATCH_DATAARRAY3_RANK2_I2P, & + WRITE_ON_SCRATCH_DATAARRAY3_RANK2_I1P, & + WRITE_ON_SCRATCH_DATAARRAY3_RANK3_R8P, & + WRITE_ON_SCRATCH_DATAARRAY3_RANK3_R4P, & + WRITE_ON_SCRATCH_DATAARRAY3_RANK3_I8P, & + WRITE_ON_SCRATCH_DATAARRAY3_RANK3_I4P, & + WRITE_ON_SCRATCH_DATAARRAY3_RANK3_I2P, & + WRITE_ON_SCRATCH_DATAARRAY3_RANK3_I1P, & + WRITE_ON_SCRATCH_DATAARRAY6_RANK1_R8P, & + WRITE_ON_SCRATCH_DATAARRAY6_RANK1_R4P, & + WRITE_ON_SCRATCH_DATAARRAY6_RANK1_I8P, & + WRITE_ON_SCRATCH_DATAARRAY6_RANK1_I4P, & + WRITE_ON_SCRATCH_DATAARRAY6_RANK1_I2P, & + WRITE_ON_SCRATCH_DATAARRAY6_RANK1_I1P, & + WRITE_ON_SCRATCH_DATAARRAY6_RANK2_R8P, & + WRITE_ON_SCRATCH_DATAARRAY6_RANK2_R4P, & + WRITE_ON_SCRATCH_DATAARRAY6_RANK2_I8P, & + WRITE_ON_SCRATCH_DATAARRAY6_RANK2_I4P, & + WRITE_ON_SCRATCH_DATAARRAY6_RANK2_I2P, & + WRITE_ON_SCRATCH_DATAARRAY6_RANK2_I1P, & + WRITE_ON_SCRATCH_DATAARRAY6_RANK3_R8P, & + WRITE_ON_SCRATCH_DATAARRAY6_RANK3_R4P, & + WRITE_ON_SCRATCH_DATAARRAY6_RANK3_I8P, & + WRITE_ON_SCRATCH_DATAARRAY6_RANK3_I4P, & + WRITE_ON_SCRATCH_DATAARRAY6_RANK3_I2P, & + WRITE_ON_SCRATCH_DATAARRAY6_RANK3_I1P !< WRITE DATAARRAY. + PROCEDURE, PASS(SELF), PRIVATE :: WRITE_ON_SCRATCH_DATAARRAY1_RANK1 !< WRITE DATAARRAY, DATA 1 RANK 1. + PROCEDURE, PASS(SELF), PRIVATE :: WRITE_ON_SCRATCH_DATAARRAY1_RANK2 !< WRITE DATAARRAY, DATA 1 RANK 2. + PROCEDURE, PASS(SELF), PRIVATE :: WRITE_ON_SCRATCH_DATAARRAY1_RANK3 !< WRITE DATAARRAY, DATA 1 RANK 3. + PROCEDURE, PASS(SELF), PRIVATE :: WRITE_ON_SCRATCH_DATAARRAY1_RANK4 !< WRITE DATAARRAY, DATA 1 RANK 4. + PROCEDURE, PASS(SELF), PRIVATE :: WRITE_ON_SCRATCH_DATAARRAY3_RANK1_R8P !< WRITE DATAARRAY, COMP 3 RANK 1, R8P. + PROCEDURE, PASS(SELF), PRIVATE :: WRITE_ON_SCRATCH_DATAARRAY3_RANK1_R4P !< WRITE DATAARRAY, COMP 3 RANK 1, R4P. + PROCEDURE, PASS(SELF), PRIVATE :: WRITE_ON_SCRATCH_DATAARRAY3_RANK1_I8P !< WRITE DATAARRAY, COMP 3 RANK 1, I8P. + PROCEDURE, PASS(SELF), PRIVATE :: WRITE_ON_SCRATCH_DATAARRAY3_RANK1_I4P !< WRITE DATAARRAY, COMP 3 RANK 1, I4P. + PROCEDURE, PASS(SELF), PRIVATE :: WRITE_ON_SCRATCH_DATAARRAY3_RANK1_I2P !< WRITE DATAARRAY, COMP 3 RANK 1, I2P. + PROCEDURE, PASS(SELF), PRIVATE :: WRITE_ON_SCRATCH_DATAARRAY3_RANK1_I1P !< WRITE DATAARRAY, COMP 3 RANK 1, I1P. + PROCEDURE, PASS(SELF), PRIVATE :: WRITE_ON_SCRATCH_DATAARRAY3_RANK2_R8P !< WRITE DATAARRAY, COMP 3 RANK 2, R8P. + PROCEDURE, PASS(SELF), PRIVATE :: WRITE_ON_SCRATCH_DATAARRAY3_RANK2_R4P !< WRITE DATAARRAY, COMP 3 RANK 2, R4P. + PROCEDURE, PASS(SELF), PRIVATE :: WRITE_ON_SCRATCH_DATAARRAY3_RANK2_I8P !< WRITE DATAARRAY, COMP 3 RANK 2, I8P. + PROCEDURE, PASS(SELF), PRIVATE :: WRITE_ON_SCRATCH_DATAARRAY3_RANK2_I4P !< WRITE DATAARRAY, COMP 3 RANK 2, I4P. + PROCEDURE, PASS(SELF), PRIVATE :: WRITE_ON_SCRATCH_DATAARRAY3_RANK2_I2P !< WRITE DATAARRAY, COMP 3 RANK 2, I2P. + PROCEDURE, PASS(SELF), PRIVATE :: WRITE_ON_SCRATCH_DATAARRAY3_RANK2_I1P !< WRITE DATAARRAY, COMP 3 RANK 2, I1P. + PROCEDURE, PASS(SELF), PRIVATE :: WRITE_ON_SCRATCH_DATAARRAY3_RANK3_R8P !< WRITE DATAARRAY, COMP 3 RANK 3, R8P. + PROCEDURE, PASS(SELF), PRIVATE :: WRITE_ON_SCRATCH_DATAARRAY3_RANK3_R4P !< WRITE DATAARRAY, COMP 3 RANK 3, R4P. + PROCEDURE, PASS(SELF), PRIVATE :: WRITE_ON_SCRATCH_DATAARRAY3_RANK3_I8P !< WRITE DATAARRAY, COMP 3 RANK 3, I8P. + PROCEDURE, PASS(SELF), PRIVATE :: WRITE_ON_SCRATCH_DATAARRAY3_RANK3_I4P !< WRITE DATAARRAY, COMP 3 RANK 3, I4P. + PROCEDURE, PASS(SELF), PRIVATE :: WRITE_ON_SCRATCH_DATAARRAY3_RANK3_I2P !< WRITE DATAARRAY, COMP 3 RANK 3, I2P. + PROCEDURE, PASS(SELF), PRIVATE :: WRITE_ON_SCRATCH_DATAARRAY3_RANK3_I1P !< WRITE DATAARRAY, COMP 3 RANK 3, I1P. + PROCEDURE, PASS(SELF), PRIVATE :: WRITE_ON_SCRATCH_DATAARRAY6_RANK1_R8P !< WRITE DATAARRAY, COMP 6 RANK 1, R8P. + PROCEDURE, PASS(SELF), PRIVATE :: WRITE_ON_SCRATCH_DATAARRAY6_RANK1_R4P !< WRITE DATAARRAY, COMP 6 RANK 1, R4P. + PROCEDURE, PASS(SELF), PRIVATE :: WRITE_ON_SCRATCH_DATAARRAY6_RANK1_I8P !< WRITE DATAARRAY, COMP 6 RANK 1, I8P. + PROCEDURE, PASS(SELF), PRIVATE :: WRITE_ON_SCRATCH_DATAARRAY6_RANK1_I4P !< WRITE DATAARRAY, COMP 6 RANK 1, I4P. + PROCEDURE, PASS(SELF), PRIVATE :: WRITE_ON_SCRATCH_DATAARRAY6_RANK1_I2P !< WRITE DATAARRAY, COMP 6 RANK 1, I2P. + PROCEDURE, PASS(SELF), PRIVATE :: WRITE_ON_SCRATCH_DATAARRAY6_RANK1_I1P !< WRITE DATAARRAY, COMP 6 RANK 1, I1P. + PROCEDURE, PASS(SELF), PRIVATE :: WRITE_ON_SCRATCH_DATAARRAY6_RANK2_R8P !< WRITE DATAARRAY, COMP 6 RANK 2, R8P. + PROCEDURE, PASS(SELF), PRIVATE :: WRITE_ON_SCRATCH_DATAARRAY6_RANK2_R4P !< WRITE DATAARRAY, COMP 6 RANK 2, R4P. + PROCEDURE, PASS(SELF), PRIVATE :: WRITE_ON_SCRATCH_DATAARRAY6_RANK2_I8P !< WRITE DATAARRAY, COMP 6 RANK 2, I8P. + PROCEDURE, PASS(SELF), PRIVATE :: WRITE_ON_SCRATCH_DATAARRAY6_RANK2_I4P !< WRITE DATAARRAY, COMP 6 RANK 2, I4P. + PROCEDURE, PASS(SELF), PRIVATE :: WRITE_ON_SCRATCH_DATAARRAY6_RANK2_I2P !< WRITE DATAARRAY, COMP 6 RANK 2, I2P. + PROCEDURE, PASS(SELF), PRIVATE :: WRITE_ON_SCRATCH_DATAARRAY6_RANK2_I1P !< WRITE DATAARRAY, COMP 6 RANK 2, I1P. + PROCEDURE, PASS(SELF), PRIVATE :: WRITE_ON_SCRATCH_DATAARRAY6_RANK3_R8P !< WRITE DATAARRAY, COMP 6 RANK 3, R8P. + PROCEDURE, PASS(SELF), PRIVATE :: WRITE_ON_SCRATCH_DATAARRAY6_RANK3_R4P !< WRITE DATAARRAY, COMP 6 RANK 3, R4P. + PROCEDURE, PASS(SELF), PRIVATE :: WRITE_ON_SCRATCH_DATAARRAY6_RANK3_I8P !< WRITE DATAARRAY, COMP 6 RANK 3, I8P. + PROCEDURE, PASS(SELF), PRIVATE :: WRITE_ON_SCRATCH_DATAARRAY6_RANK3_I4P !< WRITE DATAARRAY, COMP 6 RANK 3, I4P. + PROCEDURE, PASS(SELF), PRIVATE :: WRITE_ON_SCRATCH_DATAARRAY6_RANK3_I2P !< WRITE DATAARRAY, COMP 6 RANK 3, I2P. + PROCEDURE, PASS(SELF), PRIVATE :: WRITE_ON_SCRATCH_DATAARRAY6_RANK3_I1P !< WRITE DATAARRAY, COMP 6 RANK 3, I1P. +ENDTYPE XML_WRITER_APPENDED +CONTAINS + FUNCTION INITIALIZE(SELF, FORMAT, FILENAME, MESH_TOPOLOGY, NX1, NX2, NY1, NY2, NZ1, NZ2, & + IS_VOLATILE, MESH_KIND) RESULT(ERROR) + !< INITIALIZE WRITER. + CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF !< WRITER. + CHARACTER(*), INTENT(IN) :: FORMAT !< FILE FORMAT: ASCII. + CHARACTER(*), INTENT(IN) :: FILENAME !< FILE NAME. + CHARACTER(*), INTENT(IN) :: MESH_TOPOLOGY !< MESH TOPOLOGY. + INTEGER(I4P), INTENT(IN), OPTIONAL :: NX1 !< INITIAL NODE OF X AXIS. + INTEGER(I4P), INTENT(IN), OPTIONAL :: NX2 !< FINAL NODE OF X AXIS. + INTEGER(I4P), INTENT(IN), OPTIONAL :: NY1 !< INITIAL NODE OF Y AXIS. + INTEGER(I4P), INTENT(IN), OPTIONAL :: NY2 !< FINAL NODE OF Y AXIS. + INTEGER(I4P), INTENT(IN), OPTIONAL :: NZ1 !< INITIAL NODE OF Z AXIS. + INTEGER(I4P), INTENT(IN), OPTIONAL :: NZ2 !< FINAL NODE OF Z AXIS. + CHARACTER(*), INTENT(IN), OPTIONAL :: MESH_KIND !< KIND OF MESH DATA: FLOAT64, FLOAT32, ECC. + LOGICAL, INTENT(IN), OPTIONAL :: IS_VOLATILE !< FLAG TO CHECK VOLATILE WRITER. + INTEGER(I4P) :: ERROR !< ERROR STATUS. + + SELF%TOPOLOGY = TRIM(ADJUSTL(MESH_TOPOLOGY)) + SELF%FORMAT_CH = 'appended' + SELF%ENCODING = FORMAT + SELF%ENCODING = SELF%ENCODING%UPPER() + SELECT CASE(SELF%ENCODING%CHARS()) + CASE('raw') + SELF%ENCODING = 'raw' + CASE('binary-appended') + SELF%ENCODING = 'base64' + ENDSELECT + CALL SELF%OPEN_XML_FILE(FILENAME=FILENAME) + CALL SELF%WRITE_HEADER_TAG + CALL SELF%WRITE_TOPOLOGY_TAG(NX1=NX1, NX2=NX2, NY1=NY1, NY2=NY2, NZ1=NZ1, NZ2=NZ2, MESH_KIND=MESH_KIND) + SELF%IOFFSET = 0 + CALL SELF%OPEN_SCRATCH_FILE + ERROR = SELF%ERROR + ENDFUNCTION INITIALIZE + + FUNCTION FINALIZE(SELF) RESULT(ERROR) + !< FINALIZE WRITER. + CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF !< WRITER. + INTEGER(I4P) :: ERROR !< ERROR STATUS. + + CALL SELF%WRITE_END_TAG(NAME=SELF%TOPOLOGY%CHARS()) + CALL SELF%W_DATA_APPENDED + CALL SELF%WRITE_END_TAG(NAME='VTKFile') + CALL SELF%CLOSE_XML_FILE + CALL SELF%CLOSE_SCRATCH_FILE + ERROR = SELF%ERROR + ENDFUNCTION FINALIZE + + ELEMENTAL SUBROUTINE IOFFSET_UPDATE(SELF, N_BYTE) + !< UPDATE IOFFSET COUNT. + CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF !< WRITER. + INTEGER(I4P), INTENT(IN) :: N_BYTE !< NUMBER OF BYTES SAVED. + + IF (SELF%ENCODING=='raw') THEN + SELF%IOFFSET = SELF%IOFFSET + BYI4P + N_BYTE + ELSE + SELF%IOFFSET = SELF%IOFFSET + ((N_BYTE + BYI4P + 2_I4P)/3_I4P)*4_I4P + ENDIF + ENDSUBROUTINE IOFFSET_UPDATE + + SUBROUTINE OPEN_SCRATCH_FILE(SELF) + !< OPEN SCRATCH FILE. + CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF !< WRITER. + + OPEN(NEWUNIT=SELF%SCRATCH, & + FORM='UNFORMATTED', & + ACCESS='STREAM', & + ACTION='READWRITE', & + STATUS='SCRATCH', & + IOSTAT=SELF%ERROR) + ENDSUBROUTINE OPEN_SCRATCH_FILE + + SUBROUTINE CLOSE_SCRATCH_FILE(SELF) + !< CLOSE SCRATCH FILE. + CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF !< WRITER. + + CLOSE(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR) + ENDSUBROUTINE CLOSE_SCRATCH_FILE + + ! W_DATA METHODS + FUNCTION W_DATA1_RANK1_R8P(SELF, DATA_NAME, X, IS_TUPLES) RESULT(ERROR) + !< WRITE `<DATAARRAY... NumberOfComponents="1"...>...</DATAARRAY>` TAG (R8P). + CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF !< WRITER. + CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. + REAL(R8P), INTENT(IN) :: X(1:) !< DATA VARIABLE. + LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES". + INTEGER(I4P) :: ERROR !< ERROR STATUS. + CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. + INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. + + DATA_TYPE = 'Float64' + N_COMPONENTS = 1 + CALL SELF%W_DATA_TAG_APPENDED(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, & + IS_TUPLES=IS_TUPLES) + CALL SELF%IOFFSET_UPDATE(N_BYTE=SELF%WRITE_ON_SCRATCH_DATAARRAY(X=X)) + ERROR = SELF%ERROR + ENDFUNCTION W_DATA1_RANK1_R8P + + FUNCTION W_DATA1_RANK1_R4P(SELF, DATA_NAME, X, IS_TUPLES) RESULT(ERROR) + !< WRITE `<DATAARRAY... NumberOfComponents="1"...>...</DATAARRAY>` TAG (R4P). + CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF !< WRITER. + CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. + REAL(R4P), INTENT(IN) :: X(1:) !< DATA VARIABLE. + LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES". + INTEGER(I4P) :: ERROR !< ERROR STATUS. + CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. + INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. + + DATA_TYPE = 'Float32' + N_COMPONENTS = 1 + CALL SELF%W_DATA_TAG_APPENDED(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, & + IS_TUPLES=IS_TUPLES) + CALL SELF%IOFFSET_UPDATE(N_BYTE=SELF%WRITE_ON_SCRATCH_DATAARRAY(X=X)) + ERROR = SELF%ERROR + ENDFUNCTION W_DATA1_RANK1_R4P + + FUNCTION W_DATA1_RANK1_I8P(SELF, DATA_NAME, X, IS_TUPLES) RESULT(ERROR) + !< WRITE `<DATAARRAY... NumberOfComponents="1"...>...</DATAARRAY>` TAG (I8P). + CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF !< WRITER. + CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. + INTEGER(I8P), INTENT(IN) :: X(1:) !< DATA VARIABLE. + LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES". + INTEGER(I4P) :: ERROR !< ERROR STATUS. + CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. + INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. + + DATA_TYPE = 'Int64' + N_COMPONENTS = 1 + CALL SELF%W_DATA_TAG_APPENDED(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, & + IS_TUPLES=IS_TUPLES) + CALL SELF%IOFFSET_UPDATE(N_BYTE=SELF%WRITE_ON_SCRATCH_DATAARRAY(X=X)) + ERROR = SELF%ERROR + ENDFUNCTION W_DATA1_RANK1_I8P + + FUNCTION W_DATA1_RANK1_I4P(SELF, DATA_NAME, X, IS_TUPLES) RESULT(ERROR) + !< WRITE `<DATAARRAY... NumberOfComponents="1"...>...</DATAARRAY>` TAG (I4P). + CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF !< WRITER. + CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. + INTEGER(I4P), INTENT(IN) :: X(1:) !< DATA VARIABLE. + LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES". + INTEGER(I4P) :: ERROR !< ERROR STATUS. + CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. + INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. + + DATA_TYPE = 'Int32' + N_COMPONENTS = 1 + CALL SELF%W_DATA_TAG_APPENDED(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, & + IS_TUPLES=IS_TUPLES) + CALL SELF%IOFFSET_UPDATE(N_BYTE=SELF%WRITE_ON_SCRATCH_DATAARRAY(X=X)) + ERROR = SELF%ERROR + ENDFUNCTION W_DATA1_RANK1_I4P + + FUNCTION W_DATA1_RANK1_I2P(SELF, DATA_NAME, X, IS_TUPLES) RESULT(ERROR) + !< WRITE `<DATAARRAY... NumberOfComponents="1"...>...</DATAARRAY>` TAG (I2P). + CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF !< WRITER. + CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. + INTEGER(I2P), INTENT(IN) :: X(1:) !< DATA VARIABLE. + LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES". + INTEGER(I4P) :: ERROR !< ERROR STATUS. + CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. + INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. + + DATA_TYPE = 'Int16' + N_COMPONENTS = 1 + CALL SELF%W_DATA_TAG_APPENDED(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, & + IS_TUPLES=IS_TUPLES) + CALL SELF%IOFFSET_UPDATE(N_BYTE=SELF%WRITE_ON_SCRATCH_DATAARRAY(X=X)) + ERROR = SELF%ERROR + ENDFUNCTION W_DATA1_RANK1_I2P + + FUNCTION W_DATA1_RANK1_I1P(SELF, DATA_NAME, X, IS_TUPLES) RESULT(ERROR) + !< WRITE `<DATAARRAY... NumberOfComponents="1"...>...</DATAARRAY>` TAG (I1P). + CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF !< WRITER. + CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. + INTEGER(I1P), INTENT(IN) :: X(1:) !< DATA VARIABLE. + LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES". + INTEGER(I4P) :: ERROR !< ERROR STATUS. + CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. + INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. + + DATA_TYPE = 'Int8' + N_COMPONENTS = 1 + CALL SELF%W_DATA_TAG_APPENDED(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, & + IS_TUPLES=IS_TUPLES) + CALL SELF%IOFFSET_UPDATE(N_BYTE=SELF%WRITE_ON_SCRATCH_DATAARRAY(X=X)) + ERROR = SELF%ERROR + ENDFUNCTION W_DATA1_RANK1_I1P + + FUNCTION W_DATA1_RANK2_R8P(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR) + !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (R8P). + CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF !< WRITER. + CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. + REAL(R8P), INTENT(IN) :: X(1:,1:) !< DATA VARIABLE. + LOGICAL, INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT. + LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES". + INTEGER(I4P) :: ERROR !< ERROR STATUS. + CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. + INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. + + DATA_TYPE = 'Float64' + N_COMPONENTS = SIZE(X, DIM=1) + IF (PRESENT(ONE_COMPONENT)) THEN + IF (ONE_COMPONENT) N_COMPONENTS = 1 + ENDIF + CALL SELF%W_DATA_TAG_APPENDED(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, & + IS_TUPLES=IS_TUPLES) + CALL SELF%IOFFSET_UPDATE(N_BYTE=SELF%WRITE_ON_SCRATCH_DATAARRAY(X=X)) + ERROR = SELF%ERROR + ENDFUNCTION W_DATA1_RANK2_R8P + + FUNCTION W_DATA1_RANK2_R4P(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR) + !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (R4P). + CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF !< WRITER. + CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. + REAL(R4P), INTENT(IN) :: X(1:,1:) !< DATA VARIABLE. + LOGICAL, INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT. + LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES". + INTEGER(I4P) :: ERROR !< ERROR STATUS. + CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. + INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. + + DATA_TYPE = 'Float32' + N_COMPONENTS = SIZE(X, DIM=1) + IF (PRESENT(ONE_COMPONENT)) THEN + IF (ONE_COMPONENT) N_COMPONENTS = 1 + ENDIF + CALL SELF%W_DATA_TAG_APPENDED(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, & + IS_TUPLES=IS_TUPLES) + CALL SELF%IOFFSET_UPDATE(N_BYTE=SELF%WRITE_ON_SCRATCH_DATAARRAY(X=X)) + ERROR = SELF%ERROR + ENDFUNCTION W_DATA1_RANK2_R4P + + FUNCTION W_DATA1_RANK2_I8P(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR) + !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (I8P). + CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF !< WRITER. + CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. + INTEGER(I8P), INTENT(IN) :: X(1:,1:) !< DATA VARIABLE. + LOGICAL, INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT. + LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES". + INTEGER(I4P) :: ERROR !< ERROR STATUS. + CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. + INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. + + DATA_TYPE = 'Int64' + N_COMPONENTS = SIZE(X, DIM=1) + IF (PRESENT(ONE_COMPONENT)) THEN + IF (ONE_COMPONENT) N_COMPONENTS = 1 + ENDIF + CALL SELF%W_DATA_TAG_APPENDED(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, & + IS_TUPLES=IS_TUPLES) + CALL SELF%IOFFSET_UPDATE(N_BYTE=SELF%WRITE_ON_SCRATCH_DATAARRAY(X=X)) + ERROR = SELF%ERROR + ENDFUNCTION W_DATA1_RANK2_I8P + + FUNCTION W_DATA1_RANK2_I4P(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR) + !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (I4P). + CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF !< WRITER. + CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. + INTEGER(I4P), INTENT(IN) :: X(1:,1:) !< DATA VARIABLE. + LOGICAL, INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT. + LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES". + INTEGER(I4P) :: ERROR !< ERROR STATUS. + CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. + INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. + + DATA_TYPE = 'Int32' + N_COMPONENTS = SIZE(X, DIM=1) + IF (PRESENT(ONE_COMPONENT)) THEN + IF (ONE_COMPONENT) N_COMPONENTS = 1 + ENDIF + CALL SELF%W_DATA_TAG_APPENDED(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, & + IS_TUPLES=IS_TUPLES) + CALL SELF%IOFFSET_UPDATE(N_BYTE=SELF%WRITE_ON_SCRATCH_DATAARRAY(X=X)) + ERROR = SELF%ERROR + ENDFUNCTION W_DATA1_RANK2_I4P + + FUNCTION W_DATA1_RANK2_I2P(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR) + !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (I2P). + CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF !< WRITER. + CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. + INTEGER(I2P), INTENT(IN) :: X(1:,1:) !< DATA VARIABLE. + LOGICAL, INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT. + LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES". + INTEGER(I4P) :: ERROR !< ERROR STATUS. + CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. + INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. + + DATA_TYPE = 'Int16' + N_COMPONENTS = SIZE(X, DIM=1) + IF (PRESENT(ONE_COMPONENT)) THEN + IF (ONE_COMPONENT) N_COMPONENTS = 1 + ENDIF + CALL SELF%W_DATA_TAG_APPENDED(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, & + IS_TUPLES=IS_TUPLES) + CALL SELF%IOFFSET_UPDATE(N_BYTE=SELF%WRITE_ON_SCRATCH_DATAARRAY(X=X)) + ERROR = SELF%ERROR + ENDFUNCTION W_DATA1_RANK2_I2P + + FUNCTION W_DATA1_RANK2_I1P(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR) + !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (I1P). + CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF !< WRITER. + CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. + INTEGER(I1P), INTENT(IN) :: X(1:,1:) !< DATA VARIABLE. + LOGICAL, INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT. + LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES". + INTEGER(I4P) :: ERROR !< ERROR STATUS. + CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. + INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. + + DATA_TYPE = 'Int8' + N_COMPONENTS = SIZE(X, DIM=1) + IF (PRESENT(ONE_COMPONENT)) THEN + IF (ONE_COMPONENT) N_COMPONENTS = 1 + ENDIF + CALL SELF%W_DATA_TAG_APPENDED(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, & + IS_TUPLES=IS_TUPLES) + CALL SELF%IOFFSET_UPDATE(N_BYTE=SELF%WRITE_ON_SCRATCH_DATAARRAY(X=X)) + ERROR = SELF%ERROR + ENDFUNCTION W_DATA1_RANK2_I1P + + FUNCTION W_DATA1_RANK3_R8P(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR) + !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (R8P). + CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF !< WRITER. + CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. + REAL(R8P), INTENT(IN) :: X(1:,1:,1:) !< DATA VARIABLE. + LOGICAL, INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT. + LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES". + INTEGER(I4P) :: ERROR !< ERROR STATUS. + CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. + INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. + + DATA_TYPE = 'Float64' + N_COMPONENTS = SIZE(X, DIM=1) + IF (PRESENT(ONE_COMPONENT)) THEN + IF (ONE_COMPONENT) N_COMPONENTS = 1 + ENDIF + CALL SELF%W_DATA_TAG_APPENDED(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, & + IS_TUPLES=IS_TUPLES) + CALL SELF%IOFFSET_UPDATE(N_BYTE=SELF%WRITE_ON_SCRATCH_DATAARRAY(X=X)) + ERROR = SELF%ERROR + ENDFUNCTION W_DATA1_RANK3_R8P + + FUNCTION W_DATA1_RANK3_R4P(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR) + !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (R4P). + CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF !< WRITER. + CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. + REAL(R4P), INTENT(IN) :: X(1:,1:,1:) !< DATA VARIABLE. + LOGICAL, INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT. + LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES". + INTEGER(I4P) :: ERROR !< ERROR STATUS. + CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. + INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. + + DATA_TYPE = 'Float32' + N_COMPONENTS = SIZE(X, DIM=1) + IF (PRESENT(ONE_COMPONENT)) THEN + IF (ONE_COMPONENT) N_COMPONENTS = 1 + ENDIF + CALL SELF%W_DATA_TAG_APPENDED(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, & + IS_TUPLES=IS_TUPLES) + CALL SELF%IOFFSET_UPDATE(N_BYTE=SELF%WRITE_ON_SCRATCH_DATAARRAY(X=X)) + ERROR = SELF%ERROR + ENDFUNCTION W_DATA1_RANK3_R4P + + FUNCTION W_DATA1_RANK3_I8P(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR) + !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (I8P). + CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF !< WRITER. + CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. + INTEGER(I8P), INTENT(IN) :: X(1:,1:,1:) !< DATA VARIABLE. + LOGICAL, INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT. + LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES". + INTEGER(I4P) :: ERROR !< ERROR STATUS. + CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. + INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. + + DATA_TYPE = 'Int64' + N_COMPONENTS = SIZE(X, DIM=1) + IF (PRESENT(ONE_COMPONENT)) THEN + IF (ONE_COMPONENT) N_COMPONENTS = 1 + ENDIF + CALL SELF%W_DATA_TAG_APPENDED(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, & + IS_TUPLES=IS_TUPLES) + CALL SELF%IOFFSET_UPDATE(N_BYTE=SELF%WRITE_ON_SCRATCH_DATAARRAY(X=X)) + ERROR = SELF%ERROR + ENDFUNCTION W_DATA1_RANK3_I8P + + FUNCTION W_DATA1_RANK3_I4P(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR) + !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (I4P). + CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF !< WRITER. + CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. + INTEGER(I4P), INTENT(IN) :: X(1:,1:,1:) !< DATA VARIABLE. + LOGICAL, INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT. + LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES". + INTEGER(I4P) :: ERROR !< ERROR STATUS. + CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. + INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. + + DATA_TYPE = 'Int32' + N_COMPONENTS = SIZE(X, DIM=1) + IF (PRESENT(ONE_COMPONENT)) THEN + IF (ONE_COMPONENT) N_COMPONENTS = 1 + ENDIF + CALL SELF%W_DATA_TAG_APPENDED(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, & + IS_TUPLES=IS_TUPLES) + CALL SELF%IOFFSET_UPDATE(N_BYTE=SELF%WRITE_ON_SCRATCH_DATAARRAY(X=X)) + ERROR = SELF%ERROR + ENDFUNCTION W_DATA1_RANK3_I4P + + FUNCTION W_DATA1_RANK3_I2P(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR) + !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (I2P). + CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF !< WRITER. + CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. + INTEGER(I2P), INTENT(IN) :: X(1:,1:,1:) !< DATA VARIABLE. + LOGICAL, INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT. + LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES". + INTEGER(I4P) :: ERROR !< ERROR STATUS. + CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. + INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. + + DATA_TYPE = 'Int16' + N_COMPONENTS = SIZE(X, DIM=1) + IF (PRESENT(ONE_COMPONENT)) THEN + IF (ONE_COMPONENT) N_COMPONENTS = 1 + ENDIF + CALL SELF%W_DATA_TAG_APPENDED(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, & + IS_TUPLES=IS_TUPLES) + CALL SELF%IOFFSET_UPDATE(N_BYTE=SELF%WRITE_ON_SCRATCH_DATAARRAY(X=X)) + ERROR = SELF%ERROR + ENDFUNCTION W_DATA1_RANK3_I2P + + FUNCTION W_DATA1_RANK3_I1P(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR) + !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (I1P). + CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF !< WRITER. + CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. + INTEGER(I1P), INTENT(IN) :: X(1:,1:,1:) !< DATA VARIABLE. + LOGICAL, INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT. + LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES". + INTEGER(I4P) :: ERROR !< ERROR STATUS. + CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. + INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. + + DATA_TYPE = 'Int8' + N_COMPONENTS = SIZE(X, DIM=1) + IF (PRESENT(ONE_COMPONENT)) THEN + IF (ONE_COMPONENT) N_COMPONENTS = 1 + ENDIF + CALL SELF%W_DATA_TAG_APPENDED(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, & + IS_TUPLES=IS_TUPLES) + CALL SELF%IOFFSET_UPDATE(N_BYTE=SELF%WRITE_ON_SCRATCH_DATAARRAY(X=X)) + ERROR = SELF%ERROR + ENDFUNCTION W_DATA1_RANK3_I1P + + FUNCTION W_DATA1_RANK4_R8P(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR) + !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (R8P). + CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF !< WRITER. + CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. + REAL(R8P), INTENT(IN) :: X(1:,1:,1:,1:) !< DATA VARIABLE. + LOGICAL, INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT. + LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES". + INTEGER(I4P) :: ERROR !< ERROR STATUS. + CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. + INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. + + DATA_TYPE = 'Float64' + N_COMPONENTS = SIZE(X, DIM=1) + IF (PRESENT(ONE_COMPONENT)) THEN + IF (ONE_COMPONENT) N_COMPONENTS = 1 + ENDIF + CALL SELF%W_DATA_TAG_APPENDED(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, & + IS_TUPLES=IS_TUPLES) + CALL SELF%IOFFSET_UPDATE(N_BYTE=SELF%WRITE_ON_SCRATCH_DATAARRAY(X=X)) + ERROR = SELF%ERROR + ENDFUNCTION W_DATA1_RANK4_R8P + + FUNCTION W_DATA1_RANK4_R4P(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR) + !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (R4P). + CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF !< WRITER. + CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. + REAL(R4P), INTENT(IN) :: X(1:,1:,1:,1:) !< DATA VARIABLE. + LOGICAL, INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT. + LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES". + INTEGER(I4P) :: ERROR !< ERROR STATUS. + CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. + INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. + + DATA_TYPE = 'Float32' + N_COMPONENTS = SIZE(X, DIM=1) + IF (PRESENT(ONE_COMPONENT)) THEN + IF (ONE_COMPONENT) N_COMPONENTS = 1 + ENDIF + CALL SELF%W_DATA_TAG_APPENDED(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, & + IS_TUPLES=IS_TUPLES) + CALL SELF%IOFFSET_UPDATE(N_BYTE=SELF%WRITE_ON_SCRATCH_DATAARRAY(X=X)) + ERROR = SELF%ERROR + ENDFUNCTION W_DATA1_RANK4_R4P + + FUNCTION W_DATA1_RANK4_I8P(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR) + !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (I8P). + CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF !< WRITER. + CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. + INTEGER(I8P), INTENT(IN) :: X(1:,1:,1:,1:) !< DATA VARIABLE. + LOGICAL, INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT. + LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES". + INTEGER(I4P) :: ERROR !< ERROR STATUS. + CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. + INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. + + DATA_TYPE = 'Int64' + N_COMPONENTS = SIZE(X, DIM=1) + IF (PRESENT(ONE_COMPONENT)) THEN + IF (ONE_COMPONENT) N_COMPONENTS = 1 + ENDIF + CALL SELF%W_DATA_TAG_APPENDED(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, & + IS_TUPLES=IS_TUPLES) + CALL SELF%IOFFSET_UPDATE(N_BYTE=SELF%WRITE_ON_SCRATCH_DATAARRAY(X=X)) + ERROR = SELF%ERROR + ENDFUNCTION W_DATA1_RANK4_I8P + + FUNCTION W_DATA1_RANK4_I4P(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR) + !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (I4P). + CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF !< WRITER. + CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. + INTEGER(I4P), INTENT(IN) :: X(1:,1:,1:,1:) !< DATA VARIABLE. + LOGICAL, INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT. + LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES". + INTEGER(I4P) :: ERROR !< ERROR STATUS. + CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. + INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. + + DATA_TYPE = 'Int32' + N_COMPONENTS = SIZE(X, DIM=1) + IF (PRESENT(ONE_COMPONENT)) THEN + IF (ONE_COMPONENT) N_COMPONENTS = 1 + ENDIF + CALL SELF%W_DATA_TAG_APPENDED(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, & + IS_TUPLES=IS_TUPLES) + CALL SELF%IOFFSET_UPDATE(N_BYTE=SELF%WRITE_ON_SCRATCH_DATAARRAY(X=X)) + ERROR = SELF%ERROR + ENDFUNCTION W_DATA1_RANK4_I4P + + FUNCTION W_DATA1_RANK4_I2P(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR) + !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (I2P). + CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF !< WRITER. + CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. + INTEGER(I2P), INTENT(IN) :: X(1:,1:,1:,1:) !< DATA VARIABLE. + LOGICAL, INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT. + LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES". + INTEGER(I4P) :: ERROR !< ERROR STATUS. + CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. + INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. + + DATA_TYPE = 'Int16' + N_COMPONENTS = SIZE(X, DIM=1) + IF (PRESENT(ONE_COMPONENT)) THEN + IF (ONE_COMPONENT) N_COMPONENTS = 1 + ENDIF + CALL SELF%W_DATA_TAG_APPENDED(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, & + IS_TUPLES=IS_TUPLES) + CALL SELF%IOFFSET_UPDATE(N_BYTE=SELF%WRITE_ON_SCRATCH_DATAARRAY(X=X)) + ERROR = SELF%ERROR + ENDFUNCTION W_DATA1_RANK4_I2P + + FUNCTION W_DATA1_RANK4_I1P(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR) + !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (I1P). + CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF !< WRITER. + CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. + INTEGER(I1P), INTENT(IN) :: X(1:,1:,1:,1:) !< DATA VARIABLE. + LOGICAL, INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT. + LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES". + INTEGER(I4P) :: ERROR !< ERROR STATUS. + CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. + INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. + + DATA_TYPE = 'Int8' + N_COMPONENTS = SIZE(X, DIM=1) + IF (PRESENT(ONE_COMPONENT)) THEN + IF (ONE_COMPONENT) N_COMPONENTS = 1 + ENDIF + CALL SELF%W_DATA_TAG_APPENDED(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, & + IS_TUPLES=IS_TUPLES) + CALL SELF%IOFFSET_UPDATE(N_BYTE=SELF%WRITE_ON_SCRATCH_DATAARRAY(X=X)) + ERROR = SELF%ERROR + ENDFUNCTION W_DATA1_RANK4_I1P + + FUNCTION W_DATA3_RANK1_R8P(SELF, DATA_NAME, X, Y, Z, IS_TUPLES) RESULT(ERROR) + !< WRITE `<DATAARRAY... NumberOfComponents="3"...>...</DATAARRAY>` TAG (R8P). + CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF !< WRITER. + CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. + REAL(R8P), INTENT(IN) :: X(1:) !< X COMPONENT OF DATA VARIABLE. + REAL(R8P), INTENT(IN) :: Y(1:) !< Y COMPONENT OF DATA VARIABLE. + REAL(R8P), INTENT(IN) :: Z(1:) !< Z COMPONENT OF DATA VARIABLE. + LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD "NUMBEROFCOMPONENTS" ATTRIBUTE. + INTEGER(I4P) :: ERROR !< ERROR STATUS. + CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. + INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. + + DATA_TYPE = 'Float64' + N_COMPONENTS = 3 + CALL SELF%W_DATA_TAG_APPENDED(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, & + IS_TUPLES=IS_TUPLES) + CALL SELF%IOFFSET_UPDATE(N_BYTE=SELF%WRITE_ON_SCRATCH_DATAARRAY(X=X, Y=Y, Z=Z)) + ERROR = SELF%ERROR + ENDFUNCTION W_DATA3_RANK1_R8P + + FUNCTION W_DATA3_RANK1_R4P(SELF, DATA_NAME, X, Y, Z, IS_TUPLES) RESULT(ERROR) + !< WRITE `<DATAARRAY... NumberOfComponents="3"...>...</DATAARRAY>` TAG (R4P). + CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF !< WRITER. + CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. + REAL(R4P), INTENT(IN) :: X(1:) !< X COMPONENT OF DATA VARIABLE. + REAL(R4P), INTENT(IN) :: Y(1:) !< Y COMPONENT OF DATA VARIABLE. + REAL(R4P), INTENT(IN) :: Z(1:) !< Z COMPONENT OF DATA VARIABLE. + LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES". + INTEGER(I4P) :: ERROR !< ERROR STATUS. + CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. + INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. + + DATA_TYPE = 'Float32' + N_COMPONENTS = 3 + CALL SELF%W_DATA_TAG_APPENDED(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, & + IS_TUPLES=IS_TUPLES) + CALL SELF%IOFFSET_UPDATE(N_BYTE=SELF%WRITE_ON_SCRATCH_DATAARRAY(X=X, Y=Y, Z=Z)) + ERROR = SELF%ERROR + ENDFUNCTION W_DATA3_RANK1_R4P + + FUNCTION W_DATA3_RANK1_I8P(SELF, DATA_NAME, X, Y, Z, IS_TUPLES) RESULT(ERROR) + !< WRITE `<DATAARRAY... NumberOfComponents="3"...>...</DATAARRAY>` TAG (I8P). + CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF !< WRITER. + CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. + INTEGER(I8P), INTENT(IN) :: X(1:) !< X COMPONENT OF DATA VARIABLE. + INTEGER(I8P), INTENT(IN) :: Y(1:) !< Y COMPONENT OF DATA VARIABLE. + INTEGER(I8P), INTENT(IN) :: Z(1:) !< Z COMPONENT OF DATA VARIABLE. + LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES". + INTEGER(I4P) :: ERROR !< ERROR STATUS. + CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. + INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. + + DATA_TYPE = 'Int64' + N_COMPONENTS = 3 + CALL SELF%W_DATA_TAG_APPENDED(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, & + IS_TUPLES=IS_TUPLES) + CALL SELF%IOFFSET_UPDATE(N_BYTE=SELF%WRITE_ON_SCRATCH_DATAARRAY(X=X, Y=Y, Z=Z)) + ERROR = SELF%ERROR + ENDFUNCTION W_DATA3_RANK1_I8P + + FUNCTION W_DATA3_RANK1_I4P(SELF, DATA_NAME, X, Y, Z, IS_TUPLES) RESULT(ERROR) + !< WRITE `<DATAARRAY... NumberOfComponents="3"...>...</DATAARRAY>` TAG (I4P). + CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF !< WRITER. + CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. + INTEGER(I4P), INTENT(IN) :: X(1:) !< X COMPONENT OF DATA VARIABLE. + INTEGER(I4P), INTENT(IN) :: Y(1:) !< Y COMPONENT OF DATA VARIABLE. + INTEGER(I4P), INTENT(IN) :: Z(1:) !< Z COMPONENT OF DATA VARIABLE. + LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES". + INTEGER(I4P) :: ERROR !< ERROR STATUS. + CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. + INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. + + DATA_TYPE = 'Int32' + N_COMPONENTS = 3 + CALL SELF%W_DATA_TAG_APPENDED(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, & + IS_TUPLES=IS_TUPLES) + CALL SELF%IOFFSET_UPDATE(N_BYTE=SELF%WRITE_ON_SCRATCH_DATAARRAY(X=X, Y=Y, Z=Z)) + ERROR = SELF%ERROR + ENDFUNCTION W_DATA3_RANK1_I4P + + FUNCTION W_DATA3_RANK1_I2P(SELF, DATA_NAME, X, Y, Z, IS_TUPLES) RESULT(ERROR) + !< WRITE `<DATAARRAY... NumberOfComponents="3"...>...</DATAARRAY>` TAG (I2P). + CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF !< WRITER. + CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. + INTEGER(I2P), INTENT(IN) :: X(1:) !< X COMPONENT OF DATA VARIABLE. + INTEGER(I2P), INTENT(IN) :: Y(1:) !< Y COMPONENT OF DATA VARIABLE. + INTEGER(I2P), INTENT(IN) :: Z(1:) !< Z COMPONENT OF DATA VARIABLE. + LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES". + INTEGER(I4P) :: ERROR !< ERROR STATUS. + CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. + INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. + + DATA_TYPE = 'Int16' + N_COMPONENTS = 3 + CALL SELF%W_DATA_TAG_APPENDED(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, & + IS_TUPLES=IS_TUPLES) + CALL SELF%IOFFSET_UPDATE(N_BYTE=SELF%WRITE_ON_SCRATCH_DATAARRAY(X=X, Y=Y, Z=Z)) + ERROR = SELF%ERROR + ENDFUNCTION W_DATA3_RANK1_I2P + + FUNCTION W_DATA3_RANK1_I1P(SELF, DATA_NAME, X, Y, Z, IS_TUPLES) RESULT(ERROR) + !< WRITE `<DATAARRAY... NumberOfComponents="3"...>...</DATAARRAY>` TAG (I1P). + CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF !< WRITER. + CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. + INTEGER(I1P), INTENT(IN) :: X(1:) !< X COMPONENT OF DATA VARIABLE. + INTEGER(I1P), INTENT(IN) :: Y(1:) !< Y COMPONENT OF DATA VARIABLE. + INTEGER(I1P), INTENT(IN) :: Z(1:) !< Z COMPONENT OF DATA VARIABLE. + LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES". + INTEGER(I4P) :: ERROR !< ERROR STATUS. + CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. + INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. + + DATA_TYPE = 'Int8' + N_COMPONENTS = 3 + CALL SELF%W_DATA_TAG_APPENDED(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, & + IS_TUPLES=IS_TUPLES) + CALL SELF%IOFFSET_UPDATE(N_BYTE=SELF%WRITE_ON_SCRATCH_DATAARRAY(X=X, Y=Y, Z=Z)) + ERROR = SELF%ERROR + ENDFUNCTION W_DATA3_RANK1_I1P + + FUNCTION W_DATA3_RANK3_R8P(SELF, DATA_NAME, X, Y, Z, IS_TUPLES) RESULT(ERROR) + !< WRITE `<DATAARRAY... NumberOfComponents="3"...>...</DATAARRAY>` TAG (R8P). + CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF !< WRITER. + CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. + REAL(R8P), INTENT(IN) :: X(1:,1:,1:) !< X COMPONENT OF DATA VARIABLE. + REAL(R8P), INTENT(IN) :: Y(1:,1:,1:) !< Y COMPONENT OF DATA VARIABLE. + REAL(R8P), INTENT(IN) :: Z(1:,1:,1:) !< Z COMPONENT OF DATA VARIABLE. + LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES". + INTEGER(I4P) :: ERROR !< ERROR STATUS. + CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. + INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. + + DATA_TYPE = 'Float64' + N_COMPONENTS = 3 + CALL SELF%W_DATA_TAG_APPENDED(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, & + IS_TUPLES=IS_TUPLES) + CALL SELF%IOFFSET_UPDATE(N_BYTE=SELF%WRITE_ON_SCRATCH_DATAARRAY(X=X, Y=Y, Z=Z)) + ERROR = SELF%ERROR + ENDFUNCTION W_DATA3_RANK3_R8P + + FUNCTION W_DATA3_RANK3_R4P(SELF, DATA_NAME, X, Y, Z, IS_TUPLES) RESULT(ERROR) + !< WRITE `<DATAARRAY... NumberOfComponents="3"...>...</DATAARRAY>` TAG (R4P). + CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF !< WRITER. + CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. + REAL(R4P), INTENT(IN) :: X(1:,1:,1:) !< X COMPONENT OF DATA VARIABLE. + REAL(R4P), INTENT(IN) :: Y(1:,1:,1:) !< Y COMPONENT OF DATA VARIABLE. + REAL(R4P), INTENT(IN) :: Z(1:,1:,1:) !< Z COMPONENT OF DATA VARIABLE. + LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES". + INTEGER(I4P) :: ERROR !< ERROR STATUS. + CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. + INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. + + DATA_TYPE = 'Float32' + N_COMPONENTS = 3 + CALL SELF%W_DATA_TAG_APPENDED(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, & + IS_TUPLES=IS_TUPLES) + CALL SELF%IOFFSET_UPDATE(N_BYTE=SELF%WRITE_ON_SCRATCH_DATAARRAY(X=X, Y=Y, Z=Z)) + ERROR = SELF%ERROR + ENDFUNCTION W_DATA3_RANK3_R4P + + FUNCTION W_DATA3_RANK3_I8P(SELF, DATA_NAME, X, Y, Z, IS_TUPLES) RESULT(ERROR) + !< WRITE `<DATAARRAY... NumberOfComponents="3"...>...</DATAARRAY>` TAG (I8P). + CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF !< WRITER. + CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. + INTEGER(I8P), INTENT(IN) :: X(1:,1:,1:) !< X COMPONENT OF DATA VARIABLE. + INTEGER(I8P), INTENT(IN) :: Y(1:,1:,1:) !< Y COMPONENT OF DATA VARIABLE. + INTEGER(I8P), INTENT(IN) :: Z(1:,1:,1:) !< Z COMPONENT OF DATA VARIABLE. + LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES". + INTEGER(I4P) :: ERROR !< ERROR STATUS. + CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. + INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. + + DATA_TYPE = 'Int64' + N_COMPONENTS = 3 + CALL SELF%W_DATA_TAG_APPENDED(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, & + IS_TUPLES=IS_TUPLES) + CALL SELF%IOFFSET_UPDATE(N_BYTE=SELF%WRITE_ON_SCRATCH_DATAARRAY(X=X, Y=Y, Z=Z)) + ERROR = SELF%ERROR + ENDFUNCTION W_DATA3_RANK3_I8P + + FUNCTION W_DATA3_RANK3_I4P(SELF, DATA_NAME, X, Y, Z, IS_TUPLES) RESULT(ERROR) + !< WRITE `<DATAARRAY... NumberOfComponents="3"...>...</DATAARRAY>` TAG (I4P). + CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF !< WRITER. + CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. + INTEGER(I4P), INTENT(IN) :: X(1:,1:,1:) !< X COMPONENT OF DATA VARIABLE. + INTEGER(I4P), INTENT(IN) :: Y(1:,1:,1:) !< Y COMPONENT OF DATA VARIABLE. + INTEGER(I4P), INTENT(IN) :: Z(1:,1:,1:) !< Z COMPONENT OF DATA VARIABLE. + LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES". + INTEGER(I4P) :: ERROR !< ERROR STATUS. + CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. + INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. + + DATA_TYPE = 'Int32' + N_COMPONENTS = 3 + CALL SELF%W_DATA_TAG_APPENDED(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, & + IS_TUPLES=IS_TUPLES) + CALL SELF%IOFFSET_UPDATE(N_BYTE=SELF%WRITE_ON_SCRATCH_DATAARRAY(X=X, Y=Y, Z=Z)) + ERROR = SELF%ERROR + ENDFUNCTION W_DATA3_RANK3_I4P + + FUNCTION W_DATA3_RANK3_I2P(SELF, DATA_NAME, X, Y, Z, IS_TUPLES) RESULT(ERROR) + !< WRITE `<DATAARRAY... NumberOfComponents="3"...>...</DATAARRAY>` TAG (I2P). + CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF !< WRITER. + CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. + INTEGER(I2P), INTENT(IN) :: X(1:,1:,1:) !< X COMPONENT OF DATA VARIABLE. + INTEGER(I2P), INTENT(IN) :: Y(1:,1:,1:) !< Y COMPONENT OF DATA VARIABLE. + INTEGER(I2P), INTENT(IN) :: Z(1:,1:,1:) !< Z COMPONENT OF DATA VARIABLE. + LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES". + INTEGER(I4P) :: ERROR !< ERROR STATUS. + CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. + INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. + + DATA_TYPE = 'Int16' + N_COMPONENTS = 3 + CALL SELF%W_DATA_TAG_APPENDED(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, & + IS_TUPLES=IS_TUPLES) + CALL SELF%IOFFSET_UPDATE(N_BYTE=SELF%WRITE_ON_SCRATCH_DATAARRAY(X=X, Y=Y, Z=Z)) + ERROR = SELF%ERROR + ENDFUNCTION W_DATA3_RANK3_I2P + + FUNCTION W_DATA3_RANK3_I1P(SELF, DATA_NAME, X, Y, Z, IS_TUPLES) RESULT(ERROR) + !< WRITE `<DATAARRAY... NumberOfComponents="3"...>...</DATAARRAY>` TAG (I1P). + CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF !< WRITER. + CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. + INTEGER(I1P), INTENT(IN) :: X(1:,1:,1:) !< X COMPONENT OF DATA VARIABLE. + INTEGER(I1P), INTENT(IN) :: Y(1:,1:,1:) !< Y COMPONENT OF DATA VARIABLE. + INTEGER(I1P), INTENT(IN) :: Z(1:,1:,1:) !< Z COMPONENT OF DATA VARIABLE. + LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES". + INTEGER(I4P) :: ERROR !< ERROR STATUS. + CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. + INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. + + DATA_TYPE = 'Int8' + N_COMPONENTS = 3 + CALL SELF%W_DATA_TAG_APPENDED(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, & + IS_TUPLES=IS_TUPLES) + CALL SELF%IOFFSET_UPDATE(N_BYTE=SELF%WRITE_ON_SCRATCH_DATAARRAY(X=X, Y=Y, Z=Z)) + ERROR = SELF%ERROR + ENDFUNCTION W_DATA3_RANK3_I1P + + FUNCTION W_DATA6_RANK1_R8P(SELF, DATA_NAME, U, V, W, X, Y, Z, IS_TUPLES) RESULT(ERROR) + !< WRITE `<DATAARRAY... NumberOfComponents="3"...>...</DATAARRAY>` TAG (R8P). + CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF !< WRITER. + CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. + REAL(R8P), INTENT(IN) :: U(1:) !< U COMPONENT OF DATA VARIABLE. + REAL(R8P), INTENT(IN) :: V(1:) !< V COMPONENT OF DATA VARIABLE. + REAL(R8P), INTENT(IN) :: W(1:) !< W COMPONENT OF DATA VARIABLE. + REAL(R8P), INTENT(IN) :: X(1:) !< X COMPONENT OF DATA VARIABLE. + REAL(R8P), INTENT(IN) :: Y(1:) !< Y COMPONENT OF DATA VARIABLE. + REAL(R8P), INTENT(IN) :: Z(1:) !< Z COMPONENT OF DATA VARIABLE. + LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD "NUMBEROFCOMPONENTS" ATTRIBUTE. + INTEGER(I4P) :: ERROR !< ERROR STATUS. + CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. + INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. + + DATA_TYPE = 'Float64' + N_COMPONENTS = 6 + CALL SELF%W_DATA_TAG_APPENDED(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, & + IS_TUPLES=IS_TUPLES) + CALL SELF%IOFFSET_UPDATE(N_BYTE=SELF%WRITE_ON_SCRATCH_DATAARRAY(U=U, V=V, W=W, X=X, Y=Y, Z=Z)) + ERROR = SELF%ERROR + ENDFUNCTION W_DATA6_RANK1_R8P + + FUNCTION W_DATA6_RANK1_R4P(SELF, DATA_NAME, U, V, W, X, Y, Z, IS_TUPLES) RESULT(ERROR) + !< WRITE `<DATAARRAY... NumberOfComponents="3"...>...</DATAARRAY>` TAG (R4P). + CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF !< WRITER. + CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. + REAL(R4P), INTENT(IN) :: U(1:) !< U COMPONENT OF DATA VARIABLE. + REAL(R4P), INTENT(IN) :: V(1:) !< V COMPONENT OF DATA VARIABLE. + REAL(R4P), INTENT(IN) :: W(1:) !< W COMPONENT OF DATA VARIABLE. + REAL(R4P), INTENT(IN) :: X(1:) !< X COMPONENT OF DATA VARIABLE. + REAL(R4P), INTENT(IN) :: Y(1:) !< Y COMPONENT OF DATA VARIABLE. + REAL(R4P), INTENT(IN) :: Z(1:) !< Z COMPONENT OF DATA VARIABLE. + LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES". + INTEGER(I4P) :: ERROR !< ERROR STATUS. + CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. + INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. + + DATA_TYPE = 'Float32' + N_COMPONENTS = 6 + CALL SELF%W_DATA_TAG_APPENDED(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, & + IS_TUPLES=IS_TUPLES) + CALL SELF%IOFFSET_UPDATE(N_BYTE=SELF%WRITE_ON_SCRATCH_DATAARRAY(U=U, V=V, W=W, X=X, Y=Y, Z=Z)) + ERROR = SELF%ERROR + ENDFUNCTION W_DATA6_RANK1_R4P + + FUNCTION W_DATA6_RANK1_I8P(SELF, DATA_NAME, U, V, W, X, Y, Z, IS_TUPLES) RESULT(ERROR) + !< WRITE `<DATAARRAY... NumberOfComponents="6"...>...</DATAARRAY>` TAG (I8P). + CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF !< WRITER. + CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. + INTEGER(I8P), INTENT(IN) :: U(1:) !< U COMPONENT OF DATA VARIABLE. + INTEGER(I8P), INTENT(IN) :: V(1:) !< V COMPONENT OF DATA VARIABLE. + INTEGER(I8P), INTENT(IN) :: W(1:) !< W COMPONENT OF DATA VARIABLE. + INTEGER(I8P), INTENT(IN) :: X(1:) !< X COMPONENT OF DATA VARIABLE. + INTEGER(I8P), INTENT(IN) :: Y(1:) !< Y COMPONENT OF DATA VARIABLE. + INTEGER(I8P), INTENT(IN) :: Z(1:) !< Z COMPONENT OF DATA VARIABLE. + LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES". + INTEGER(I4P) :: ERROR !< ERROR STATUS. + CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. + INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. + + DATA_TYPE = 'Int64' + N_COMPONENTS = 6 + CALL SELF%W_DATA_TAG_APPENDED(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, & + IS_TUPLES=IS_TUPLES) + CALL SELF%IOFFSET_UPDATE(N_BYTE=SELF%WRITE_ON_SCRATCH_DATAARRAY(U=U, V=V, W=W, X=X, Y=Y, Z=Z)) + ERROR = SELF%ERROR + ENDFUNCTION W_DATA6_RANK1_I8P + + FUNCTION W_DATA6_RANK1_I4P(SELF, DATA_NAME, U, V, W, X, Y, Z, IS_TUPLES) RESULT(ERROR) + !< WRITE `<DATAARRAY... NumberOfComponents="6"...>...</DATAARRAY>` TAG (I4P). + CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF !< WRITER. + CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. + INTEGER(I4P), INTENT(IN) :: U(1:) !< U COMPONENT OF DATA VARIABLE. + INTEGER(I4P), INTENT(IN) :: V(1:) !< V COMPONENT OF DATA VARIABLE. + INTEGER(I4P), INTENT(IN) :: W(1:) !< W COMPONENT OF DATA VARIABLE. + INTEGER(I4P), INTENT(IN) :: X(1:) !< X COMPONENT OF DATA VARIABLE. + INTEGER(I4P), INTENT(IN) :: Y(1:) !< Y COMPONENT OF DATA VARIABLE. + INTEGER(I4P), INTENT(IN) :: Z(1:) !< Z COMPONENT OF DATA VARIABLE. + LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES". + INTEGER(I4P) :: ERROR !< ERROR STATUS. + CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. + INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. + + DATA_TYPE = 'Int32' + N_COMPONENTS = 6 + CALL SELF%W_DATA_TAG_APPENDED(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, & + IS_TUPLES=IS_TUPLES) + CALL SELF%IOFFSET_UPDATE(N_BYTE=SELF%WRITE_ON_SCRATCH_DATAARRAY(U=U, V=V, W=W, X=X, Y=Y, Z=Z)) + ERROR = SELF%ERROR + ENDFUNCTION W_DATA6_RANK1_I4P + + FUNCTION W_DATA6_RANK1_I2P(SELF, DATA_NAME, U, V, W, X, Y, Z, IS_TUPLES) RESULT(ERROR) + !< WRITE `<DATAARRAY... NumberOfComponents="6"...>...</DATAARRAY>` TAG (I2P). + CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF !< WRITER. + CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. + INTEGER(I2P), INTENT(IN) :: U(1:) !< U COMPONENT OF DATA VARIABLE. + INTEGER(I2P), INTENT(IN) :: V(1:) !< V COMPONENT OF DATA VARIABLE. + INTEGER(I2P), INTENT(IN) :: W(1:) !< W COMPONENT OF DATA VARIABLE. + INTEGER(I2P), INTENT(IN) :: X(1:) !< X COMPONENT OF DATA VARIABLE. + INTEGER(I2P), INTENT(IN) :: Y(1:) !< Y COMPONENT OF DATA VARIABLE. + INTEGER(I2P), INTENT(IN) :: Z(1:) !< Z COMPONENT OF DATA VARIABLE. + LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES". + INTEGER(I4P) :: ERROR !< ERROR STATUS. + CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. + INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. + + DATA_TYPE = 'Int16' + N_COMPONENTS = 6 + CALL SELF%W_DATA_TAG_APPENDED(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, & + IS_TUPLES=IS_TUPLES) + CALL SELF%IOFFSET_UPDATE(N_BYTE=SELF%WRITE_ON_SCRATCH_DATAARRAY(U=U, V=V, W=W, X=X, Y=Y, Z=Z)) + ERROR = SELF%ERROR + ENDFUNCTION W_DATA6_RANK1_I2P + + FUNCTION W_DATA6_RANK1_I1P(SELF, DATA_NAME, U, V, W, X, Y, Z, IS_TUPLES) RESULT(ERROR) + !< WRITE `<DATAARRAY... NumberOfComponents="6"...>...</DATAARRAY>` TAG (I1P). + CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF !< WRITER. + CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. + INTEGER(I1P), INTENT(IN) :: U(1:) !< U COMPONENT OF DATA VARIABLE. + INTEGER(I1P), INTENT(IN) :: V(1:) !< V COMPONENT OF DATA VARIABLE. + INTEGER(I1P), INTENT(IN) :: W(1:) !< W COMPONENT OF DATA VARIABLE. + INTEGER(I1P), INTENT(IN) :: X(1:) !< X COMPONENT OF DATA VARIABLE. + INTEGER(I1P), INTENT(IN) :: Y(1:) !< Y COMPONENT OF DATA VARIABLE. + INTEGER(I1P), INTENT(IN) :: Z(1:) !< Z COMPONENT OF DATA VARIABLE. + LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES". + INTEGER(I4P) :: ERROR !< ERROR STATUS. + CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. + INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. + + DATA_TYPE = 'Int8' + N_COMPONENTS = 6 + CALL SELF%W_DATA_TAG_APPENDED(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, & + IS_TUPLES=IS_TUPLES) + CALL SELF%IOFFSET_UPDATE(N_BYTE=SELF%WRITE_ON_SCRATCH_DATAARRAY(U=U, V=V, W=W, X=X, Y=Y, Z=Z)) + ERROR = SELF%ERROR + ENDFUNCTION W_DATA6_RANK1_I1P + + FUNCTION W_DATA6_RANK3_R8P(SELF, DATA_NAME, U, V, W, X, Y, Z, IS_TUPLES) RESULT(ERROR) + !< WRITE `<DATAARRAY... NumberOfComponents="6"...>...</DATAARRAY>` TAG (R8P). + CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF !< WRITER. + CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. + REAL(R8P), INTENT(IN) :: U(1:,1:,1:) !< U COMPONENT OF DATA VARIABLE. + REAL(R8P), INTENT(IN) :: V(1:,1:,1:) !< V COMPONENT OF DATA VARIABLE. + REAL(R8P), INTENT(IN) :: W(1:,1:,1:) !< W COMPONENT OF DATA VARIABLE. + REAL(R8P), INTENT(IN) :: X(1:,1:,1:) !< X COMPONENT OF DATA VARIABLE. + REAL(R8P), INTENT(IN) :: Y(1:,1:,1:) !< Y COMPONENT OF DATA VARIABLE. + REAL(R8P), INTENT(IN) :: Z(1:,1:,1:) !< Z COMPONENT OF DATA VARIABLE. + LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES". + INTEGER(I4P) :: ERROR !< ERROR STATUS. + CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. + INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. + + DATA_TYPE = 'Float64' + N_COMPONENTS = 6 + CALL SELF%W_DATA_TAG_APPENDED(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, & + IS_TUPLES=IS_TUPLES) + CALL SELF%IOFFSET_UPDATE(N_BYTE=SELF%WRITE_ON_SCRATCH_DATAARRAY(U=U, V=V, W=W, X=X, Y=Y, Z=Z)) + ERROR = SELF%ERROR + ENDFUNCTION W_DATA6_RANK3_R8P + + FUNCTION W_DATA6_RANK3_R4P(SELF, DATA_NAME, U, V, W, X, Y, Z, IS_TUPLES) RESULT(ERROR) + !< WRITE `<DATAARRAY... NumberOfComponents="6"...>...</DATAARRAY>` TAG (R4P). + CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF !< WRITER. + CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. + REAL(R4P), INTENT(IN) :: U(1:,1:,1:) !< U COMPONENT OF DATA VARIABLE. + REAL(R4P), INTENT(IN) :: V(1:,1:,1:) !< V COMPONENT OF DATA VARIABLE. + REAL(R4P), INTENT(IN) :: W(1:,1:,1:) !< W COMPONENT OF DATA VARIABLE. + REAL(R4P), INTENT(IN) :: X(1:,1:,1:) !< X COMPONENT OF DATA VARIABLE. + REAL(R4P), INTENT(IN) :: Y(1:,1:,1:) !< Y COMPONENT OF DATA VARIABLE. + REAL(R4P), INTENT(IN) :: Z(1:,1:,1:) !< Z COMPONENT OF DATA VARIABLE. + LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES". + INTEGER(I4P) :: ERROR !< ERROR STATUS. + CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. + INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. + + DATA_TYPE = 'Float32' + N_COMPONENTS = 6 + CALL SELF%W_DATA_TAG_APPENDED(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, & + IS_TUPLES=IS_TUPLES) + CALL SELF%IOFFSET_UPDATE(N_BYTE=SELF%WRITE_ON_SCRATCH_DATAARRAY(U=U, V=V, W=W, X=X, Y=Y, Z=Z)) + ERROR = SELF%ERROR + ENDFUNCTION W_DATA6_RANK3_R4P + + FUNCTION W_DATA6_RANK3_I8P(SELF, DATA_NAME, U, V, W, X, Y, Z, IS_TUPLES) RESULT(ERROR) + !< WRITE `<DATAARRAY... NumberOfComponents="3"...>...</DATAARRAY>` TAG (I8P). + CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF !< WRITER. + CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. + INTEGER(I8P), INTENT(IN) :: U(1:,1:,1:) !< U COMPONENT OF DATA VARIABLE. + INTEGER(I8P), INTENT(IN) :: V(1:,1:,1:) !< V COMPONENT OF DATA VARIABLE. + INTEGER(I8P), INTENT(IN) :: W(1:,1:,1:) !< W COMPONENT OF DATA VARIABLE. + INTEGER(I8P), INTENT(IN) :: X(1:,1:,1:) !< X COMPONENT OF DATA VARIABLE. + INTEGER(I8P), INTENT(IN) :: Y(1:,1:,1:) !< Y COMPONENT OF DATA VARIABLE. + INTEGER(I8P), INTENT(IN) :: Z(1:,1:,1:) !< Z COMPONENT OF DATA VARIABLE. + LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES". + INTEGER(I4P) :: ERROR !< ERROR STATUS. + CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. + INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. + + DATA_TYPE = 'Int64' + N_COMPONENTS = 6 + CALL SELF%W_DATA_TAG_APPENDED(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, & + IS_TUPLES=IS_TUPLES) + CALL SELF%IOFFSET_UPDATE(N_BYTE=SELF%WRITE_ON_SCRATCH_DATAARRAY(U=U, V=V, W=W, X=X, Y=Y, Z=Z)) + ERROR = SELF%ERROR + ENDFUNCTION W_DATA6_RANK3_I8P + + FUNCTION W_DATA6_RANK3_I4P(SELF, DATA_NAME, U, V, W, X, Y, Z, IS_TUPLES) RESULT(ERROR) + !< WRITE `<DATAARRAY... NumberOfComponents="6"...>...</DATAARRAY>` TAG (I4P). + CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF !< WRITER. + CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. + INTEGER(I4P), INTENT(IN) :: U(1:,1:,1:) !< U COMPONENT OF DATA VARIABLE. + INTEGER(I4P), INTENT(IN) :: V(1:,1:,1:) !< V COMPONENT OF DATA VARIABLE. + INTEGER(I4P), INTENT(IN) :: W(1:,1:,1:) !< W COMPONENT OF DATA VARIABLE. + INTEGER(I4P), INTENT(IN) :: X(1:,1:,1:) !< X COMPONENT OF DATA VARIABLE. + INTEGER(I4P), INTENT(IN) :: Y(1:,1:,1:) !< Y COMPONENT OF DATA VARIABLE. + INTEGER(I4P), INTENT(IN) :: Z(1:,1:,1:) !< Z COMPONENT OF DATA VARIABLE. + LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES". + INTEGER(I4P) :: ERROR !< ERROR STATUS. + CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. + INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. + + DATA_TYPE = 'Int32' + N_COMPONENTS = 6 + CALL SELF%W_DATA_TAG_APPENDED(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, & + IS_TUPLES=IS_TUPLES) + CALL SELF%IOFFSET_UPDATE(N_BYTE=SELF%WRITE_ON_SCRATCH_DATAARRAY(U=U, V=V, W=W, X=X, Y=Y, Z=Z)) + ERROR = SELF%ERROR + ENDFUNCTION W_DATA6_RANK3_I4P + + FUNCTION W_DATA6_RANK3_I2P(SELF, DATA_NAME, U, V, W, X, Y, Z, IS_TUPLES) RESULT(ERROR) + !< WRITE `<DATAARRAY... NumberOfComponents="6"...>...</DATAARRAY>` TAG (I2P). + CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF !< WRITER. + CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. + INTEGER(I2P), INTENT(IN) :: U(1:,1:,1:) !< U COMPONENT OF DATA VARIABLE. + INTEGER(I2P), INTENT(IN) :: V(1:,1:,1:) !< V COMPONENT OF DATA VARIABLE. + INTEGER(I2P), INTENT(IN) :: W(1:,1:,1:) !< W COMPONENT OF DATA VARIABLE. + INTEGER(I2P), INTENT(IN) :: X(1:,1:,1:) !< X COMPONENT OF DATA VARIABLE. + INTEGER(I2P), INTENT(IN) :: Y(1:,1:,1:) !< Y COMPONENT OF DATA VARIABLE. + INTEGER(I2P), INTENT(IN) :: Z(1:,1:,1:) !< Z COMPONENT OF DATA VARIABLE. + LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES". + INTEGER(I4P) :: ERROR !< ERROR STATUS. + CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. + INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. + + DATA_TYPE = 'Int16' + N_COMPONENTS = 6 + CALL SELF%W_DATA_TAG_APPENDED(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, & + IS_TUPLES=IS_TUPLES) + CALL SELF%IOFFSET_UPDATE(N_BYTE=SELF%WRITE_ON_SCRATCH_DATAARRAY(U=U, V=V, W=W, X=X, Y=Y, Z=Z)) + ERROR = SELF%ERROR + ENDFUNCTION W_DATA6_RANK3_I2P + + FUNCTION W_DATA6_RANK3_I1P(SELF, DATA_NAME, U, V, W, X, Y, Z, IS_TUPLES) RESULT(ERROR) + !< WRITE `<DATAARRAY... NumberOfComponents="6"...>...</DATAARRAY>` TAG (I1P). + CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF !< WRITER. + CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. + INTEGER(I1P), INTENT(IN) :: U(1:,1:,1:) !< U COMPONENT OF DATA VARIABLE. + INTEGER(I1P), INTENT(IN) :: V(1:,1:,1:) !< V COMPONENT OF DATA VARIABLE. + INTEGER(I1P), INTENT(IN) :: W(1:,1:,1:) !< W COMPONENT OF DATA VARIABLE. + INTEGER(I1P), INTENT(IN) :: X(1:,1:,1:) !< X COMPONENT OF DATA VARIABLE. + INTEGER(I1P), INTENT(IN) :: Y(1:,1:,1:) !< Y COMPONENT OF DATA VARIABLE. + INTEGER(I1P), INTENT(IN) :: Z(1:,1:,1:) !< Z COMPONENT OF DATA VARIABLE. + LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES". + INTEGER(I4P) :: ERROR !< ERROR STATUS. + CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. + INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. + + DATA_TYPE = 'Int8' + N_COMPONENTS = 6 + CALL SELF%W_DATA_TAG_APPENDED(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, & + IS_TUPLES=IS_TUPLES) + CALL SELF%IOFFSET_UPDATE(N_BYTE=SELF%WRITE_ON_SCRATCH_DATAARRAY(U=U, V=V, W=W, X=X, Y=Y, Z=Z)) + ERROR = SELF%ERROR + ENDFUNCTION W_DATA6_RANK3_I1P + + SUBROUTINE W_DATA_APPENDED(SELF) + !< DO NOTHING, ASCII DATA CANNOT BE APPENDED. + CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF !< WRITER. + TYPE(STRING) :: TAG_ATTRIBUTES !< TAG ATTRIBUTES. + INTEGER(I4P) :: N_BYTE !< BYTES COUNT. + CHARACTER(LEN=2) :: DATAARRAY_TYPE !< DATAARRAY TYPE = R8,R4,I8,I4,I2,I1. + INTEGER(I4P) :: DATAARRAY_DIM !< DATAARRAY DIMENSION. + REAL(R8P), ALLOCATABLE :: DATAARRAY_R8P(:) !< DATAARRAY BUFFER OF R8P. + REAL(R4P), ALLOCATABLE :: DATAARRAY_R4P(:) !< DATAARRAY BUFFER OF R4P. + INTEGER(I8P), ALLOCATABLE :: DATAARRAY_I8P(:) !< DATAARRAY BUFFER OF I8P. + INTEGER(I4P), ALLOCATABLE :: DATAARRAY_I4P(:) !< DATAARRAY BUFFER OF I4P. + INTEGER(I2P), ALLOCATABLE :: DATAARRAY_I2P(:) !< DATAARRAY BUFFER OF I2P. + INTEGER(I1P), ALLOCATABLE :: DATAARRAY_I1P(:) !< DATAARRAY BUFFER OF I1P. + + CALL SELF%WRITE_START_TAG(NAME='AppendedData', ATTRIBUTES='encoding="'//SELF%ENCODING%CHARS()//'"') + WRITE(UNIT=SELF%XML, IOSTAT=SELF%ERROR)'_' + ENDFILE(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR) + REWIND(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR) + DO + CALL READ_DATAARRAY_FROM_SCRATCH + IF (SELF%ERROR==0) CALL W_DATA_ON_XML + IF (IS_IOSTAT_END(SELF%ERROR)) EXIT + ENDDO + CLOSE(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR) + WRITE(UNIT=SELF%XML, IOSTAT=SELF%ERROR)END_REC + CALL SELF%WRITE_END_TAG(NAME='AppendedData') + CONTAINS + SUBROUTINE READ_DATAARRAY_FROM_SCRATCH + !< READ THE CURRENT DATAARAY FROM SCRATCH FILE. + + READ(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR, END=10)N_BYTE, DATAARRAY_TYPE, DATAARRAY_DIM + SELECT CASE(DATAARRAY_TYPE) + CASE('R8') + IF (ALLOCATED(DATAARRAY_R8P)) DEALLOCATE(DATAARRAY_R8P) ; ALLOCATE(DATAARRAY_R8P(1:DATAARRAY_DIM)) + READ(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)DATAARRAY_R8P + CASE('R4') + IF (ALLOCATED(DATAARRAY_R4P)) DEALLOCATE(DATAARRAY_R4P) ; ALLOCATE(DATAARRAY_R4P(1:DATAARRAY_DIM)) + READ(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)DATAARRAY_R4P + CASE('I8') + IF (ALLOCATED(DATAARRAY_I8P)) DEALLOCATE(DATAARRAY_I8P) ; ALLOCATE(DATAARRAY_I8P(1:DATAARRAY_DIM)) + READ(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)DATAARRAY_I8P + CASE('I4') + IF (ALLOCATED(DATAARRAY_I4P)) DEALLOCATE(DATAARRAY_I4P) ; ALLOCATE(DATAARRAY_I4P(1:DATAARRAY_DIM)) + READ(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)DATAARRAY_I4P + CASE('I2') + IF (ALLOCATED(DATAARRAY_I2P)) DEALLOCATE(DATAARRAY_I2P) ; ALLOCATE(DATAARRAY_I2P(1:DATAARRAY_DIM)) + READ(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)DATAARRAY_I2P + CASE('I1') + IF (ALLOCATED(DATAARRAY_I1P)) DEALLOCATE(DATAARRAY_I1P) ; ALLOCATE(DATAARRAY_I1P(1:DATAARRAY_DIM)) + READ(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)DATAARRAY_I1P + CASE DEFAULT + SELF%ERROR = 1 + WRITE (STDERR,'(A)')' ERROR: BAD DATAARRAY_TYPE = '//DATAARRAY_TYPE + WRITE (STDERR,'(A)')' BYTES = '//TRIM(STR(N=N_BYTE)) + WRITE (STDERR,'(A)')' DATAARRAY DIMENSION = '//TRIM(STR(N=DATAARRAY_DIM)) + ENDSELECT + 10 RETURN + ENDSUBROUTINE READ_DATAARRAY_FROM_SCRATCH + + SUBROUTINE W_DATA_ON_XML + !< WRITE THE CURRENT DATAARAY ON XML FILE. + CHARACTER(LEN=:), ALLOCATABLE :: CODE !< DATAARRAY ENCODED WITH BASE64 CODEC. + + IF (SELF%ENCODING=='raw') THEN + SELECT CASE(DATAARRAY_TYPE) + CASE('R8') + WRITE(UNIT=SELF%XML, IOSTAT=SELF%ERROR)N_BYTE, DATAARRAY_R8P + DEALLOCATE(DATAARRAY_R8P) + CASE('R4') + WRITE(UNIT=SELF%XML, IOSTAT=SELF%ERROR)N_BYTE, DATAARRAY_R4P + DEALLOCATE(DATAARRAY_R4P) + CASE('I8') + WRITE(UNIT=SELF%XML, IOSTAT=SELF%ERROR)N_BYTE, DATAARRAY_I8P + DEALLOCATE(DATAARRAY_I8P) + CASE('I4') + WRITE(UNIT=SELF%XML, IOSTAT=SELF%ERROR)N_BYTE, DATAARRAY_I4P + DEALLOCATE(DATAARRAY_I4P) + CASE('I2') + WRITE(UNIT=SELF%XML, IOSTAT=SELF%ERROR)N_BYTE, DATAARRAY_I2P + DEALLOCATE(DATAARRAY_I2P) + CASE('I1') + WRITE(UNIT=SELF%XML, IOSTAT=SELF%ERROR)N_BYTE, DATAARRAY_I1P + DEALLOCATE(DATAARRAY_I1P) + ENDSELECT + ELSE + SELECT CASE(DATAARRAY_TYPE) + CASE('R8') + CODE = ENCODE_BINARY_DATAARRAY(X=DATAARRAY_R8P) + WRITE(UNIT=SELF%XML, IOSTAT=SELF%ERROR)CODE + CASE('R4') + CODE = ENCODE_BINARY_DATAARRAY(X=DATAARRAY_R4P) + WRITE(UNIT=SELF%XML, IOSTAT=SELF%ERROR)CODE + CASE('I8') + CODE = ENCODE_BINARY_DATAARRAY(X=DATAARRAY_I8P) + WRITE(UNIT=SELF%XML, IOSTAT=SELF%ERROR)CODE + CASE('I4') + CODE = ENCODE_BINARY_DATAARRAY(X=DATAARRAY_I4P) + WRITE(UNIT=SELF%XML, IOSTAT=SELF%ERROR)CODE + CASE('I2') + CODE = ENCODE_BINARY_DATAARRAY(X=DATAARRAY_I2P) + WRITE(UNIT=SELF%XML, IOSTAT=SELF%ERROR)CODE + CASE('I1') + CODE = ENCODE_BINARY_DATAARRAY(X=DATAARRAY_I1P) + WRITE(UNIT=SELF%XML, IOSTAT=SELF%ERROR)CODE + ENDSELECT + ENDIF + ENDSUBROUTINE W_DATA_ON_XML + ENDSUBROUTINE W_DATA_APPENDED + + ! WRITE_ON_SCRATCH_DATAARRAY METHODS + FUNCTION WRITE_ON_SCRATCH_DATAARRAY1_RANK1(SELF, X) RESULT(N_BYTE) + !< WRITE A DATAARRAY WITH 1 COMPONENTS OF RANK 1. + CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF !< WRITER. + CLASS(*), INTENT(IN) :: X(1:) !< DATA VARIABLE. + INTEGER(I4P) :: N_BYTE !< NUMBER OF BYTES + INTEGER(I4P) :: NN !< NUMBER OF ELEMENTS. + + NN = SIZE(X, DIM=1) + SELECT TYPE(X) + TYPE IS(REAL(R8P)) + N_BYTE = NN*BYR8P + WRITE(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)N_BYTE, 'R8', NN + WRITE(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)X + TYPE IS(REAL(R4P)) + N_BYTE = NN*BYR4P + WRITE(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)N_BYTE, 'R4', NN + WRITE(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)X + TYPE IS(INTEGER(I8P)) + N_BYTE = NN*BYI8P + WRITE(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)N_BYTE, 'I8', NN + WRITE(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)X + TYPE IS(INTEGER(I4P)) + N_BYTE = NN*BYI4P + WRITE(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)N_BYTE, 'I4', NN + WRITE(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)X + TYPE IS(INTEGER(I2P)) + N_BYTE = NN*BYI2P + WRITE(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)N_BYTE, 'I2', NN + WRITE(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)X + TYPE IS(INTEGER(I1P)) + N_BYTE = NN*BYI1P + WRITE(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)N_BYTE, 'I1', NN + WRITE(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)X + ENDSELECT + ENDFUNCTION WRITE_ON_SCRATCH_DATAARRAY1_RANK1 + + FUNCTION WRITE_ON_SCRATCH_DATAARRAY1_RANK2(SELF, X) RESULT(N_BYTE) + !< WRITE A DATAARRAY WITH 1 COMPONENTS OF RANK 2. + CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF !< WRITER. + CLASS(*), INTENT(IN) :: X(1:,1:) !< DATA VARIABLE. + INTEGER(I4P) :: N_BYTE !< NUMBER OF BYTES + INTEGER(I4P) :: NN !< NUMBER OF ELEMENTS. + + NN = SIZE(X, DIM=1)*SIZE(X, DIM=2) + SELECT TYPE(X) + TYPE IS(REAL(R8P)) + N_BYTE = NN*BYR8P + WRITE(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)N_BYTE, 'R8', NN + WRITE(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)X + TYPE IS(REAL(R4P)) + N_BYTE = NN*BYR4P + WRITE(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)N_BYTE, 'R4', NN + WRITE(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)X + TYPE IS(INTEGER(I8P)) + N_BYTE = NN*BYI8P + WRITE(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)N_BYTE, 'I8', NN + WRITE(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)X + TYPE IS(INTEGER(I4P)) + N_BYTE = NN*BYI4P + WRITE(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)N_BYTE, 'I4', NN + WRITE(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)X + TYPE IS(INTEGER(I2P)) + N_BYTE = NN*BYI2P + WRITE(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)N_BYTE, 'I2', NN + WRITE(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)X + TYPE IS(INTEGER(I1P)) + N_BYTE = NN*BYI1P + WRITE(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)N_BYTE, 'I1', NN + WRITE(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)X + ENDSELECT + ENDFUNCTION WRITE_ON_SCRATCH_DATAARRAY1_RANK2 + + FUNCTION WRITE_ON_SCRATCH_DATAARRAY1_RANK3(SELF, X) RESULT(N_BYTE) + !< WRITE A DATAARRAY WITH 1 COMPONENTS OF RANK 3. + CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF !< WRITER. + CLASS(*), INTENT(IN) :: X(1:,1:,1:) !< DATA VARIABLE. + INTEGER(I4P) :: N_BYTE !< NUMBER OF BYTES + INTEGER(I4P) :: NN !< NUMBER OF ELEMENTS. + + NN = SIZE(X, DIM=1)*SIZE(X, DIM=2)*SIZE(X, DIM=3) + SELECT TYPE(X) + TYPE IS(REAL(R8P)) + N_BYTE = NN*BYR8P + WRITE(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)N_BYTE, 'R8', NN + WRITE(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)X + TYPE IS(REAL(R4P)) + N_BYTE = NN*BYR4P + WRITE(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)N_BYTE, 'R4', NN + WRITE(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)X + TYPE IS(INTEGER(I8P)) + N_BYTE = NN*BYI8P + WRITE(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)N_BYTE, 'I8', NN + WRITE(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)X + TYPE IS(INTEGER(I4P)) + N_BYTE = NN*BYI4P + WRITE(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)N_BYTE, 'I4', NN + WRITE(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)X + TYPE IS(INTEGER(I2P)) + N_BYTE = NN*BYI2P + WRITE(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)N_BYTE, 'I2', NN + WRITE(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)X + TYPE IS(INTEGER(I1P)) + N_BYTE = NN*BYI1P + WRITE(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)N_BYTE, 'I1', NN + WRITE(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)X + ENDSELECT + ENDFUNCTION WRITE_ON_SCRATCH_DATAARRAY1_RANK3 + + FUNCTION WRITE_ON_SCRATCH_DATAARRAY1_RANK4(SELF, X) RESULT(N_BYTE) + !< WRITE A DATAARRAY WITH 1 COMPONENTS OF RANK 4. + CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF !< WRITER. + CLASS(*), INTENT(IN) :: X(1:,1:,1:,1:) !< DATA VARIABLE. + INTEGER(I4P) :: N_BYTE !< NUMBER OF BYTES + INTEGER(I4P) :: NN !< NUMBER OF ELEMENTS. + + NN = SIZE(X, DIM=1)*SIZE(X, DIM=2)*SIZE(X, DIM=3)*SIZE(X, DIM=4) + SELECT TYPE(X) + TYPE IS(REAL(R8P)) + N_BYTE = NN*BYR8P + WRITE(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)N_BYTE, 'R8', NN + WRITE(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)X + TYPE IS(REAL(R4P)) + N_BYTE = NN*BYR4P + WRITE(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)N_BYTE, 'R4', NN + WRITE(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)X + TYPE IS(INTEGER(I8P)) + N_BYTE = NN*BYI8P + WRITE(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)N_BYTE, 'I8', NN + WRITE(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)X + TYPE IS(INTEGER(I4P)) + N_BYTE = NN*BYI4P + WRITE(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)N_BYTE, 'I4', NN + WRITE(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)X + TYPE IS(INTEGER(I2P)) + N_BYTE = NN*BYI2P + WRITE(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)N_BYTE, 'I2', NN + WRITE(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)X + TYPE IS(INTEGER(I1P)) + N_BYTE = NN*BYI1P + WRITE(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)N_BYTE, 'I1', NN + WRITE(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)X + ENDSELECT + ENDFUNCTION WRITE_ON_SCRATCH_DATAARRAY1_RANK4 + + FUNCTION WRITE_ON_SCRATCH_DATAARRAY3_RANK1_R8P(SELF, X, Y, Z) RESULT(N_BYTE) + !< WRITE A DATAARRAY WITH 3 COMPONENTS OF RANK 1 (R8P). + CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF !< WRITER. + REAL(R8P), INTENT(IN) :: X(1:) !< X COMPONENT. + REAL(R8P), INTENT(IN) :: Y(1:) !< Y COMPONENT. + REAL(R8P), INTENT(IN) :: Z(1:) !< Z COMPONENT. + INTEGER(I4P) :: N_BYTE !< NUMBER OF BYTES + INTEGER(I4P) :: N !< COUNTER. + + N_BYTE = SELF%WRITE_ON_SCRATCH_DATAARRAY(X=[(X(N), Y(N), Z(N), N=1,SIZE(X, DIM=1))]) + ENDFUNCTION WRITE_ON_SCRATCH_DATAARRAY3_RANK1_R8P + + FUNCTION WRITE_ON_SCRATCH_DATAARRAY3_RANK1_R4P(SELF, X, Y, Z) RESULT(N_BYTE) + !< WRITE A DATAARRAY WITH 3 COMPONENTS OF RANK 1 (R4P). + CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF !< WRITER. + REAL(R4P), INTENT(IN) :: X(1:) !< X COMPONENT. + REAL(R4P), INTENT(IN) :: Y(1:) !< Y COMPONENT. + REAL(R4P), INTENT(IN) :: Z(1:) !< Z COMPONENT. + INTEGER(I4P) :: N_BYTE !< NUMBER OF BYTES + INTEGER(I4P) :: N !< COUNTER. + + N_BYTE = SELF%WRITE_ON_SCRATCH_DATAARRAY(X=[(X(N), Y(N), Z(N), N=1,SIZE(X, DIM=1))]) + ENDFUNCTION WRITE_ON_SCRATCH_DATAARRAY3_RANK1_R4P + + FUNCTION WRITE_ON_SCRATCH_DATAARRAY3_RANK1_I8P(SELF, X, Y, Z) RESULT(N_BYTE) + !< WRITE A DATAARRAY WITH 3 COMPONENTS OF RANK 1 (I8P). + CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF !< WRITER. + INTEGER(I8P), INTENT(IN) :: X(1:) !< X COMPONENT. + INTEGER(I8P), INTENT(IN) :: Y(1:) !< Y COMPONENT. + INTEGER(I8P), INTENT(IN) :: Z(1:) !< Z COMPONENT. + INTEGER(I4P) :: N_BYTE !< NUMBER OF BYTES + INTEGER(I4P) :: N !< COUNTER. + + N_BYTE = SELF%WRITE_ON_SCRATCH_DATAARRAY(X=[(X(N), Y(N), Z(N), N=1,SIZE(X, DIM=1))]) + ENDFUNCTION WRITE_ON_SCRATCH_DATAARRAY3_RANK1_I8P + + FUNCTION WRITE_ON_SCRATCH_DATAARRAY3_RANK1_I4P(SELF, X, Y, Z) RESULT(N_BYTE) + !< WRITE A DATAARRAY WITH 3 COMPONENTS OF RANK 1 (I4P). + CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF !< WRITER. + INTEGER(I4P), INTENT(IN) :: X(1:) !< X COMPONENT. + INTEGER(I4P), INTENT(IN) :: Y(1:) !< Y COMPONENT. + INTEGER(I4P), INTENT(IN) :: Z(1:) !< Z COMPONENT. + INTEGER(I4P) :: N_BYTE !< NUMBER OF BYTES + INTEGER(I4P) :: N !< COUNTER. + + N_BYTE = SELF%WRITE_ON_SCRATCH_DATAARRAY(X=[(X(N), Y(N), Z(N), N=1,SIZE(X, DIM=1))]) + ENDFUNCTION WRITE_ON_SCRATCH_DATAARRAY3_RANK1_I4P + + FUNCTION WRITE_ON_SCRATCH_DATAARRAY3_RANK1_I2P(SELF, X, Y, Z) RESULT(N_BYTE) + !< WRITE A DATAARRAY WITH 3 COMPONENTS OF RANK 1 (I2P). + CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF !< WRITER. + INTEGER(I2P), INTENT(IN) :: X(1:) !< X COMPONENT. + INTEGER(I2P), INTENT(IN) :: Y(1:) !< Y COMPONENT. + INTEGER(I2P), INTENT(IN) :: Z(1:) !< Z COMPONENT. + INTEGER(I4P) :: N_BYTE !< NUMBER OF BYTES + INTEGER(I4P) :: N !< COUNTER. + + N_BYTE = SELF%WRITE_ON_SCRATCH_DATAARRAY(X=[(X(N), Y(N), Z(N), N=1,SIZE(X, DIM=1))]) + ENDFUNCTION WRITE_ON_SCRATCH_DATAARRAY3_RANK1_I2P + + FUNCTION WRITE_ON_SCRATCH_DATAARRAY3_RANK1_I1P(SELF, X, Y, Z) RESULT(N_BYTE) + !< WRITE A DATAARRAY WITH 3 COMPONENTS OF RANK 1 (I1P). + CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF !< WRITER. + INTEGER(I1P), INTENT(IN) :: X(1:) !< X COMPONENT. + INTEGER(I1P), INTENT(IN) :: Y(1:) !< Y COMPONENT. + INTEGER(I1P), INTENT(IN) :: Z(1:) !< Z COMPONENT. + INTEGER(I4P) :: N_BYTE !< NUMBER OF BYTES + INTEGER(I4P) :: N !< COUNTER. + + N_BYTE = SELF%WRITE_ON_SCRATCH_DATAARRAY(X=[(X(N), Y(N), Z(N), N=1,SIZE(X, DIM=1))]) + ENDFUNCTION WRITE_ON_SCRATCH_DATAARRAY3_RANK1_I1P + + FUNCTION WRITE_ON_SCRATCH_DATAARRAY3_RANK2_R8P(SELF, X, Y, Z) RESULT(N_BYTE) + !< WRITE A DATAARRAY WITH 3 COMPONENTS OF RANK 2 (R8P). + CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF !< WRITER. + REAL(R8P), INTENT(IN) :: X(1:,1:) !< X COMPONENT. + REAL(R8P), INTENT(IN) :: Y(1:,1:) !< Y COMPONENT. + REAL(R8P), INTENT(IN) :: Z(1:,1:) !< Z COMPONENT. + INTEGER(I4P) :: N_BYTE !< NUMBER OF BYTES + INTEGER(I4P) :: N1 !< COUNTER. + INTEGER(I4P) :: N2 !< COUNTER. + + N_BYTE = SELF%WRITE_ON_SCRATCH_DATAARRAY(X=[((X(N1,N2), Y(N1,N2), Z(N1,N2), N1=1,SIZE(X, DIM=1)),N2=1,SIZE(X, DIM=2))]) + ENDFUNCTION WRITE_ON_SCRATCH_DATAARRAY3_RANK2_R8P + + FUNCTION WRITE_ON_SCRATCH_DATAARRAY3_RANK2_R4P(SELF, X, Y, Z) RESULT(N_BYTE) + !< WRITE A DATAARRAY WITH 3 COMPONENTS OF RANK 2 (R4P). + CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF !< WRITER. + REAL(R4P), INTENT(IN) :: X(1:,1:) !< X COMPONENT. + REAL(R4P), INTENT(IN) :: Y(1:,1:) !< Y COMPONENT. + REAL(R4P), INTENT(IN) :: Z(1:,1:) !< Z COMPONENT. + INTEGER(I4P) :: N_BYTE !< NUMBER OF BYTES + INTEGER(I4P) :: N1 !< COUNTER. + INTEGER(I4P) :: N2 !< COUNTER. + + N_BYTE = SELF%WRITE_ON_SCRATCH_DATAARRAY(X=[((X(N1,N2), Y(N1,N2), Z(N1,N2), N1=1,SIZE(X, DIM=1)),N2=1,SIZE(X, DIM=2))]) + ENDFUNCTION WRITE_ON_SCRATCH_DATAARRAY3_RANK2_R4P + + FUNCTION WRITE_ON_SCRATCH_DATAARRAY3_RANK2_I8P(SELF, X, Y, Z) RESULT(N_BYTE) + !< WRITE A DATAARRAY WITH 3 COMPONENTS OF RANK 2 (I8P). + CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF !< WRITER. + INTEGER(I8P), INTENT(IN) :: X(1:,1:) !< X COMPONENT. + INTEGER(I8P), INTENT(IN) :: Y(1:,1:) !< Y COMPONENT. + INTEGER(I8P), INTENT(IN) :: Z(1:,1:) !< Z COMPONENT. + INTEGER(I4P) :: N_BYTE !< NUMBER OF BYTES + INTEGER(I4P) :: N1 !< COUNTER. + INTEGER(I4P) :: N2 !< COUNTER. + + N_BYTE = SELF%WRITE_ON_SCRATCH_DATAARRAY(X=[((X(N1,N2), Y(N1,N2), Z(N1,N2), N1=1,SIZE(X, DIM=1)),N2=1,SIZE(X, DIM=2))]) + ENDFUNCTION WRITE_ON_SCRATCH_DATAARRAY3_RANK2_I8P + + FUNCTION WRITE_ON_SCRATCH_DATAARRAY3_RANK2_I4P(SELF, X, Y, Z) RESULT(N_BYTE) + !< WRITE A DATAARRAY WITH 3 COMPONENTS OF RANK 2 (I4P). + CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF !< WRITER. + INTEGER(I4P), INTENT(IN) :: X(1:,1:) !< X COMPONENT. + INTEGER(I4P), INTENT(IN) :: Y(1:,1:) !< Y COMPONENT. + INTEGER(I4P), INTENT(IN) :: Z(1:,1:) !< Z COMPONENT. + INTEGER(I4P) :: N_BYTE !< NUMBER OF BYTES + INTEGER(I4P) :: N1 !< COUNTER. + INTEGER(I4P) :: N2 !< COUNTER. + + N_BYTE = SELF%WRITE_ON_SCRATCH_DATAARRAY(X=[((X(N1,N2), Y(N1,N2), Z(N1,N2), N1=1,SIZE(X, DIM=1)),N2=1,SIZE(X, DIM=2))]) + ENDFUNCTION WRITE_ON_SCRATCH_DATAARRAY3_RANK2_I4P + + FUNCTION WRITE_ON_SCRATCH_DATAARRAY3_RANK2_I2P(SELF, X, Y, Z) RESULT(N_BYTE) + !< WRITE A DATAARRAY WITH 3 COMPONENTS OF RANK 2 (I2P). + CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF !< WRITER. + INTEGER(I2P), INTENT(IN) :: X(1:,1:) !< X COMPONENT. + INTEGER(I2P), INTENT(IN) :: Y(1:,1:) !< Y COMPONENT. + INTEGER(I2P), INTENT(IN) :: Z(1:,1:) !< Z COMPONENT. + INTEGER(I4P) :: N_BYTE !< NUMBER OF BYTES + INTEGER(I4P) :: N1 !< COUNTER. + INTEGER(I4P) :: N2 !< COUNTER. + + N_BYTE = SELF%WRITE_ON_SCRATCH_DATAARRAY(X=[((X(N1,N2), Y(N1,N2), Z(N1,N2), N1=1,SIZE(X, DIM=1)),N2=1,SIZE(X, DIM=2))]) + ENDFUNCTION WRITE_ON_SCRATCH_DATAARRAY3_RANK2_I2P + + FUNCTION WRITE_ON_SCRATCH_DATAARRAY3_RANK2_I1P(SELF, X, Y, Z) RESULT(N_BYTE) + !< WRITE A DATAARRAY WITH 3 COMPONENTS OF RANK 2 (I1P). + CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF !< WRITER. + INTEGER(I1P), INTENT(IN) :: X(1:,1:) !< X COMPONENT. + INTEGER(I1P), INTENT(IN) :: Y(1:,1:) !< Y COMPONENT. + INTEGER(I1P), INTENT(IN) :: Z(1:,1:) !< Z COMPONENT. + INTEGER(I4P) :: N_BYTE !< NUMBER OF BYTES + INTEGER(I4P) :: N1 !< COUNTER. + INTEGER(I4P) :: N2 !< COUNTER. + + N_BYTE = SELF%WRITE_ON_SCRATCH_DATAARRAY(X=[((X(N1,N2), Y(N1,N2), Z(N1,N2), N1=1,SIZE(X, DIM=1)),N2=1,SIZE(X, DIM=2))]) + ENDFUNCTION WRITE_ON_SCRATCH_DATAARRAY3_RANK2_I1P + + FUNCTION WRITE_ON_SCRATCH_DATAARRAY3_RANK3_R8P(SELF, X, Y, Z) RESULT(N_BYTE) + !< WRITE A DATAARRAY WITH 3 COMPONENTS OF RANK 3 (R8P). + CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF !< WRITER. + REAL(R8P), INTENT(IN) :: X(1:,1:,1:) !< X COMPONENT. + REAL(R8P), INTENT(IN) :: Y(1:,1:,1:) !< Y COMPONENT. + REAL(R8P), INTENT(IN) :: Z(1:,1:,1:) !< Z COMPONENT. + INTEGER(I4P) :: N_BYTE !< NUMBER OF BYTES + INTEGER(I4P) :: N1 !< COUNTER. + INTEGER(I4P) :: N2 !< COUNTER. + INTEGER(I4P) :: N3 !< COUNTER. + + N_BYTE = SELF%WRITE_ON_SCRATCH_DATAARRAY(X=[(((X(N1,N2,N3), Y(N1,N2,N3), Z(N1,N2,N3), & + N1=1,SIZE(X, DIM=1)),N2=1,SIZE(X, DIM=2)),N3=1,SIZE(X, DIM=3))]) + ENDFUNCTION WRITE_ON_SCRATCH_DATAARRAY3_RANK3_R8P + + FUNCTION WRITE_ON_SCRATCH_DATAARRAY3_RANK3_R4P(SELF, X, Y, Z) RESULT(N_BYTE) + !< WRITE A DATAARRAY WITH 3 COMPONENTS OF RANK 3 (R4P). + CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF !< WRITER. + REAL(R4P), INTENT(IN) :: X(1:,1:,1:) !< X COMPONENT. + REAL(R4P), INTENT(IN) :: Y(1:,1:,1:) !< Y COMPONENT. + REAL(R4P), INTENT(IN) :: Z(1:,1:,1:) !< Z COMPONENT. + INTEGER(I4P) :: N_BYTE !< NUMBER OF BYTES + INTEGER(I4P) :: N1 !< COUNTER. + INTEGER(I4P) :: N2 !< COUNTER. + INTEGER(I4P) :: N3 !< COUNTER. + + N_BYTE = SELF%WRITE_ON_SCRATCH_DATAARRAY(X=[(((X(N1,N2,N3), Y(N1,N2,N3), Z(N1,N2,N3), & + N1=1,SIZE(X, DIM=1)),N2=1,SIZE(X, DIM=2)),N3=1,SIZE(X, DIM=3))]) + ENDFUNCTION WRITE_ON_SCRATCH_DATAARRAY3_RANK3_R4P + + FUNCTION WRITE_ON_SCRATCH_DATAARRAY3_RANK3_I8P(SELF, X, Y, Z) RESULT(N_BYTE) + !< WRITE A DATAARRAY WITH 3 COMPONENTS OF RANK 3 (I8P). + CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF !< WRITER. + INTEGER(I8P), INTENT(IN) :: X(1:,1:,1:) !< X COMPONENT. + INTEGER(I8P), INTENT(IN) :: Y(1:,1:,1:) !< Y COMPONENT. + INTEGER(I8P), INTENT(IN) :: Z(1:,1:,1:) !< Z COMPONENT. + INTEGER(I4P) :: N_BYTE !< NUMBER OF BYTES + INTEGER(I4P) :: N1 !< COUNTER. + INTEGER(I4P) :: N2 !< COUNTER. + INTEGER(I4P) :: N3 !< COUNTER. + + N_BYTE = SELF%WRITE_ON_SCRATCH_DATAARRAY(X=[(((X(N1,N2,N3), Y(N1,N2,N3), Z(N1,N2,N3), & + N1=1,SIZE(X, DIM=1)),N2=1,SIZE(X, DIM=2)),N3=1,SIZE(X, DIM=3))]) + ENDFUNCTION WRITE_ON_SCRATCH_DATAARRAY3_RANK3_I8P + + FUNCTION WRITE_ON_SCRATCH_DATAARRAY3_RANK3_I4P(SELF, X, Y, Z) RESULT(N_BYTE) + !< WRITE A DATAARRAY WITH 3 COMPONENTS OF RANK 3 (I4P). + CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF !< WRITER. + INTEGER(I4P), INTENT(IN) :: X(1:,1:,1:) !< X COMPONENT. + INTEGER(I4P), INTENT(IN) :: Y(1:,1:,1:) !< Y COMPONENT. + INTEGER(I4P), INTENT(IN) :: Z(1:,1:,1:) !< Z COMPONENT. + INTEGER(I4P) :: N_BYTE !< NUMBER OF BYTES + INTEGER(I4P) :: N1 !< COUNTER. + INTEGER(I4P) :: N2 !< COUNTER. + INTEGER(I4P) :: N3 !< COUNTER. + + N_BYTE = SELF%WRITE_ON_SCRATCH_DATAARRAY(X=[(((X(N1,N2,N3), Y(N1,N2,N3), Z(N1,N2,N3), & + N1=1,SIZE(X, DIM=1)),N2=1,SIZE(X, DIM=2)),N3=1,SIZE(X, DIM=3))]) + ENDFUNCTION WRITE_ON_SCRATCH_DATAARRAY3_RANK3_I4P + + FUNCTION WRITE_ON_SCRATCH_DATAARRAY3_RANK3_I2P(SELF, X, Y, Z) RESULT(N_BYTE) + !< WRITE A DATAARRAY WITH 3 COMPONENTS OF RANK 3 (I2P). + CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF !< WRITER. + INTEGER(I2P), INTENT(IN) :: X(1:,1:,1:) !< X COMPONENT. + INTEGER(I2P), INTENT(IN) :: Y(1:,1:,1:) !< Y COMPONENT. + INTEGER(I2P), INTENT(IN) :: Z(1:,1:,1:) !< Z COMPONENT. + INTEGER(I4P) :: N_BYTE !< NUMBER OF BYTES + INTEGER(I4P) :: N1 !< COUNTER. + INTEGER(I4P) :: N2 !< COUNTER. + INTEGER(I4P) :: N3 !< COUNTER. + + N_BYTE = SELF%WRITE_ON_SCRATCH_DATAARRAY(X=[(((X(N1,N2,N3), Y(N1,N2,N3), Z(N1,N2,N3), & + N1=1,SIZE(X, DIM=1)),N2=1,SIZE(X, DIM=2)),N3=1,SIZE(X, DIM=3))]) + ENDFUNCTION WRITE_ON_SCRATCH_DATAARRAY3_RANK3_I2P + + FUNCTION WRITE_ON_SCRATCH_DATAARRAY3_RANK3_I1P(SELF, X, Y, Z) RESULT(N_BYTE) + !< WRITE A DATAARRAY WITH 3 COMPONENTS OF RANK 3 (I1P). + CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF !< WRITER. + INTEGER(I1P), INTENT(IN) :: X(1:,1:,1:) !< X COMPONENT. + INTEGER(I1P), INTENT(IN) :: Y(1:,1:,1:) !< Y COMPONENT. + INTEGER(I1P), INTENT(IN) :: Z(1:,1:,1:) !< Z COMPONENT. + INTEGER(I4P) :: N_BYTE !< NUMBER OF BYTES + INTEGER(I4P) :: N1 !< COUNTER. + INTEGER(I4P) :: N2 !< COUNTER. + INTEGER(I4P) :: N3 !< COUNTER. + + N_BYTE = SELF%WRITE_ON_SCRATCH_DATAARRAY(X=[(((X(N1,N2,N3), Y(N1,N2,N3), Z(N1,N2,N3), & + N1=1,SIZE(X, DIM=1)),N2=1,SIZE(X, DIM=2)),N3=1,SIZE(X, DIM=3))]) + ENDFUNCTION WRITE_ON_SCRATCH_DATAARRAY3_RANK3_I1P + + FUNCTION WRITE_ON_SCRATCH_DATAARRAY6_RANK1_R8P(SELF, U, V, W, X, Y, Z) RESULT(N_BYTE) + !< WRITE A DATAARRAY WITH 6 COMPONENTS OF RANK 1 (R8P). + CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF !< WRITER. + REAL(R8P), INTENT(IN) :: U(1:) !< U COMPONENT. + REAL(R8P), INTENT(IN) :: V(1:) !< V COMPONENT. + REAL(R8P), INTENT(IN) :: W(1:) !< W COMPONENT. + REAL(R8P), INTENT(IN) :: X(1:) !< X COMPONENT. + REAL(R8P), INTENT(IN) :: Y(1:) !< Y COMPONENT. + REAL(R8P), INTENT(IN) :: Z(1:) !< Z COMPONENT. + INTEGER(I4P) :: N_BYTE !< NUMBER OF BYTES + INTEGER(I4P) :: N !< COUNTER. + + N_BYTE = SELF%WRITE_ON_SCRATCH_DATAARRAY(X=[(U(N), V(N), W(N), X(N), Y(N), Z(N), N=1,SIZE(X, DIM=1))]) + ENDFUNCTION WRITE_ON_SCRATCH_DATAARRAY6_RANK1_R8P + + FUNCTION WRITE_ON_SCRATCH_DATAARRAY6_RANK1_R4P(SELF, U, V, W, X, Y, Z) RESULT(N_BYTE) + !< WRITE A DATAARRAY WITH 6 COMPONENTS OF RANK 1 (R4P). + CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF !< WRITER. + REAL(R4P), INTENT(IN) :: U(1:) !< U COMPONENT. + REAL(R4P), INTENT(IN) :: V(1:) !< V COMPONENT. + REAL(R4P), INTENT(IN) :: W(1:) !< W COMPONENT. + REAL(R4P), INTENT(IN) :: X(1:) !< X COMPONENT. + REAL(R4P), INTENT(IN) :: Y(1:) !< Y COMPONENT. + REAL(R4P), INTENT(IN) :: Z(1:) !< Z COMPONENT. + INTEGER(I4P) :: N_BYTE !< NUMBER OF BYTES + INTEGER(I4P) :: N !< COUNTER. + + N_BYTE = SELF%WRITE_ON_SCRATCH_DATAARRAY(X=[(U(N), V(N), W(N), X(N), Y(N), Z(N), N=1,SIZE(X, DIM=1))]) + ENDFUNCTION WRITE_ON_SCRATCH_DATAARRAY6_RANK1_R4P + + FUNCTION WRITE_ON_SCRATCH_DATAARRAY6_RANK1_I8P(SELF, U, V, W, X, Y, Z) RESULT(N_BYTE) + !< WRITE A DATAARRAY WITH 3 COMPONENTS OF RANK 1 (I8P). + CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF !< WRITER. + INTEGER(I8P), INTENT(IN) :: U(1:) !< U COMPONENT. + INTEGER(I8P), INTENT(IN) :: V(1:) !< V COMPONENT. + INTEGER(I8P), INTENT(IN) :: W(1:) !< W COMPONENT. + INTEGER(I8P), INTENT(IN) :: X(1:) !< X COMPONENT. + INTEGER(I8P), INTENT(IN) :: Y(1:) !< Y COMPONENT. + INTEGER(I8P), INTENT(IN) :: Z(1:) !< Z COMPONENT. + INTEGER(I4P) :: N_BYTE !< NUMBER OF BYTES + INTEGER(I4P) :: N !< COUNTER. + + N_BYTE = SELF%WRITE_ON_SCRATCH_DATAARRAY(X=[(U(N), V(N), W(N), X(N), Y(N), Z(N), N=1,SIZE(X, DIM=1))]) + ENDFUNCTION WRITE_ON_SCRATCH_DATAARRAY6_RANK1_I8P + + FUNCTION WRITE_ON_SCRATCH_DATAARRAY6_RANK1_I4P(SELF, U, V, W, X, Y, Z) RESULT(N_BYTE) + !< WRITE A DATAARRAY WITH 6 COMPONENTS OF RANK 1 (I4P). + CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF !< WRITER. + INTEGER(I4P), INTENT(IN) :: U(1:) !< U COMPONENT. + INTEGER(I4P), INTENT(IN) :: V(1:) !< V COMPONENT. + INTEGER(I4P), INTENT(IN) :: W(1:) !< W COMPONENT. + INTEGER(I4P), INTENT(IN) :: X(1:) !< X COMPONENT. + INTEGER(I4P), INTENT(IN) :: Y(1:) !< Y COMPONENT. + INTEGER(I4P), INTENT(IN) :: Z(1:) !< Z COMPONENT. + INTEGER(I4P) :: N_BYTE !< NUMBER OF BYTES + INTEGER(I4P) :: N !< COUNTER. + + N_BYTE = SELF%WRITE_ON_SCRATCH_DATAARRAY(X=[(U(N), V(N), W(N), X(N), Y(N), Z(N), N=1,SIZE(X, DIM=1))]) + ENDFUNCTION WRITE_ON_SCRATCH_DATAARRAY6_RANK1_I4P + + FUNCTION WRITE_ON_SCRATCH_DATAARRAY6_RANK1_I2P(SELF, U, V, W, X, Y, Z) RESULT(N_BYTE) + !< WRITE A DATAARRAY WITH 6 COMPONENTS OF RANK 1 (I2P). + CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF !< WRITER. + INTEGER(I2P), INTENT(IN) :: U(1:) !< U COMPONENT. + INTEGER(I2P), INTENT(IN) :: V(1:) !< V COMPONENT. + INTEGER(I2P), INTENT(IN) :: W(1:) !< W COMPONENT. + INTEGER(I2P), INTENT(IN) :: X(1:) !< X COMPONENT. + INTEGER(I2P), INTENT(IN) :: Y(1:) !< Y COMPONENT. + INTEGER(I2P), INTENT(IN) :: Z(1:) !< Z COMPONENT. + INTEGER(I4P) :: N_BYTE !< NUMBER OF BYTES + INTEGER(I4P) :: N !< COUNTER. + + N_BYTE = SELF%WRITE_ON_SCRATCH_DATAARRAY(X=[(U(N), V(N), W(N), X(N), Y(N), Z(N), N=1,SIZE(X, DIM=1))]) + ENDFUNCTION WRITE_ON_SCRATCH_DATAARRAY6_RANK1_I2P + + FUNCTION WRITE_ON_SCRATCH_DATAARRAY6_RANK1_I1P(SELF, U, V, W, X, Y, Z) RESULT(N_BYTE) + !< WRITE A DATAARRAY WITH 6 COMPONENTS OF RANK 1 (I1P). + CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF !< WRITER. + INTEGER(I1P), INTENT(IN) :: U(1:) !< U COMPONENT. + INTEGER(I1P), INTENT(IN) :: V(1:) !< V COMPONENT. + INTEGER(I1P), INTENT(IN) :: W(1:) !< W COMPONENT. + INTEGER(I1P), INTENT(IN) :: X(1:) !< X COMPONENT. + INTEGER(I1P), INTENT(IN) :: Y(1:) !< Y COMPONENT. + INTEGER(I1P), INTENT(IN) :: Z(1:) !< Z COMPONENT. + INTEGER(I4P) :: N_BYTE !< NUMBER OF BYTES + INTEGER(I4P) :: N !< COUNTER. + + N_BYTE = SELF%WRITE_ON_SCRATCH_DATAARRAY(X=[(U(N), V(N), W(N), X(N), Y(N), Z(N), N=1,SIZE(X, DIM=1))]) + ENDFUNCTION WRITE_ON_SCRATCH_DATAARRAY6_RANK1_I1P + + FUNCTION WRITE_ON_SCRATCH_DATAARRAY6_RANK2_R8P(SELF, U, V, W, X, Y, Z) RESULT(N_BYTE) + !< WRITE A DATAARRAY WITH 6 COMPONENTS OF RANK 2 (R8P). + CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF !< WRITER. + REAL(R8P), INTENT(IN) :: U(1:,1:) !< U COMPONENT. + REAL(R8P), INTENT(IN) :: V(1:,1:) !< V COMPONENT. + REAL(R8P), INTENT(IN) :: W(1:,1:) !< W COMPONENT. + REAL(R8P), INTENT(IN) :: X(1:,1:) !< X COMPONENT. + REAL(R8P), INTENT(IN) :: Y(1:,1:) !< Y COMPONENT. + REAL(R8P), INTENT(IN) :: Z(1:,1:) !< Z COMPONENT. + INTEGER(I4P) :: N_BYTE !< NUMBER OF BYTES + INTEGER(I4P) :: N1 !< COUNTER. + INTEGER(I4P) :: N2 !< COUNTER. + + N_BYTE = SELF%WRITE_ON_SCRATCH_DATAARRAY(X=[((U(N1,N2), V(N1,N2), W(N1,N2), & + X(N1,N2), Y(N1,N2), Z(N1,N2), N1=1,SIZE(X, DIM=1)),N2=1,SIZE(X, DIM=2))]) + ENDFUNCTION WRITE_ON_SCRATCH_DATAARRAY6_RANK2_R8P + + FUNCTION WRITE_ON_SCRATCH_DATAARRAY6_RANK2_R4P(SELF, U, V, W, X, Y, Z) RESULT(N_BYTE) + !< WRITE A DATAARRAY WITH 6 COMPONENTS OF RANK 2 (R4P). + CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF !< WRITER. + REAL(R4P), INTENT(IN) :: U(1:,1:) !< U COMPONENT. + REAL(R4P), INTENT(IN) :: V(1:,1:) !< V COMPONENT. + REAL(R4P), INTENT(IN) :: W(1:,1:) !< W COMPONENT. + REAL(R4P), INTENT(IN) :: X(1:,1:) !< X COMPONENT. + REAL(R4P), INTENT(IN) :: Y(1:,1:) !< Y COMPONENT. + REAL(R4P), INTENT(IN) :: Z(1:,1:) !< Z COMPONENT. + INTEGER(I4P) :: N_BYTE !< NUMBER OF BYTES + INTEGER(I4P) :: N1 !< COUNTER. + INTEGER(I4P) :: N2 !< COUNTER. + + N_BYTE = SELF%WRITE_ON_SCRATCH_DATAARRAY(X=[((U(N1,N2), V(N1,N2), W(N1,N2), & + X(N1,N2), Y(N1,N2), Z(N1,N2), N1=1,SIZE(X, DIM=1)),N2=1,SIZE(X, DIM=2))]) + ENDFUNCTION WRITE_ON_SCRATCH_DATAARRAY6_RANK2_R4P + + FUNCTION WRITE_ON_SCRATCH_DATAARRAY6_RANK2_I8P(SELF, U, V, W, X, Y, Z) RESULT(N_BYTE) + !< WRITE A DATAARRAY WITH 6 COMPONENTS OF RANK 2 (I8P). + CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF !< WRITER. + INTEGER(I8P), INTENT(IN) :: U(1:,1:) !< U COMPONENT. + INTEGER(I8P), INTENT(IN) :: V(1:,1:) !< V COMPONENT. + INTEGER(I8P), INTENT(IN) :: W(1:,1:) !< W COMPONENT. + INTEGER(I8P), INTENT(IN) :: X(1:,1:) !< X COMPONENT. + INTEGER(I8P), INTENT(IN) :: Y(1:,1:) !< Y COMPONENT. + INTEGER(I8P), INTENT(IN) :: Z(1:,1:) !< Z COMPONENT. + INTEGER(I4P) :: N_BYTE !< NUMBER OF BYTES + INTEGER(I4P) :: N1 !< COUNTER. + INTEGER(I4P) :: N2 !< COUNTER. + + N_BYTE = SELF%WRITE_ON_SCRATCH_DATAARRAY(X=[((U(N1,N2), V(N1,N2), W(N1,N2), & + X(N1,N2), Y(N1,N2), Z(N1,N2), N1=1,SIZE(X, DIM=1)),N2=1,SIZE(X, DIM=2))]) + ENDFUNCTION WRITE_ON_SCRATCH_DATAARRAY6_RANK2_I8P + + FUNCTION WRITE_ON_SCRATCH_DATAARRAY6_RANK2_I4P(SELF, U, V, W, X, Y, Z) RESULT(N_BYTE) + !< WRITE A DATAARRAY WITH 6 COMPONENTS OF RANK 2 (I4P). + CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF !< WRITER. + INTEGER(I4P), INTENT(IN) :: U(1:,1:) !< U COMPONENT. + INTEGER(I4P), INTENT(IN) :: V(1:,1:) !< V COMPONENT. + INTEGER(I4P), INTENT(IN) :: W(1:,1:) !< W COMPONENT. + INTEGER(I4P), INTENT(IN) :: X(1:,1:) !< X COMPONENT. + INTEGER(I4P), INTENT(IN) :: Y(1:,1:) !< Y COMPONENT. + INTEGER(I4P), INTENT(IN) :: Z(1:,1:) !< Z COMPONENT. + INTEGER(I4P) :: N_BYTE !< NUMBER OF BYTES + INTEGER(I4P) :: N1 !< COUNTER. + INTEGER(I4P) :: N2 !< COUNTER. + + N_BYTE = SELF%WRITE_ON_SCRATCH_DATAARRAY(X=[((U(N1,N2), V(N1,N2), W(N1,N2), & + X(N1,N2), Y(N1,N2), Z(N1,N2), N1=1,SIZE(X, DIM=1)),N2=1,SIZE(X, DIM=2))]) + ENDFUNCTION WRITE_ON_SCRATCH_DATAARRAY6_RANK2_I4P + + FUNCTION WRITE_ON_SCRATCH_DATAARRAY6_RANK2_I2P(SELF, U, V, W, X, Y, Z) RESULT(N_BYTE) + !< WRITE A DATAARRAY WITH 6 COMPONENTS OF RANK 2 (I2P). + CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF !< WRITER. + INTEGER(I2P), INTENT(IN) :: U(1:,1:) !< U COMPONENT. + INTEGER(I2P), INTENT(IN) :: V(1:,1:) !< V COMPONENT. + INTEGER(I2P), INTENT(IN) :: W(1:,1:) !< W COMPONENT. + INTEGER(I2P), INTENT(IN) :: X(1:,1:) !< X COMPONENT. + INTEGER(I2P), INTENT(IN) :: Y(1:,1:) !< Y COMPONENT. + INTEGER(I2P), INTENT(IN) :: Z(1:,1:) !< Z COMPONENT. + INTEGER(I4P) :: N_BYTE !< NUMBER OF BYTES + INTEGER(I4P) :: N1 !< COUNTER. + INTEGER(I4P) :: N2 !< COUNTER. + + N_BYTE = SELF%WRITE_ON_SCRATCH_DATAARRAY(X=[((U(N1,N2), V(N1,N2), W(N1,N2), & + X(N1,N2), Y(N1,N2), Z(N1,N2), N1=1,SIZE(X, DIM=1)),N2=1,SIZE(X, DIM=2))]) + ENDFUNCTION WRITE_ON_SCRATCH_DATAARRAY6_RANK2_I2P + + FUNCTION WRITE_ON_SCRATCH_DATAARRAY6_RANK2_I1P(SELF, U, V, W, X, Y, Z) RESULT(N_BYTE) + !< WRITE A DATAARRAY WITH 6 COMPONENTS OF RANK 2 (I1P). + CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF !< WRITER. + INTEGER(I1P), INTENT(IN) :: U(1:,1:) !< U COMPONENT. + INTEGER(I1P), INTENT(IN) :: V(1:,1:) !< V COMPONENT. + INTEGER(I1P), INTENT(IN) :: W(1:,1:) !< W COMPONENT. + INTEGER(I1P), INTENT(IN) :: X(1:,1:) !< X COMPONENT. + INTEGER(I1P), INTENT(IN) :: Y(1:,1:) !< Y COMPONENT. + INTEGER(I1P), INTENT(IN) :: Z(1:,1:) !< Z COMPONENT. + INTEGER(I4P) :: N_BYTE !< NUMBER OF BYTES + INTEGER(I4P) :: N1 !< COUNTER. + INTEGER(I4P) :: N2 !< COUNTER. + + N_BYTE = SELF%WRITE_ON_SCRATCH_DATAARRAY(X=[((U(N1,N2), V(N1,N2), W(N1,N2), & + X(N1,N2), Y(N1,N2), Z(N1,N2), N1=1,SIZE(X, DIM=1)),N2=1,SIZE(X, DIM=2))]) + ENDFUNCTION WRITE_ON_SCRATCH_DATAARRAY6_RANK2_I1P + + FUNCTION WRITE_ON_SCRATCH_DATAARRAY6_RANK3_R8P(SELF, U, V, W, X, Y, Z) RESULT(N_BYTE) + !< WRITE A DATAARRAY WITH 6 COMPONENTS OF RANK 3 (R8P). + CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF !< WRITER. + REAL(R8P), INTENT(IN) :: U(1:,1:,1:) !< U COMPONENT. + REAL(R8P), INTENT(IN) :: V(1:,1:,1:) !< V COMPONENT. + REAL(R8P), INTENT(IN) :: W(1:,1:,1:) !< W COMPONENT. + REAL(R8P), INTENT(IN) :: X(1:,1:,1:) !< X COMPONENT. + REAL(R8P), INTENT(IN) :: Y(1:,1:,1:) !< Y COMPONENT. + REAL(R8P), INTENT(IN) :: Z(1:,1:,1:) !< Z COMPONENT. + INTEGER(I4P) :: N_BYTE !< NUMBER OF BYTES + INTEGER(I4P) :: N1 !< COUNTER. + INTEGER(I4P) :: N2 !< COUNTER. + INTEGER(I4P) :: N3 !< COUNTER. + + N_BYTE = SELF%WRITE_ON_SCRATCH_DATAARRAY(X=[(((U(N1,N2,N3), V(N1,N2,N3), W(N1,N2,N3), & + X(N1,N2,N3), Y(N1,N2,N3), Z(N1,N2,N3), & + N1=1,SIZE(X, DIM=1)),N2=1,SIZE(X, DIM=2)),N3=1,SIZE(X, DIM=3))]) + ENDFUNCTION WRITE_ON_SCRATCH_DATAARRAY6_RANK3_R8P + + FUNCTION WRITE_ON_SCRATCH_DATAARRAY6_RANK3_R4P(SELF, U, V, W, X, Y, Z) RESULT(N_BYTE) + !< WRITE A DATAARRAY WITH 6 COMPONENTS OF RANK 3 (R4P). + CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF !< WRITER. + REAL(R4P), INTENT(IN) :: U(1:,1:,1:) !< U COMPONENT. + REAL(R4P), INTENT(IN) :: V(1:,1:,1:) !< V COMPONENT. + REAL(R4P), INTENT(IN) :: W(1:,1:,1:) !< W COMPONENT. + REAL(R4P), INTENT(IN) :: X(1:,1:,1:) !< X COMPONENT. + REAL(R4P), INTENT(IN) :: Y(1:,1:,1:) !< Y COMPONENT. + REAL(R4P), INTENT(IN) :: Z(1:,1:,1:) !< Z COMPONENT. + INTEGER(I4P) :: N_BYTE !< NUMBER OF BYTES + INTEGER(I4P) :: N1 !< COUNTER. + INTEGER(I4P) :: N2 !< COUNTER. + INTEGER(I4P) :: N3 !< COUNTER. + + N_BYTE = SELF%WRITE_ON_SCRATCH_DATAARRAY(X=[(((U(N1,N2,N3), V(N1,N2,N3), W(N1,N2,N3), X(N1,N2,N3), Y(N1,N2,N3), Z(N1,N2,N3), & + N1=1,SIZE(X, DIM=1)),N2=1,SIZE(X, DIM=2)),N3=1,SIZE(X, DIM=3))]) + ENDFUNCTION WRITE_ON_SCRATCH_DATAARRAY6_RANK3_R4P + + FUNCTION WRITE_ON_SCRATCH_DATAARRAY6_RANK3_I8P(SELF, U, V, W, X, Y, Z) RESULT(N_BYTE) + !< WRITE A DATAARRAY WITH 6 COMPONENTS OF RANK 3 (I8P). + CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF !< WRITER. + INTEGER(I8P), INTENT(IN) :: U(1:,1:,1:) !< U COMPONENT. + INTEGER(I8P), INTENT(IN) :: V(1:,1:,1:) !< V COMPONENT. + INTEGER(I8P), INTENT(IN) :: W(1:,1:,1:) !< W COMPONENT. + INTEGER(I8P), INTENT(IN) :: X(1:,1:,1:) !< X COMPONENT. + INTEGER(I8P), INTENT(IN) :: Y(1:,1:,1:) !< Y COMPONENT. + INTEGER(I8P), INTENT(IN) :: Z(1:,1:,1:) !< Z COMPONENT. + INTEGER(I4P) :: N_BYTE !< NUMBER OF BYTES + INTEGER(I4P) :: N1 !< COUNTER. + INTEGER(I4P) :: N2 !< COUNTER. + INTEGER(I4P) :: N3 !< COUNTER. + + N_BYTE = SELF%WRITE_ON_SCRATCH_DATAARRAY(X=[(((U(N1,N2,N3), V(N1,N2,N3), W(N1,N2,N3), X(N1,N2,N3), Y(N1,N2,N3), Z(N1,N2,N3), & + N1=1,SIZE(X, DIM=1)),N2=1,SIZE(X, DIM=2)),N3=1,SIZE(X, DIM=3))]) + ENDFUNCTION WRITE_ON_SCRATCH_DATAARRAY6_RANK3_I8P + + FUNCTION WRITE_ON_SCRATCH_DATAARRAY6_RANK3_I4P(SELF, U, V, W, X, Y, Z) RESULT(N_BYTE) + !< WRITE A DATAARRAY WITH 6 COMPONENTS OF RANK 3 (I4P). + CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF !< WRITER. + INTEGER(I4P), INTENT(IN) :: U(1:,1:,1:) !< U COMPONENT. + INTEGER(I4P), INTENT(IN) :: V(1:,1:,1:) !< V COMPONENT. + INTEGER(I4P), INTENT(IN) :: W(1:,1:,1:) !< W COMPONENT. + INTEGER(I4P), INTENT(IN) :: X(1:,1:,1:) !< X COMPONENT. + INTEGER(I4P), INTENT(IN) :: Y(1:,1:,1:) !< Y COMPONENT. + INTEGER(I4P), INTENT(IN) :: Z(1:,1:,1:) !< Z COMPONENT. + INTEGER(I4P) :: N_BYTE !< NUMBER OF BYTES + INTEGER(I4P) :: N1 !< COUNTER. + INTEGER(I4P) :: N2 !< COUNTER. + INTEGER(I4P) :: N3 !< COUNTER. + + N_BYTE = SELF%WRITE_ON_SCRATCH_DATAARRAY(X=[(((U(N1,N2,N3), V(N1,N2,N3), W(N1,N2,N3), X(N1,N2,N3), Y(N1,N2,N3), Z(N1,N2,N3), & + N1=1,SIZE(X, DIM=1)),N2=1,SIZE(X, DIM=2)),N3=1,SIZE(X, DIM=3))]) + ENDFUNCTION WRITE_ON_SCRATCH_DATAARRAY6_RANK3_I4P + + FUNCTION WRITE_ON_SCRATCH_DATAARRAY6_RANK3_I2P(SELF, U, V, W, X, Y, Z) RESULT(N_BYTE) + !< WRITE A DATAARRAY WITH 6 COMPONENTS OF RANK 3 (I2P). + CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF !< WRITER. + INTEGER(I2P), INTENT(IN) :: U(1:,1:,1:) !< U COMPONENT. + INTEGER(I2P), INTENT(IN) :: V(1:,1:,1:) !< V COMPONENT. + INTEGER(I2P), INTENT(IN) :: W(1:,1:,1:) !< W COMPONENT. + INTEGER(I2P), INTENT(IN) :: X(1:,1:,1:) !< X COMPONENT. + INTEGER(I2P), INTENT(IN) :: Y(1:,1:,1:) !< Y COMPONENT. + INTEGER(I2P), INTENT(IN) :: Z(1:,1:,1:) !< Z COMPONENT. + INTEGER(I4P) :: N_BYTE !< NUMBER OF BYTES + INTEGER(I4P) :: N1 !< COUNTER. + INTEGER(I4P) :: N2 !< COUNTER. + INTEGER(I4P) :: N3 !< COUNTER. + + N_BYTE = SELF%WRITE_ON_SCRATCH_DATAARRAY(X=[(((U(N1,N2,N3), V(N1,N2,N3), W(N1,N2,N3), X(N1,N2,N3), Y(N1,N2,N3), Z(N1,N2,N3), & + N1=1,SIZE(X, DIM=1)),N2=1,SIZE(X, DIM=2)),N3=1,SIZE(X, DIM=3))]) + ENDFUNCTION WRITE_ON_SCRATCH_DATAARRAY6_RANK3_I2P + + FUNCTION WRITE_ON_SCRATCH_DATAARRAY6_RANK3_I1P(SELF, U, V, W, X, Y, Z) RESULT(N_BYTE) + !< WRITE A DATAARRAY WITH 6 COMPONENTS OF RANK 3 (I1P). + CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF !< WRITER. + INTEGER(I1P), INTENT(IN) :: U(1:,1:,1:) !< U COMPONENT. + INTEGER(I1P), INTENT(IN) :: V(1:,1:,1:) !< V COMPONENT. + INTEGER(I1P), INTENT(IN) :: W(1:,1:,1:) !< W COMPONENT. + INTEGER(I1P), INTENT(IN) :: X(1:,1:,1:) !< X COMPONENT. + INTEGER(I1P), INTENT(IN) :: Y(1:,1:,1:) !< Y COMPONENT. + INTEGER(I1P), INTENT(IN) :: Z(1:,1:,1:) !< Z COMPONENT. + INTEGER(I4P) :: N_BYTE !< NUMBER OF BYTES + INTEGER(I4P) :: N1 !< COUNTER. + INTEGER(I4P) :: N2 !< COUNTER. + INTEGER(I4P) :: N3 !< COUNTER. + + N_BYTE = SELF%WRITE_ON_SCRATCH_DATAARRAY(X=[(((U(N1,N2,N3), V(N1,N2,N3), W(N1,N2,N3), X(N1,N2,N3), Y(N1,N2,N3), Z(N1,N2,N3), & + N1=1,SIZE(X, DIM=1)),N2=1,SIZE(X, DIM=2)),N3=1,SIZE(X, DIM=3))]) + ENDFUNCTION WRITE_ON_SCRATCH_DATAARRAY6_RANK3_I1P +ENDMODULE VTKF_FILE_XML_WRITER_APPENDED + + + + +!< VTK FILE XML WRITER, BINARY LOCAL. +MODULE VTKF_FILE_XML_WRITER_BINARY_LOCAL +!< VTK FILE XML WRITER, BINARY LOCAL. +!< +!< THIS WRITER IS (CURRENTLY) THE ONLY ONE ABLE ALSO TO CREATE A *VOLATILE* FILE (ENABLING VOLATILE OPTION). +!< INSTEAD OF SAVING DATA INTO A REAL FILE ON THE SYSTEM, THIS WRITER CAN SAVE DATA INTO A (VOLATILE) CHARACTERS STRING THAT CAN BE +!< USED ALSO ON (SLAVE) PROCESSES THAT HAVE NOT ACCESS TO FILESYSTEM: THE VOLATILE STRING CAN BE EASILY SENT TO OTHER (MASTER) +!< PROCESSES HAVING ACCESS TO FILESYTEM. THE VOLATILE WRITER MODE IS DESIGNED TO FACILITATE THE USE OF THE LIBRARY IN PARALLEL +!< ENVINROMENTS WEHERE NOT ALL PROCESSES/THREADS HAVE ACCESS TO FILESYSTEM. +USE PENF +USE STRINGIFOR +USE VTK_FORTRAN_DATAARRAY_ENCODER +USE VTKF_FILE_XML_WRITER_ABSTRACT + +IMPLICIT NONE +PRIVATE +PUBLIC :: XML_WRITER_BINARY_LOCAL + +TYPE, EXTENDS(XML_WRITER_ABSTRACT) :: XML_WRITER_BINARY_LOCAL + !< VTK FILE XML WRITER, BINARY LOCAL. + CONTAINS + ! DEFERRED METHODS + PROCEDURE, PASS(SELF) :: INITIALIZE !< INITIALIZE WRITER. + PROCEDURE, PASS(SELF) :: FINALIZE !< FINALIZE WRITER. + PROCEDURE, PASS(SELF) :: W_DATA1_RANK1_R8P !< WRITE DATAARRAY 1, RANK 1, R8P. + PROCEDURE, PASS(SELF) :: W_DATA1_RANK1_R4P !< WRITE DATAARRAY 1, RANK 1, R4P. + PROCEDURE, PASS(SELF) :: W_DATA1_RANK1_I8P !< WRITE DATAARRAY 1, RANK 1, I8P. + PROCEDURE, PASS(SELF) :: W_DATA1_RANK1_I4P !< WRITE DATAARRAY 1, RANK 1, I4P. + PROCEDURE, PASS(SELF) :: W_DATA1_RANK1_I2P !< WRITE DATAARRAY 1, RANK 1, I2P. + PROCEDURE, PASS(SELF) :: W_DATA1_RANK1_I1P !< WRITE DATAARRAY 1, RANK 1, I1P. + PROCEDURE, PASS(SELF) :: W_DATA1_RANK2_R8P !< WRITE DATAARRAY 1, RANK 2, R8P. + PROCEDURE, PASS(SELF) :: W_DATA1_RANK2_R4P !< WRITE DATAARRAY 1, RANK 2, R4P. + PROCEDURE, PASS(SELF) :: W_DATA1_RANK2_I8P !< WRITE DATAARRAY 1, RANK 2, I8P. + PROCEDURE, PASS(SELF) :: W_DATA1_RANK2_I4P !< WRITE DATAARRAY 1, RANK 2, I4P. + PROCEDURE, PASS(SELF) :: W_DATA1_RANK2_I2P !< WRITE DATAARRAY 1, RANK 2, I2P. + PROCEDURE, PASS(SELF) :: W_DATA1_RANK2_I1P !< WRITE DATAARRAY 1, RANK 2, I1P. + PROCEDURE, PASS(SELF) :: W_DATA1_RANK3_R8P !< WRITE DATAARRAY 1, RANK 3, R8P. + PROCEDURE, PASS(SELF) :: W_DATA1_RANK3_R4P !< WRITE DATAARRAY 1, RANK 3, R4P. + PROCEDURE, PASS(SELF) :: W_DATA1_RANK3_I8P !< WRITE DATAARRAY 1, RANK 3, I8P. + PROCEDURE, PASS(SELF) :: W_DATA1_RANK3_I4P !< WRITE DATAARRAY 1, RANK 3, I4P. + PROCEDURE, PASS(SELF) :: W_DATA1_RANK3_I2P !< WRITE DATAARRAY 1, RANK 3, I2P. + PROCEDURE, PASS(SELF) :: W_DATA1_RANK3_I1P !< WRITE DATAARRAY 1, RANK 3, I1P. + PROCEDURE, PASS(SELF) :: W_DATA1_RANK4_R8P !< WRITE DATAARRAY 1, RANK 4, R8P. + PROCEDURE, PASS(SELF) :: W_DATA1_RANK4_R4P !< WRITE DATAARRAY 1, RANK 4, R4P. + PROCEDURE, PASS(SELF) :: W_DATA1_RANK4_I8P !< WRITE DATAARRAY 1, RANK 4, I8P. + PROCEDURE, PASS(SELF) :: W_DATA1_RANK4_I4P !< WRITE DATAARRAY 1, RANK 4, I4P. + PROCEDURE, PASS(SELF) :: W_DATA1_RANK4_I2P !< WRITE DATAARRAY 1, RANK 4, I2P. + PROCEDURE, PASS(SELF) :: W_DATA1_RANK4_I1P !< WRITE DATAARRAY 1, RANK 4, I1P. + PROCEDURE, PASS(SELF) :: W_DATA3_RANK1_R8P !< WRITE DATAARRAY 3, RANK 1, R8P. + PROCEDURE, PASS(SELF) :: W_DATA3_RANK1_R4P !< WRITE DATAARRAY 3, RANK 1, R4P. + PROCEDURE, PASS(SELF) :: W_DATA3_RANK1_I8P !< WRITE DATAARRAY 3, RANK 1, I8P. + PROCEDURE, PASS(SELF) :: W_DATA3_RANK1_I4P !< WRITE DATAARRAY 3, RANK 1, I4P. + PROCEDURE, PASS(SELF) :: W_DATA3_RANK1_I2P !< WRITE DATAARRAY 3, RANK 1, I2P. + PROCEDURE, PASS(SELF) :: W_DATA3_RANK1_I1P !< WRITE DATAARRAY 3, RANK 1, I1P. + PROCEDURE, PASS(SELF) :: W_DATA3_RANK3_R8P !< WRITE DATAARRAY 3, RANK 3, R8P. + PROCEDURE, PASS(SELF) :: W_DATA3_RANK3_R4P !< WRITE DATAARRAY 3, RANK 3, R4P. + PROCEDURE, PASS(SELF) :: W_DATA3_RANK3_I8P !< WRITE DATAARRAY 3, RANK 3, I8P. + PROCEDURE, PASS(SELF) :: W_DATA3_RANK3_I4P !< WRITE DATAARRAY 3, RANK 3, I4P. + PROCEDURE, PASS(SELF) :: W_DATA3_RANK3_I2P !< WRITE DATAARRAY 3, RANK 3, I2P. + PROCEDURE, PASS(SELF) :: W_DATA3_RANK3_I1P !< WRITE DATAARRAY 3, RANK 3, I1P. + PROCEDURE, PASS(SELF) :: W_DATA6_RANK1_R8P !< WRITE DATAARRAY 6, RANK 1, R8P. + PROCEDURE, PASS(SELF) :: W_DATA6_RANK1_R4P !< WRITE DATAARRAY 6, RANK 1, R4P. + PROCEDURE, PASS(SELF) :: W_DATA6_RANK1_I8P !< WRITE DATAARRAY 6, RANK 1, I8P. + PROCEDURE, PASS(SELF) :: W_DATA6_RANK1_I4P !< WRITE DATAARRAY 6, RANK 1, I4P. + PROCEDURE, PASS(SELF) :: W_DATA6_RANK1_I2P !< WRITE DATAARRAY 6, RANK 1, I2P. + PROCEDURE, PASS(SELF) :: W_DATA6_RANK1_I1P !< WRITE DATAARRAY 6, RANK 1, I1P. + PROCEDURE, PASS(SELF) :: W_DATA6_RANK3_R8P !< WRITE DATAARRAY 6, RANK 3, R8P. + PROCEDURE, PASS(SELF) :: W_DATA6_RANK3_R4P !< WRITE DATAARRAY 6, RANK 3, R4P. + PROCEDURE, PASS(SELF) :: W_DATA6_RANK3_I8P !< WRITE DATAARRAY 6, RANK 3, I8P. + PROCEDURE, PASS(SELF) :: W_DATA6_RANK3_I4P !< WRITE DATAARRAY 6, RANK 3, I4P. + PROCEDURE, PASS(SELF) :: W_DATA6_RANK3_I2P !< WRITE DATAARRAY 6, RANK 3, I2P. + PROCEDURE, PASS(SELF) :: W_DATA6_RANK3_I1P !< WRITE DATAARRAY 6, RANK 3, I1P. + PROCEDURE, PASS(SELF) :: W_DATA_APPENDED !< WRITE APPENDED. +ENDTYPE XML_WRITER_BINARY_LOCAL +CONTAINS + FUNCTION INITIALIZE(SELF, FORMAT, FILENAME, MESH_TOPOLOGY, NX1, NX2, NY1, NY2, NZ1, NZ2, & + IS_VOLATILE, MESH_KIND) RESULT(ERROR) + !< INITIALIZE WRITER. + CLASS(XML_WRITER_BINARY_LOCAL), INTENT(INOUT) :: SELF !< WRITER. + CHARACTER(*), INTENT(IN) :: FORMAT !< FILE FORMAT: BINARY. + CHARACTER(*), INTENT(IN) :: FILENAME !< FILE NAME. + CHARACTER(*), INTENT(IN) :: MESH_TOPOLOGY !< MESH TOPOLOGY. + INTEGER(I4P), INTENT(IN), OPTIONAL :: NX1 !< INITIAL NODE OF X AXIS. + INTEGER(I4P), INTENT(IN), OPTIONAL :: NX2 !< FINAL NODE OF X AXIS. + INTEGER(I4P), INTENT(IN), OPTIONAL :: NY1 !< INITIAL NODE OF Y AXIS. + INTEGER(I4P), INTENT(IN), OPTIONAL :: NY2 !< FINAL NODE OF Y AXIS. + INTEGER(I4P), INTENT(IN), OPTIONAL :: NZ1 !< INITIAL NODE OF Z AXIS. + INTEGER(I4P), INTENT(IN), OPTIONAL :: NZ2 !< FINAL NODE OF Z AXIS. + CHARACTER(*), INTENT(IN), OPTIONAL :: MESH_KIND !< KIND OF MESH DATA: FLOAT64, FLOAT32, ECC. + LOGICAL, INTENT(IN), OPTIONAL :: IS_VOLATILE !< FLAG TO CHECK VOLATILE WRITER. + INTEGER(I4P) :: ERROR !< ERROR STATUS. + + SELF%IS_VOLATILE = .FALSE. ; IF (PRESENT(IS_VOLATILE)) SELF%IS_VOLATILE = IS_VOLATILE + SELF%TOPOLOGY = TRIM(ADJUSTL(MESH_TOPOLOGY)) + SELF%FORMAT_CH = FORMAT + SELF%FORMAT_CH = SELF%FORMAT_CH%LOWER() + CALL SELF%OPEN_XML_FILE(FILENAME=FILENAME) + CALL SELF%WRITE_HEADER_TAG + CALL SELF%WRITE_TOPOLOGY_TAG(NX1=NX1, NX2=NX2, NY1=NY1, NY2=NY2, NZ1=NZ1, NZ2=NZ2, MESH_KIND=MESH_KIND) + ERROR = SELF%ERROR + ENDFUNCTION INITIALIZE + + FUNCTION FINALIZE(SELF) RESULT(ERROR) + !< FINALIZE WRITER. + CLASS(XML_WRITER_BINARY_LOCAL), INTENT(INOUT) :: SELF !< WRITER. + INTEGER(I4P) :: ERROR !< ERROR STATUS. + + CALL SELF%WRITE_END_TAG(NAME=SELF%TOPOLOGY%CHARS()) + CALL SELF%WRITE_END_TAG(NAME='VTKFile') + CALL SELF%CLOSE_XML_FILE + ERROR = SELF%ERROR + ENDFUNCTION FINALIZE + + ! W_DATA METHODS + FUNCTION W_DATA1_RANK1_R8P(SELF, DATA_NAME, X, IS_TUPLES) RESULT(ERROR) + !< WRITE `<DATAARRAY... NumberOfComponents="1"...>...</DATAARRAY>` TAG (R8P). + CLASS(XML_WRITER_BINARY_LOCAL), INTENT(INOUT) :: SELF !< WRITER. + CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. + REAL(R8P), INTENT(IN) :: X(1:) !< DATA VARIABLE. + LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". + INTEGER(I4P) :: ERROR !< ERROR STATUS. + CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. + INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. + CHARACTER(LEN=:), ALLOCATABLE :: CODE !< DATA VARIABLE ENCODED, BINARY OR BASE64 CODEC. + + DATA_TYPE = 'Float64' + N_COMPONENTS = 1 + CODE = ENCODE_BINARY_DATAARRAY(X=X) + CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, & + IS_TUPLES=IS_TUPLES) + ERROR = SELF%ERROR + ENDFUNCTION W_DATA1_RANK1_R8P + + FUNCTION W_DATA1_RANK1_R4P(SELF, DATA_NAME, X, IS_TUPLES) RESULT(ERROR) + !< WRITE `<DATAARRAY... NumberOfComponents="1"...>...</DATAARRAY>` TAG (R4P). + CLASS(XML_WRITER_BINARY_LOCAL), INTENT(INOUT) :: SELF !< WRITER. + CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. + REAL(R4P), INTENT(IN) :: X(1:) !< DATA VARIABLE. + LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". + INTEGER(I4P) :: ERROR !< ERROR STATUS. + CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. + INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. + CHARACTER(LEN=:), ALLOCATABLE :: CODE !< DATA VARIABLE ENCODED, BINARY OR BASE64 CODEC. + + DATA_TYPE = 'Float32' + N_COMPONENTS = 1 + CODE = ENCODE_BINARY_DATAARRAY(X=X) + CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, & + IS_TUPLES=IS_TUPLES) + ERROR = SELF%ERROR + ENDFUNCTION W_DATA1_RANK1_R4P + + FUNCTION W_DATA1_RANK1_I8P(SELF, DATA_NAME, X, IS_TUPLES) RESULT(ERROR) + !< WRITE `<DATAARRAY... NumberOfComponents="1"...>...</DATAARRAY>` TAG (I8P). + CLASS(XML_WRITER_BINARY_LOCAL), INTENT(INOUT) :: SELF !< WRITER. + CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. + INTEGER(I8P), INTENT(IN) :: X(1:) !< DATA VARIABLE. + LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". + INTEGER(I4P) :: ERROR !< ERROR STATUS. + CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. + INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. + CHARACTER(LEN=:), ALLOCATABLE :: CODE !< DATA VARIABLE ENCODED, BINARY OR BASE64 CODEC. + + DATA_TYPE = 'Int64' + N_COMPONENTS = 1 + CODE = ENCODE_BINARY_DATAARRAY(X=X) + CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, & + IS_TUPLES=IS_TUPLES) + ERROR = SELF%ERROR + ENDFUNCTION W_DATA1_RANK1_I8P + + FUNCTION W_DATA1_RANK1_I4P(SELF, DATA_NAME, X, IS_TUPLES) RESULT(ERROR) + !< WRITE `<DATAARRAY... NumberOfComponents="1"...>...</DATAARRAY>` TAG (I4P). + CLASS(XML_WRITER_BINARY_LOCAL), INTENT(INOUT) :: SELF !< WRITER. + CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. + INTEGER(I4P), INTENT(IN) :: X(1:) !< DATA VARIABLE. + LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". + INTEGER(I4P) :: ERROR !< ERROR STATUS. + CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. + INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. + CHARACTER(LEN=:), ALLOCATABLE :: CODE !< DATA VARIABLE ENCODED, BINARY OR BASE64 CODEC. + + DATA_TYPE = 'Int32' + N_COMPONENTS = 1 + CODE = ENCODE_BINARY_DATAARRAY(X=X) + CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, & + IS_TUPLES=IS_TUPLES) + ERROR = SELF%ERROR + ENDFUNCTION W_DATA1_RANK1_I4P + + FUNCTION W_DATA1_RANK1_I2P(SELF, DATA_NAME, X, IS_TUPLES) RESULT(ERROR) + !< WRITE `<DATAARRAY... NumberOfComponents="1"...>...</DATAARRAY>` TAG (I2P). + CLASS(XML_WRITER_BINARY_LOCAL), INTENT(INOUT) :: SELF !< WRITER. + CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. + INTEGER(I2P), INTENT(IN) :: X(1:) !< DATA VARIABLE. + LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". + INTEGER(I4P) :: ERROR !< ERROR STATUS. + CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. + INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. + CHARACTER(LEN=:), ALLOCATABLE :: CODE !< DATA VARIABLE ENCODED, BINARY OR BASE64 CODEC. + + DATA_TYPE = 'Int16' + N_COMPONENTS = 1 + CODE = ENCODE_BINARY_DATAARRAY(X=X) + CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, & + IS_TUPLES=IS_TUPLES) + ERROR = SELF%ERROR + ENDFUNCTION W_DATA1_RANK1_I2P + + FUNCTION W_DATA1_RANK1_I1P(SELF, DATA_NAME, X, IS_TUPLES) RESULT(ERROR) + !< WRITE `<DATAARRAY... NumberOfComponents="1"...>...</DATAARRAY>` TAG (I1P). + CLASS(XML_WRITER_BINARY_LOCAL), INTENT(INOUT) :: SELF !< WRITER. + CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. + INTEGER(I1P), INTENT(IN) :: X(1:) !< DATA VARIABLE. + LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". + INTEGER(I4P) :: ERROR !< ERROR STATUS. + CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. + INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. + CHARACTER(LEN=:), ALLOCATABLE :: CODE !< DATA VARIABLE ENCODED, BINARY OR BASE64 CODEC. + + DATA_TYPE = 'Int8' + N_COMPONENTS = 1 + CODE = ENCODE_BINARY_DATAARRAY(X=X) + CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, & + IS_TUPLES=IS_TUPLES) + ERROR = SELF%ERROR + ENDFUNCTION W_DATA1_RANK1_I1P + + FUNCTION W_DATA1_RANK2_R8P(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR) + !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (R8P). + CLASS(XML_WRITER_BINARY_LOCAL), INTENT(INOUT) :: SELF !< WRITER. + CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. + REAL(R8P), INTENT(IN) :: X(1:,1:) !< DATA VARIABLE. + LOGICAL, INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT. + LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". + INTEGER(I4P) :: ERROR !< ERROR STATUS. + CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. + INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. + CHARACTER(LEN=:), ALLOCATABLE :: CODE !< DATA VARIABLE ENCODED, BINARY OR BASE64 CODEC. + + DATA_TYPE = 'Float64' + N_COMPONENTS = SIZE(X, DIM=1) + IF (PRESENT(ONE_COMPONENT)) THEN + IF (ONE_COMPONENT) N_COMPONENTS = 1 + ENDIF + CODE = ENCODE_BINARY_DATAARRAY(X=X) + CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, & + IS_TUPLES=IS_TUPLES) + ERROR = SELF%ERROR + ENDFUNCTION W_DATA1_RANK2_R8P + + FUNCTION W_DATA1_RANK2_R4P(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR) + !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (R4P). + CLASS(XML_WRITER_BINARY_LOCAL), INTENT(INOUT) :: SELF !< WRITER. + CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. + REAL(R4P), INTENT(IN) :: X(1:,1:) !< DATA VARIABLE. + LOGICAL, INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT. + LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". + INTEGER(I4P) :: ERROR !< ERROR STATUS. + CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. + INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. + CHARACTER(LEN=:), ALLOCATABLE :: CODE !< DATA VARIABLE ENCODED, BINARY OR BASE64 CODEC. + + DATA_TYPE = 'Float32' + N_COMPONENTS = SIZE(X, DIM=1) + IF (PRESENT(ONE_COMPONENT)) THEN + IF (ONE_COMPONENT) N_COMPONENTS = 1 + ENDIF + CODE = ENCODE_BINARY_DATAARRAY(X=X) + CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, & + IS_TUPLES=IS_TUPLES) + ERROR = SELF%ERROR + ENDFUNCTION W_DATA1_RANK2_R4P + + FUNCTION W_DATA1_RANK2_I8P(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR) + !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (I8P). + CLASS(XML_WRITER_BINARY_LOCAL), INTENT(INOUT) :: SELF !< WRITER. + CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. + INTEGER(I8P), INTENT(IN) :: X(1:,1:) !< DATA VARIABLE. + LOGICAL, INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT. + LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". + INTEGER(I4P) :: ERROR !< ERROR STATUS. + CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. + INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. + CHARACTER(LEN=:), ALLOCATABLE :: CODE !< DATA VARIABLE ENCODED, BINARY OR BASE64 CODEC. + + DATA_TYPE = 'Int64' + N_COMPONENTS = SIZE(X, DIM=1) + IF (PRESENT(ONE_COMPONENT)) THEN + IF (ONE_COMPONENT) N_COMPONENTS = 1 + ENDIF + CODE = ENCODE_BINARY_DATAARRAY(X=X) + CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, & + IS_TUPLES=IS_TUPLES) + ERROR = SELF%ERROR + ENDFUNCTION W_DATA1_RANK2_I8P + + FUNCTION W_DATA1_RANK2_I4P(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR) + !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (I4P). + CLASS(XML_WRITER_BINARY_LOCAL), INTENT(INOUT) :: SELF !< WRITER. + CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. + INTEGER(I4P), INTENT(IN) :: X(1:,1:) !< DATA VARIABLE. + LOGICAL, INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT. + LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". + INTEGER(I4P) :: ERROR !< ERROR STATUS. + CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. + INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. + CHARACTER(LEN=:), ALLOCATABLE :: CODE !< DATA VARIABLE ENCODED, BINARY OR BASE64 CODEC. + + DATA_TYPE = 'Int32' + N_COMPONENTS = SIZE(X, DIM=1) + IF (PRESENT(ONE_COMPONENT)) THEN + IF (ONE_COMPONENT) N_COMPONENTS = 1 + ENDIF + CODE = ENCODE_BINARY_DATAARRAY(X=X) + CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, & + IS_TUPLES=IS_TUPLES) + ERROR = SELF%ERROR + ENDFUNCTION W_DATA1_RANK2_I4P + + FUNCTION W_DATA1_RANK2_I2P(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR) + !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (I2P). + CLASS(XML_WRITER_BINARY_LOCAL), INTENT(INOUT) :: SELF !< WRITER. + CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. + INTEGER(I2P), INTENT(IN) :: X(1:,1:) !< DATA VARIABLE. + LOGICAL, INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT. + LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". + INTEGER(I4P) :: ERROR !< ERROR STATUS. + CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. + INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. + CHARACTER(LEN=:), ALLOCATABLE :: CODE !< DATA VARIABLE ENCODED, BINARY OR BASE64 CODEC. + + DATA_TYPE = 'Int16' + N_COMPONENTS = SIZE(X, DIM=1) + IF (PRESENT(ONE_COMPONENT)) THEN + IF (ONE_COMPONENT) N_COMPONENTS = 1 + ENDIF + CODE = ENCODE_BINARY_DATAARRAY(X=X) + CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, & + IS_TUPLES=IS_TUPLES) + ERROR = SELF%ERROR + ENDFUNCTION W_DATA1_RANK2_I2P + + FUNCTION W_DATA1_RANK2_I1P(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR) + !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (I1P). + CLASS(XML_WRITER_BINARY_LOCAL), INTENT(INOUT) :: SELF !< WRITER. + CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. + INTEGER(I1P), INTENT(IN) :: X(1:,1:) !< DATA VARIABLE. + LOGICAL, INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT. + LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". + INTEGER(I4P) :: ERROR !< ERROR STATUS. + CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. + INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. + CHARACTER(LEN=:), ALLOCATABLE :: CODE !< DATA VARIABLE ENCODED, BINARY OR BASE64 CODEC. + + DATA_TYPE = 'Int8' + N_COMPONENTS = SIZE(X, DIM=1) + IF (PRESENT(ONE_COMPONENT)) THEN + IF (ONE_COMPONENT) N_COMPONENTS = 1 + ENDIF + CODE = ENCODE_BINARY_DATAARRAY(X=X) + CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, & + IS_TUPLES=IS_TUPLES) + ERROR = SELF%ERROR + ENDFUNCTION W_DATA1_RANK2_I1P + + FUNCTION W_DATA1_RANK3_R8P(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR) + !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (R8P). + CLASS(XML_WRITER_BINARY_LOCAL), INTENT(INOUT) :: SELF !< WRITER. + CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. + REAL(R8P), INTENT(IN) :: X(1:,1:,1:) !< DATA VARIABLE. + LOGICAL, INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT. + LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". + INTEGER(I4P) :: ERROR !< ERROR STATUS. + CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. + INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. + CHARACTER(LEN=:), ALLOCATABLE :: CODE !< DATA VARIABLE ENCODED, BINARY OR BASE64 CODEC. + + DATA_TYPE = 'Float64' + N_COMPONENTS = SIZE(X, DIM=1) + IF (PRESENT(ONE_COMPONENT)) THEN + IF (ONE_COMPONENT) N_COMPONENTS = 1 + ENDIF + CODE = ENCODE_BINARY_DATAARRAY(X=X) + CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, & + IS_TUPLES=IS_TUPLES) + ERROR = SELF%ERROR + ENDFUNCTION W_DATA1_RANK3_R8P + + FUNCTION W_DATA1_RANK3_R4P(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR) + !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (R4P). + CLASS(XML_WRITER_BINARY_LOCAL), INTENT(INOUT) :: SELF !< WRITER. + CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. + REAL(R4P), INTENT(IN) :: X(1:,1:,1:) !< DATA VARIABLE. + LOGICAL, INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT. + LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". + INTEGER(I4P) :: ERROR !< ERROR STATUS. + CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. + INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. + CHARACTER(LEN=:), ALLOCATABLE :: CODE !< DATA VARIABLE ENCODED, BINARY OR BASE64 CODEC. + + DATA_TYPE = 'Float32' + N_COMPONENTS = SIZE(X, DIM=1) + IF (PRESENT(ONE_COMPONENT)) THEN + IF (ONE_COMPONENT) N_COMPONENTS = 1 + ENDIF + CODE = ENCODE_BINARY_DATAARRAY(X=X) + CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, & + IS_TUPLES=IS_TUPLES) + ERROR = SELF%ERROR + ENDFUNCTION W_DATA1_RANK3_R4P + + FUNCTION W_DATA1_RANK3_I8P(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR) + !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (I8P). + CLASS(XML_WRITER_BINARY_LOCAL), INTENT(INOUT) :: SELF !< WRITER. + CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. + INTEGER(I8P), INTENT(IN) :: X(1:,1:,1:) !< DATA VARIABLE. + LOGICAL, INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT. + LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". + INTEGER(I4P) :: ERROR !< ERROR STATUS. + CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. + INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. + CHARACTER(LEN=:), ALLOCATABLE :: CODE !< DATA VARIABLE ENCODED, BINARY OR BASE64 CODEC. + + DATA_TYPE = 'Int64' + N_COMPONENTS = SIZE(X, DIM=1) + IF (PRESENT(ONE_COMPONENT)) THEN + IF (ONE_COMPONENT) N_COMPONENTS = 1 + ENDIF + CODE = ENCODE_BINARY_DATAARRAY(X=X) + CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, & + IS_TUPLES=IS_TUPLES) + ERROR = SELF%ERROR + ENDFUNCTION W_DATA1_RANK3_I8P + + FUNCTION W_DATA1_RANK3_I4P(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR) + !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (I4P). + CLASS(XML_WRITER_BINARY_LOCAL), INTENT(INOUT) :: SELF !< WRITER. + CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. + INTEGER(I4P), INTENT(IN) :: X(1:,1:,1:) !< DATA VARIABLE. + LOGICAL, INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT. + LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". + INTEGER(I4P) :: ERROR !< ERROR STATUS. + CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. + INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. + CHARACTER(LEN=:), ALLOCATABLE :: CODE !< DATA VARIABLE ENCODED, BINARY OR BASE64 CODEC. + + DATA_TYPE = 'Int32' + N_COMPONENTS = SIZE(X, DIM=1) + IF (PRESENT(ONE_COMPONENT)) THEN + IF (ONE_COMPONENT) N_COMPONENTS = 1 + ENDIF + CODE = ENCODE_BINARY_DATAARRAY(X=X) + CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, & + IS_TUPLES=IS_TUPLES) + ERROR = SELF%ERROR + ENDFUNCTION W_DATA1_RANK3_I4P + + FUNCTION W_DATA1_RANK3_I2P(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR) + !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (I2P). + CLASS(XML_WRITER_BINARY_LOCAL), INTENT(INOUT) :: SELF !< WRITER. + CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. + INTEGER(I2P), INTENT(IN) :: X(1:,1:,1:) !< DATA VARIABLE. + LOGICAL, INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT. + LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". + INTEGER(I4P) :: ERROR !< ERROR STATUS. + CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. + INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. + CHARACTER(LEN=:), ALLOCATABLE :: CODE !< DATA VARIABLE ENCODED, BINARY OR BASE64 CODEC. + + DATA_TYPE = 'Int16' + N_COMPONENTS = SIZE(X, DIM=1) + IF (PRESENT(ONE_COMPONENT)) THEN + IF (ONE_COMPONENT) N_COMPONENTS = 1 + ENDIF + CODE = ENCODE_BINARY_DATAARRAY(X=X) + CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, & + IS_TUPLES=IS_TUPLES) + ERROR = SELF%ERROR + ENDFUNCTION W_DATA1_RANK3_I2P + + FUNCTION W_DATA1_RANK3_I1P(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR) + !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (I1P). + CLASS(XML_WRITER_BINARY_LOCAL), INTENT(INOUT) :: SELF !< WRITER. + CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. + INTEGER(I1P), INTENT(IN) :: X(1:,1:,1:) !< DATA VARIABLE. + LOGICAL, INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT. + LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". + INTEGER(I4P) :: ERROR !< ERROR STATUS. + CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. + INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. + CHARACTER(LEN=:), ALLOCATABLE :: CODE !< DATA VARIABLE ENCODED, BINARY OR BASE64 CODEC. + + DATA_TYPE = 'Int8' + N_COMPONENTS = SIZE(X, DIM=1) + IF (PRESENT(ONE_COMPONENT)) THEN + IF (ONE_COMPONENT) N_COMPONENTS = 1 + ENDIF + CODE = ENCODE_BINARY_DATAARRAY(X=X) + CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, & + IS_TUPLES=IS_TUPLES) + ERROR = SELF%ERROR + ENDFUNCTION W_DATA1_RANK3_I1P + + FUNCTION W_DATA1_RANK4_R8P(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR) + !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (R8P). + CLASS(XML_WRITER_BINARY_LOCAL), INTENT(INOUT) :: SELF !< WRITER. + CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. + REAL(R8P), INTENT(IN) :: X(1:,1:,1:,1:) !< DATA VARIABLE. + LOGICAL, INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT. + LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". + INTEGER(I4P) :: ERROR !< ERROR STATUS. + CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. + INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. + CHARACTER(LEN=:), ALLOCATABLE :: CODE !< DATA VARIABLE ENCODED, BINARY OR BASE64 CODEC. + + DATA_TYPE = 'Float64' + N_COMPONENTS = SIZE(X, DIM=1) + IF (PRESENT(ONE_COMPONENT)) THEN + IF (ONE_COMPONENT) N_COMPONENTS = 1 + ENDIF + CODE = ENCODE_BINARY_DATAARRAY(X=X) + CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, & + IS_TUPLES=IS_TUPLES) + ERROR = SELF%ERROR + ENDFUNCTION W_DATA1_RANK4_R8P + + FUNCTION W_DATA1_RANK4_R4P(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR) + !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (R4P). + CLASS(XML_WRITER_BINARY_LOCAL), INTENT(INOUT) :: SELF !< WRITER. + CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. + REAL(R4P), INTENT(IN) :: X(1:,1:,1:,1:) !< DATA VARIABLE. + LOGICAL, INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT. + LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". + INTEGER(I4P) :: ERROR !< ERROR STATUS. + CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. + INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. + CHARACTER(LEN=:), ALLOCATABLE :: CODE !< DATA VARIABLE ENCODED, BINARY OR BASE64 CODEC. + + DATA_TYPE = 'Float32' + N_COMPONENTS = SIZE(X, DIM=1) + IF (PRESENT(ONE_COMPONENT)) THEN + IF (ONE_COMPONENT) N_COMPONENTS = 1 + ENDIF + CODE = ENCODE_BINARY_DATAARRAY(X=X) + CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, & + IS_TUPLES=IS_TUPLES) + ERROR = SELF%ERROR + ENDFUNCTION W_DATA1_RANK4_R4P + + FUNCTION W_DATA1_RANK4_I8P(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR) + !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (I8P). + CLASS(XML_WRITER_BINARY_LOCAL), INTENT(INOUT) :: SELF !< WRITER. + CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. + INTEGER(I8P), INTENT(IN) :: X(1:,1:,1:,1:) !< DATA VARIABLE. + LOGICAL, INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT. + LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". + INTEGER(I4P) :: ERROR !< ERROR STATUS. + CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. + INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. + CHARACTER(LEN=:), ALLOCATABLE :: CODE !< DATA VARIABLE ENCODED, BINARY OR BASE64 CODEC. + + DATA_TYPE = 'Int64' + N_COMPONENTS = SIZE(X, DIM=1) + IF (PRESENT(ONE_COMPONENT)) THEN + IF (ONE_COMPONENT) N_COMPONENTS = 1 + ENDIF + CODE = ENCODE_BINARY_DATAARRAY(X=X) + CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, & + IS_TUPLES=IS_TUPLES) + ERROR = SELF%ERROR + ENDFUNCTION W_DATA1_RANK4_I8P + + FUNCTION W_DATA1_RANK4_I4P(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR) + !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (I4P). + CLASS(XML_WRITER_BINARY_LOCAL), INTENT(INOUT) :: SELF !< WRITER. + CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. + INTEGER(I4P), INTENT(IN) :: X(1:,1:,1:,1:) !< DATA VARIABLE. + LOGICAL, INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT. + LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". + INTEGER(I4P) :: ERROR !< ERROR STATUS. + CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. + INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. + CHARACTER(LEN=:), ALLOCATABLE :: CODE !< DATA VARIABLE ENCODED, BINARY OR BASE64 CODEC. + + DATA_TYPE = 'Int32' + N_COMPONENTS = SIZE(X, DIM=1) + IF (PRESENT(ONE_COMPONENT)) THEN + IF (ONE_COMPONENT) N_COMPONENTS = 1 + ENDIF + CODE = ENCODE_BINARY_DATAARRAY(X=X) + CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, & + IS_TUPLES=IS_TUPLES) + ERROR = SELF%ERROR + ENDFUNCTION W_DATA1_RANK4_I4P + + FUNCTION W_DATA1_RANK4_I2P(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR) + !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (I2P). + CLASS(XML_WRITER_BINARY_LOCAL), INTENT(INOUT) :: SELF !< WRITER. + CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. + INTEGER(I2P), INTENT(IN) :: X(1:,1:,1:,1:) !< DATA VARIABLE. + LOGICAL, INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT. + LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". + INTEGER(I4P) :: ERROR !< ERROR STATUS. + CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. + INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. + CHARACTER(LEN=:), ALLOCATABLE :: CODE !< DATA VARIABLE ENCODED, BINARY OR BASE64 CODEC. + + DATA_TYPE = 'Int16' + N_COMPONENTS = SIZE(X, DIM=1) + IF (PRESENT(ONE_COMPONENT)) THEN + IF (ONE_COMPONENT) N_COMPONENTS = 1 + ENDIF + CODE = ENCODE_BINARY_DATAARRAY(X=X) + CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, & + IS_TUPLES=IS_TUPLES) + ERROR = SELF%ERROR + ENDFUNCTION W_DATA1_RANK4_I2P + + FUNCTION W_DATA1_RANK4_I1P(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR) + !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (I1P). + CLASS(XML_WRITER_BINARY_LOCAL), INTENT(INOUT) :: SELF !< WRITER. + CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. + INTEGER(I1P), INTENT(IN) :: X(1:,1:,1:,1:) !< DATA VARIABLE. + LOGICAL, INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT. + LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". + INTEGER(I4P) :: ERROR !< ERROR STATUS. + CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. + INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. + CHARACTER(LEN=:), ALLOCATABLE :: CODE !< DATA VARIABLE ENCODED, BINARY OR BASE64 CODEC. + + DATA_TYPE = 'Int8' + N_COMPONENTS = SIZE(X, DIM=1) + IF (PRESENT(ONE_COMPONENT)) THEN + IF (ONE_COMPONENT) N_COMPONENTS = 1 + ENDIF + CODE = ENCODE_BINARY_DATAARRAY(X=X) + CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, & + IS_TUPLES=IS_TUPLES) + ERROR = SELF%ERROR + ENDFUNCTION W_DATA1_RANK4_I1P + + FUNCTION W_DATA3_RANK1_R8P(SELF, DATA_NAME, X, Y, Z, IS_TUPLES) RESULT(ERROR) + !< WRITE `<DATAARRAY... NumberOfComponents="3"...>...</DATAARRAY>` TAG (R8P). + CLASS(XML_WRITER_BINARY_LOCAL), INTENT(INOUT) :: SELF !< WRITER. + CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. + REAL(R8P), INTENT(IN) :: X(1:) !< X COMPONENT OF DATA VARIABLE. + REAL(R8P), INTENT(IN) :: Y(1:) !< Y COMPONENT OF DATA VARIABLE. + REAL(R8P), INTENT(IN) :: Z(1:) !< Z COMPONENT OF DATA VARIABLE. + LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". + INTEGER(I4P) :: ERROR !< ERROR STATUS. + CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. + INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. + CHARACTER(LEN=:), ALLOCATABLE :: CODE !< DATA VARIABLE ENCODED, BINARY OR BASE64 CODEC. + + DATA_TYPE = 'Float64' + N_COMPONENTS = 3 + CODE = ENCODE_BINARY_DATAARRAY(X=X, Y=Y, Z=Z) + CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, & + IS_TUPLES=IS_TUPLES) + ERROR = SELF%ERROR + ENDFUNCTION W_DATA3_RANK1_R8P + + FUNCTION W_DATA3_RANK1_R4P(SELF, DATA_NAME, X, Y, Z, IS_TUPLES) RESULT(ERROR) + !< WRITE `<DATAARRAY... NumberOfComponents="3"...>...</DATAARRAY>` TAG (R4P). + CLASS(XML_WRITER_BINARY_LOCAL), INTENT(INOUT) :: SELF !< WRITER. + CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. + REAL(R4P), INTENT(IN) :: X(1:) !< X COMPONENT OF DATA VARIABLE. + REAL(R4P), INTENT(IN) :: Y(1:) !< Y COMPONENT OF DATA VARIABLE. + REAL(R4P), INTENT(IN) :: Z(1:) !< Z COMPONENT OF DATA VARIABLE. + LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". + INTEGER(I4P) :: ERROR !< ERROR STATUS. + CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. + INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. + CHARACTER(LEN=:), ALLOCATABLE :: CODE !< DATA VARIABLE ENCODED, BINARY OR BASE64 CODEC. + + DATA_TYPE = 'Float32' + N_COMPONENTS = 3 + CODE = ENCODE_BINARY_DATAARRAY(X=X, Y=Y, Z=Z) + CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, & + IS_TUPLES=IS_TUPLES) + ERROR = SELF%ERROR + ENDFUNCTION W_DATA3_RANK1_R4P + + FUNCTION W_DATA3_RANK1_I8P(SELF, DATA_NAME, X, Y, Z, IS_TUPLES) RESULT(ERROR) + !< WRITE `<DATAARRAY... NumberOfComponents="3"...>...</DATAARRAY>` TAG (I8P). + CLASS(XML_WRITER_BINARY_LOCAL), INTENT(INOUT) :: SELF !< WRITER. + CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. + INTEGER(I8P), INTENT(IN) :: X(1:) !< X COMPONENT OF DATA VARIABLE. + INTEGER(I8P), INTENT(IN) :: Y(1:) !< Y COMPONENT OF DATA VARIABLE. + INTEGER(I8P), INTENT(IN) :: Z(1:) !< Z COMPONENT OF DATA VARIABLE. + LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". + INTEGER(I4P) :: ERROR !< ERROR STATUS. + CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. + INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. + CHARACTER(LEN=:), ALLOCATABLE :: CODE !< DATA VARIABLE ENCODED, BINARY OR BASE64 CODEC. + + DATA_TYPE = 'Int64' + N_COMPONENTS = 3 + CODE = ENCODE_BINARY_DATAARRAY(X=X, Y=Y, Z=Z) + CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, & + IS_TUPLES=IS_TUPLES) + ERROR = SELF%ERROR + ENDFUNCTION W_DATA3_RANK1_I8P + + FUNCTION W_DATA3_RANK1_I4P(SELF, DATA_NAME, X, Y, Z, IS_TUPLES) RESULT(ERROR) + !< WRITE `<DATAARRAY... NumberOfComponents="3"...>...</DATAARRAY>` TAG (I4P). + CLASS(XML_WRITER_BINARY_LOCAL), INTENT(INOUT) :: SELF !< WRITER. + CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. + INTEGER(I4P), INTENT(IN) :: X(1:) !< X COMPONENT OF DATA VARIABLE. + INTEGER(I4P), INTENT(IN) :: Y(1:) !< Y COMPONENT OF DATA VARIABLE. + INTEGER(I4P), INTENT(IN) :: Z(1:) !< Z COMPONENT OF DATA VARIABLE. + LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". + INTEGER(I4P) :: ERROR !< ERROR STATUS. + CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. + INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. + CHARACTER(LEN=:), ALLOCATABLE :: CODE !< DATA VARIABLE ENCODED, BINARY OR BASE64 CODEC. + + DATA_TYPE = 'Int32' + N_COMPONENTS = 3 + CODE = ENCODE_BINARY_DATAARRAY(X=X, Y=Y, Z=Z) + CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, & + IS_TUPLES=IS_TUPLES) + ERROR = SELF%ERROR + ENDFUNCTION W_DATA3_RANK1_I4P + + FUNCTION W_DATA3_RANK1_I2P(SELF, DATA_NAME, X, Y, Z, IS_TUPLES) RESULT(ERROR) + !< WRITE `<DATAARRAY... NumberOfComponents="3"...>...</DATAARRAY>` TAG (I2P). + CLASS(XML_WRITER_BINARY_LOCAL), INTENT(INOUT) :: SELF !< WRITER. + CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. + INTEGER(I2P), INTENT(IN) :: X(1:) !< X COMPONENT OF DATA VARIABLE. + INTEGER(I2P), INTENT(IN) :: Y(1:) !< Y COMPONENT OF DATA VARIABLE. + INTEGER(I2P), INTENT(IN) :: Z(1:) !< Z COMPONENT OF DATA VARIABLE. + LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". + INTEGER(I4P) :: ERROR !< ERROR STATUS. + CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. + INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. + CHARACTER(LEN=:), ALLOCATABLE :: CODE !< DATA VARIABLE ENCODED, BINARY OR BASE64 CODEC. + + DATA_TYPE = 'Int16' + N_COMPONENTS = 3 + CODE = ENCODE_BINARY_DATAARRAY(X=X, Y=Y, Z=Z) + CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, & + IS_TUPLES=IS_TUPLES) + ERROR = SELF%ERROR + ENDFUNCTION W_DATA3_RANK1_I2P + + FUNCTION W_DATA3_RANK1_I1P(SELF, DATA_NAME, X, Y, Z, IS_TUPLES) RESULT(ERROR) + !< WRITE `<DATAARRAY... NumberOfComponents="3"...>...</DATAARRAY>` TAG (I1P). + CLASS(XML_WRITER_BINARY_LOCAL), INTENT(INOUT) :: SELF !< WRITER. + CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. + INTEGER(I1P), INTENT(IN) :: X(1:) !< X COMPONENT OF DATA VARIABLE. + INTEGER(I1P), INTENT(IN) :: Y(1:) !< Y COMPONENT OF DATA VARIABLE. + INTEGER(I1P), INTENT(IN) :: Z(1:) !< Z COMPONENT OF DATA VARIABLE. + LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". + INTEGER(I4P) :: ERROR !< ERROR STATUS. + CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. + INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. + CHARACTER(LEN=:), ALLOCATABLE :: CODE !< DATA VARIABLE ENCODED, BINARY OR BASE64 CODEC. + + DATA_TYPE = 'Int8' + N_COMPONENTS = 3 + CODE = ENCODE_BINARY_DATAARRAY(X=X, Y=Y, Z=Z) + CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, & + IS_TUPLES=IS_TUPLES) + ERROR = SELF%ERROR + ENDFUNCTION W_DATA3_RANK1_I1P + + FUNCTION W_DATA3_RANK3_R8P(SELF, DATA_NAME, X, Y, Z, IS_TUPLES) RESULT(ERROR) + !< WRITE `<DATAARRAY... NumberOfComponents="3"...>...</DATAARRAY>` TAG (R8P). + CLASS(XML_WRITER_BINARY_LOCAL), INTENT(INOUT) :: SELF !< WRITER. + CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. + REAL(R8P), INTENT(IN) :: X(1:,1:,1:) !< X COMPONENT OF DATA VARIABLE. + REAL(R8P), INTENT(IN) :: Y(1:,1:,1:) !< Y COMPONENT OF DATA VARIABLE. + REAL(R8P), INTENT(IN) :: Z(1:,1:,1:) !< Z COMPONENT OF DATA VARIABLE. + LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". + INTEGER(I4P) :: ERROR !< ERROR STATUS. + CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. + INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. + CHARACTER(LEN=:), ALLOCATABLE :: CODE !< DATA VARIABLE ENCODED, BINARY OR BASE64 CODEC. + + DATA_TYPE = 'Float64' + N_COMPONENTS = 3 + CODE = ENCODE_BINARY_DATAARRAY(X=X, Y=Y, Z=Z) + CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, & + IS_TUPLES=IS_TUPLES) + ERROR = SELF%ERROR + ENDFUNCTION W_DATA3_RANK3_R8P + + FUNCTION W_DATA3_RANK3_R4P(SELF, DATA_NAME, X, Y, Z, IS_TUPLES) RESULT(ERROR) + !< WRITE `<DATAARRAY... NumberOfComponents="3"...>...</DATAARRAY>` TAG (R4P). + CLASS(XML_WRITER_BINARY_LOCAL), INTENT(INOUT) :: SELF !< WRITER. + CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. + REAL(R4P), INTENT(IN) :: X(1:,1:,1:) !< X COMPONENT OF DATA VARIABLE. + REAL(R4P), INTENT(IN) :: Y(1:,1:,1:) !< Y COMPONENT OF DATA VARIABLE. + REAL(R4P), INTENT(IN) :: Z(1:,1:,1:) !< Z COMPONENT OF DATA VARIABLE. + LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". + INTEGER(I4P) :: ERROR !< ERROR STATUS. + CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. + INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. + CHARACTER(LEN=:), ALLOCATABLE :: CODE !< DATA VARIABLE ENCODED, BINARY OR BASE64 CODEC. + + DATA_TYPE = 'Float32' + N_COMPONENTS = 3 + CODE = ENCODE_BINARY_DATAARRAY(X=X, Y=Y, Z=Z) + CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, & + IS_TUPLES=IS_TUPLES) + ERROR = SELF%ERROR + ENDFUNCTION W_DATA3_RANK3_R4P + + FUNCTION W_DATA3_RANK3_I8P(SELF, DATA_NAME, X, Y, Z, IS_TUPLES) RESULT(ERROR) + !< WRITE `<DATAARRAY... NumberOfComponents="3"...>...</DATAARRAY>` TAG (I8P). + CLASS(XML_WRITER_BINARY_LOCAL), INTENT(INOUT) :: SELF !< WRITER. + CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. + INTEGER(I8P), INTENT(IN) :: X(1:,1:,1:) !< X COMPONENT OF DATA VARIABLE. + INTEGER(I8P), INTENT(IN) :: Y(1:,1:,1:) !< Y COMPONENT OF DATA VARIABLE. + INTEGER(I8P), INTENT(IN) :: Z(1:,1:,1:) !< Z COMPONENT OF DATA VARIABLE. + LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". + INTEGER(I4P) :: ERROR !< ERROR STATUS. + CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. + INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. + CHARACTER(LEN=:), ALLOCATABLE :: CODE !< DATA VARIABLE ENCODED, BINARY OR BASE64 CODEC. + + DATA_TYPE = 'Int64' + N_COMPONENTS = 3 + CODE = ENCODE_BINARY_DATAARRAY(X=X, Y=Y, Z=Z) + CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, & + IS_TUPLES=IS_TUPLES) + ERROR = SELF%ERROR + ENDFUNCTION W_DATA3_RANK3_I8P + + FUNCTION W_DATA3_RANK3_I4P(SELF, DATA_NAME, X, Y, Z, IS_TUPLES) RESULT(ERROR) + !< WRITE `<DATAARRAY... NumberOfComponents="3"...>...</DATAARRAY>` TAG (I4P). + CLASS(XML_WRITER_BINARY_LOCAL), INTENT(INOUT) :: SELF !< WRITER. + CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. + INTEGER(I4P), INTENT(IN) :: X(1:,1:,1:) !< X COMPONENT OF DATA VARIABLE. + INTEGER(I4P), INTENT(IN) :: Y(1:,1:,1:) !< Y COMPONENT OF DATA VARIABLE. + INTEGER(I4P), INTENT(IN) :: Z(1:,1:,1:) !< Z COMPONENT OF DATA VARIABLE. + LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". + INTEGER(I4P) :: ERROR !< ERROR STATUS. + CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. + INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. + CHARACTER(LEN=:), ALLOCATABLE :: CODE !< DATA VARIABLE ENCODED, BINARY OR BASE64 CODEC. + + DATA_TYPE = 'Int32' + N_COMPONENTS = 3 + CODE = ENCODE_BINARY_DATAARRAY(X=X, Y=Y, Z=Z) + CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, & + IS_TUPLES=IS_TUPLES) + ERROR = SELF%ERROR + ENDFUNCTION W_DATA3_RANK3_I4P + + FUNCTION W_DATA3_RANK3_I2P(SELF, DATA_NAME, X, Y, Z, IS_TUPLES) RESULT(ERROR) + !< WRITE `<DATAARRAY... NumberOfComponents="3"...>...</DATAARRAY>` TAG (I2P). + CLASS(XML_WRITER_BINARY_LOCAL), INTENT(INOUT) :: SELF !< WRITER. + CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. + INTEGER(I2P), INTENT(IN) :: X(1:,1:,1:) !< X COMPONENT OF DATA VARIABLE. + INTEGER(I2P), INTENT(IN) :: Y(1:,1:,1:) !< Y COMPONENT OF DATA VARIABLE. + INTEGER(I2P), INTENT(IN) :: Z(1:,1:,1:) !< Z COMPONENT OF DATA VARIABLE. + LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". + INTEGER(I4P) :: ERROR !< ERROR STATUS. + CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. + INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. + CHARACTER(LEN=:), ALLOCATABLE :: CODE !< DATA VARIABLE ENCODED, BINARY OR BASE64 CODEC. + + DATA_TYPE = 'Int16' + N_COMPONENTS = 3 + CODE = ENCODE_BINARY_DATAARRAY(X=X, Y=Y, Z=Z) + CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, & + IS_TUPLES=IS_TUPLES) + ERROR = SELF%ERROR + ENDFUNCTION W_DATA3_RANK3_I2P + + FUNCTION W_DATA3_RANK3_I1P(SELF, DATA_NAME, X, Y, Z, IS_TUPLES) RESULT(ERROR) + !< WRITE `<DATAARRAY... NumberOfComponents="3"...>...</DATAARRAY>` TAG (I1P). + CLASS(XML_WRITER_BINARY_LOCAL), INTENT(INOUT) :: SELF !< WRITER. + CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. + INTEGER(I1P), INTENT(IN) :: X(1:,1:,1:) !< X COMPONENT OF DATA VARIABLE. + INTEGER(I1P), INTENT(IN) :: Y(1:,1:,1:) !< Y COMPONENT OF DATA VARIABLE. + INTEGER(I1P), INTENT(IN) :: Z(1:,1:,1:) !< Z COMPONENT OF DATA VARIABLE. + LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". + INTEGER(I4P) :: ERROR !< ERROR STATUS. + CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. + INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. + CHARACTER(LEN=:), ALLOCATABLE :: CODE !< DATA VARIABLE ENCODED, BINARY OR BASE64 CODEC. + + DATA_TYPE = 'Int8' + N_COMPONENTS = 3 + CODE = ENCODE_BINARY_DATAARRAY(X=X, Y=Y, Z=Z) + CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, & + IS_TUPLES=IS_TUPLES) + ERROR = SELF%ERROR + ENDFUNCTION W_DATA3_RANK3_I1P + + FUNCTION W_DATA6_RANK1_R8P(SELF, DATA_NAME, U, V, W, X, Y, Z, IS_TUPLES) RESULT(ERROR) + !< WRITE `<DATAARRAY... NumberOfComponents="6"...>...</DATAARRAY>` TAG (R8P). + CLASS(XML_WRITER_BINARY_LOCAL), INTENT(INOUT) :: SELF !< WRITER. + CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. + REAL(R8P), INTENT(IN) :: U(1:) !< U COMPONENT OF DATA VARIABLE. + REAL(R8P), INTENT(IN) :: V(1:) !< V COMPONENT OF DATA VARIABLE. + REAL(R8P), INTENT(IN) :: W(1:) !< W COMPONENT OF DATA VARIABLE. + REAL(R8P), INTENT(IN) :: X(1:) !< X COMPONENT OF DATA VARIABLE. + REAL(R8P), INTENT(IN) :: Y(1:) !< Y COMPONENT OF DATA VARIABLE. + REAL(R8P), INTENT(IN) :: Z(1:) !< Z COMPONENT OF DATA VARIABLE. + LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". + INTEGER(I4P) :: ERROR !< ERROR STATUS. + CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. + INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. + CHARACTER(LEN=:), ALLOCATABLE :: CODE !< DATA VARIABLE ENCODED, BINARY OR BASE64 CODEC. + + DATA_TYPE = 'Float64' + N_COMPONENTS = 6 + CODE = ENCODE_BINARY_DATAARRAY(U=U, V=V, W=W, X=X, Y=Y, Z=Z) + CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, & + IS_TUPLES=IS_TUPLES) + ERROR = SELF%ERROR + ENDFUNCTION W_DATA6_RANK1_R8P + + FUNCTION W_DATA6_RANK1_R4P(SELF, DATA_NAME, U, V, W, X, Y, Z, IS_TUPLES) RESULT(ERROR) + !< WRITE `<DATAARRAY... NumberOfComponents="3"...>...</DATAARRAY>` TAG (R4P). + CLASS(XML_WRITER_BINARY_LOCAL), INTENT(INOUT) :: SELF !< WRITER. + CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. + REAL(R4P), INTENT(IN) :: U(1:) !< U COMPONENT OF DATA VARIABLE. + REAL(R4P), INTENT(IN) :: V(1:) !< V COMPONENT OF DATA VARIABLE. + REAL(R4P), INTENT(IN) :: W(1:) !< W COMPONENT OF DATA VARIABLE. + REAL(R4P), INTENT(IN) :: X(1:) !< X COMPONENT OF DATA VARIABLE. + REAL(R4P), INTENT(IN) :: Y(1:) !< Y COMPONENT OF DATA VARIABLE. + REAL(R4P), INTENT(IN) :: Z(1:) !< Z COMPONENT OF DATA VARIABLE. + LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". + INTEGER(I4P) :: ERROR !< ERROR STATUS. + CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. + INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. + CHARACTER(LEN=:), ALLOCATABLE :: CODE !< DATA VARIABLE ENCODED, BINARY OR BASE64 CODEC. + + DATA_TYPE = 'Float32' + N_COMPONENTS = 6 + CODE = ENCODE_BINARY_DATAARRAY(U=U, V=V, W=W, X=X, Y=Y, Z=Z) + CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, & + IS_TUPLES=IS_TUPLES) + ERROR = SELF%ERROR + ENDFUNCTION W_DATA6_RANK1_R4P + + FUNCTION W_DATA6_RANK1_I8P(SELF, DATA_NAME, U, V, W, X, Y, Z, IS_TUPLES) RESULT(ERROR) + !< WRITE `<DATAARRAY... NumberOfComponents="3"...>...</DATAARRAY>` TAG (I8P). + CLASS(XML_WRITER_BINARY_LOCAL), INTENT(INOUT) :: SELF !< WRITER. + CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. + INTEGER(I8P), INTENT(IN) :: U(1:) !< U COMPONENT OF DATA VARIABLE. + INTEGER(I8P), INTENT(IN) :: V(1:) !< V COMPONENT OF DATA VARIABLE. + INTEGER(I8P), INTENT(IN) :: W(1:) !< W COMPONENT OF DATA VARIABLE. + INTEGER(I8P), INTENT(IN) :: X(1:) !< X COMPONENT OF DATA VARIABLE. + INTEGER(I8P), INTENT(IN) :: Y(1:) !< Y COMPONENT OF DATA VARIABLE. + INTEGER(I8P), INTENT(IN) :: Z(1:) !< Z COMPONENT OF DATA VARIABLE. + LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". + INTEGER(I4P) :: ERROR !< ERROR STATUS. + CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. + INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. + CHARACTER(LEN=:), ALLOCATABLE :: CODE !< DATA VARIABLE ENCODED, BINARY OR BASE64 CODEC. + + DATA_TYPE = 'Int64' + N_COMPONENTS = 6 + CODE = ENCODE_BINARY_DATAARRAY(U=U, V=V, W=W, X=X, Y=Y, Z=Z) + CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, & + IS_TUPLES=IS_TUPLES) + ERROR = SELF%ERROR + ENDFUNCTION W_DATA6_RANK1_I8P + + FUNCTION W_DATA6_RANK1_I4P(SELF, DATA_NAME, U, V, W, X, Y, Z, IS_TUPLES) RESULT(ERROR) + !< WRITE `<DATAARRAY... NumberOfComponents="3"...>...</DATAARRAY>` TAG (I4P). + CLASS(XML_WRITER_BINARY_LOCAL), INTENT(INOUT) :: SELF !< WRITER. + CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. + INTEGER(I4P), INTENT(IN) :: U(1:) !< U COMPONENT OF DATA VARIABLE. + INTEGER(I4P), INTENT(IN) :: V(1:) !< V COMPONENT OF DATA VARIABLE. + INTEGER(I4P), INTENT(IN) :: W(1:) !< W COMPONENT OF DATA VARIABLE. + INTEGER(I4P), INTENT(IN) :: X(1:) !< X COMPONENT OF DATA VARIABLE. + INTEGER(I4P), INTENT(IN) :: Y(1:) !< Y COMPONENT OF DATA VARIABLE. + INTEGER(I4P), INTENT(IN) :: Z(1:) !< Z COMPONENT OF DATA VARIABLE. + LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". + INTEGER(I4P) :: ERROR !< ERROR STATUS. + CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. + INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. + CHARACTER(LEN=:), ALLOCATABLE :: CODE !< DATA VARIABLE ENCODED, BINARY OR BASE64 CODEC. + + DATA_TYPE = 'Int32' + N_COMPONENTS = 6 + CODE = ENCODE_BINARY_DATAARRAY(U=U, V=V, W=W, X=X, Y=Y, Z=Z) + CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, & + IS_TUPLES=IS_TUPLES) + ERROR = SELF%ERROR + ENDFUNCTION W_DATA6_RANK1_I4P + + FUNCTION W_DATA6_RANK1_I2P(SELF, DATA_NAME, U, V, W, X, Y, Z, IS_TUPLES) RESULT(ERROR) + !< WRITE `<DATAARRAY... NumberOfComponents="3"...>...</DATAARRAY>` TAG (I2P). + CLASS(XML_WRITER_BINARY_LOCAL), INTENT(INOUT) :: SELF !< WRITER. + CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. + INTEGER(I2P), INTENT(IN) :: U(1:) !< U COMPONENT OF DATA VARIABLE. + INTEGER(I2P), INTENT(IN) :: V(1:) !< V COMPONENT OF DATA VARIABLE. + INTEGER(I2P), INTENT(IN) :: W(1:) !< W COMPONENT OF DATA VARIABLE. + INTEGER(I2P), INTENT(IN) :: X(1:) !< X COMPONENT OF DATA VARIABLE. + INTEGER(I2P), INTENT(IN) :: Y(1:) !< Y COMPONENT OF DATA VARIABLE. + INTEGER(I2P), INTENT(IN) :: Z(1:) !< Z COMPONENT OF DATA VARIABLE. + LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". + INTEGER(I4P) :: ERROR !< ERROR STATUS. + CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. + INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. + CHARACTER(LEN=:), ALLOCATABLE :: CODE !< DATA VARIABLE ENCODED, BINARY OR BASE64 CODEC. + + DATA_TYPE = 'Int16' + N_COMPONENTS = 6 + CODE = ENCODE_BINARY_DATAARRAY(U=U, V=V, W=W, X=X, Y=Y, Z=Z) + CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, & + IS_TUPLES=IS_TUPLES) + ERROR = SELF%ERROR + ENDFUNCTION W_DATA6_RANK1_I2P + + FUNCTION W_DATA6_RANK1_I1P(SELF, DATA_NAME, U, V, W, X, Y, Z, IS_TUPLES) RESULT(ERROR) + !< WRITE `<DATAARRAY... NumberOfComponents="3"...>...</DATAARRAY>` TAG (I1P). + CLASS(XML_WRITER_BINARY_LOCAL), INTENT(INOUT) :: SELF !< WRITER. + CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. + INTEGER(I1P), INTENT(IN) :: U(1:) !< U COMPONENT OF DATA VARIABLE. + INTEGER(I1P), INTENT(IN) :: V(1:) !< V COMPONENT OF DATA VARIABLE. + INTEGER(I1P), INTENT(IN) :: W(1:) !< W COMPONENT OF DATA VARIABLE. + INTEGER(I1P), INTENT(IN) :: X(1:) !< X COMPONENT OF DATA VARIABLE. + INTEGER(I1P), INTENT(IN) :: Y(1:) !< Y COMPONENT OF DATA VARIABLE. + INTEGER(I1P), INTENT(IN) :: Z(1:) !< Z COMPONENT OF DATA VARIABLE. + LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". + INTEGER(I4P) :: ERROR !< ERROR STATUS. + CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. + INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. + CHARACTER(LEN=:), ALLOCATABLE :: CODE !< DATA VARIABLE ENCODED, BINARY OR BASE64 CODEC. + + DATA_TYPE = 'Int8' + N_COMPONENTS = 6 + CODE = ENCODE_BINARY_DATAARRAY(U=U, V=V, W=W, X=X, Y=Y, Z=Z) + CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, & + IS_TUPLES=IS_TUPLES) + ERROR = SELF%ERROR + ENDFUNCTION W_DATA6_RANK1_I1P + + FUNCTION W_DATA6_RANK3_R8P(SELF, DATA_NAME, U, V, W, X, Y, Z, IS_TUPLES) RESULT(ERROR) + !< WRITE `<DATAARRAY... NumberOfComponents="3"...>...</DATAARRAY>` TAG (R8P). + CLASS(XML_WRITER_BINARY_LOCAL), INTENT(INOUT) :: SELF !< WRITER. + CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. + REAL(R8P), INTENT(IN) :: U(1:,1:,1:) !< U COMPONENT OF DATA VARIABLE. + REAL(R8P), INTENT(IN) :: V(1:,1:,1:) !< V COMPONENT OF DATA VARIABLE. + REAL(R8P), INTENT(IN) :: W(1:,1:,1:) !< W COMPONENT OF DATA VARIABLE. + REAL(R8P), INTENT(IN) :: X(1:,1:,1:) !< X COMPONENT OF DATA VARIABLE. + REAL(R8P), INTENT(IN) :: Y(1:,1:,1:) !< Y COMPONENT OF DATA VARIABLE. + REAL(R8P), INTENT(IN) :: Z(1:,1:,1:) !< Z COMPONENT OF DATA VARIABLE. + LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". + INTEGER(I4P) :: ERROR !< ERROR STATUS. + CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. + INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. + CHARACTER(LEN=:), ALLOCATABLE :: CODE !< DATA VARIABLE ENCODED, BINARY OR BASE64 CODEC. + + DATA_TYPE = 'Float64' + N_COMPONENTS = 6 + CODE = ENCODE_BINARY_DATAARRAY(U=U, V=V, W=W, X=X, Y=Y, Z=Z) + CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, & + IS_TUPLES=IS_TUPLES) + ERROR = SELF%ERROR + ENDFUNCTION W_DATA6_RANK3_R8P + + FUNCTION W_DATA6_RANK3_R4P(SELF, DATA_NAME, U, V, W, X, Y, Z, IS_TUPLES) RESULT(ERROR) + !< WRITE `<DATAARRAY... NumberOfComponents="3"...>...</DATAARRAY>` TAG (R4P). + CLASS(XML_WRITER_BINARY_LOCAL), INTENT(INOUT) :: SELF !< WRITER. + CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. + REAL(R4P), INTENT(IN) :: U(1:,1:,1:) !< U COMPONENT OF DATA VARIABLE. + REAL(R4P), INTENT(IN) :: V(1:,1:,1:) !< V COMPONENT OF DATA VARIABLE. + REAL(R4P), INTENT(IN) :: W(1:,1:,1:) !< W COMPONENT OF DATA VARIABLE. + REAL(R4P), INTENT(IN) :: X(1:,1:,1:) !< X COMPONENT OF DATA VARIABLE. + REAL(R4P), INTENT(IN) :: Y(1:,1:,1:) !< Y COMPONENT OF DATA VARIABLE. + REAL(R4P), INTENT(IN) :: Z(1:,1:,1:) !< Z COMPONENT OF DATA VARIABLE. + LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". + INTEGER(I4P) :: ERROR !< ERROR STATUS. + CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. + INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. + CHARACTER(LEN=:), ALLOCATABLE :: CODE !< DATA VARIABLE ENCODED, BINARY OR BASE64 CODEC. + + DATA_TYPE = 'Float32' + N_COMPONENTS = 6 + CODE = ENCODE_BINARY_DATAARRAY(U=U, V=V, W=W, X=X, Y=Y, Z=Z) + CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, & + IS_TUPLES=IS_TUPLES) + ERROR = SELF%ERROR + ENDFUNCTION W_DATA6_RANK3_R4P + + FUNCTION W_DATA6_RANK3_I8P(SELF, DATA_NAME, U, V, W, X, Y, Z, IS_TUPLES) RESULT(ERROR) + !< WRITE `<DATAARRAY... NumberOfComponents="3"...>...</DATAARRAY>` TAG (I8P). + CLASS(XML_WRITER_BINARY_LOCAL), INTENT(INOUT) :: SELF !< WRITER. + CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. + INTEGER(I8P), INTENT(IN) :: U(1:,1:,1:) !< U COMPONENT OF DATA VARIABLE. + INTEGER(I8P), INTENT(IN) :: V(1:,1:,1:) !< V COMPONENT OF DATA VARIABLE. + INTEGER(I8P), INTENT(IN) :: W(1:,1:,1:) !< W COMPONENT OF DATA VARIABLE. + INTEGER(I8P), INTENT(IN) :: X(1:,1:,1:) !< X COMPONENT OF DATA VARIABLE. + INTEGER(I8P), INTENT(IN) :: Y(1:,1:,1:) !< Y COMPONENT OF DATA VARIABLE. + INTEGER(I8P), INTENT(IN) :: Z(1:,1:,1:) !< Z COMPONENT OF DATA VARIABLE. + LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". + INTEGER(I4P) :: ERROR !< ERROR STATUS. + CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. + INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. + CHARACTER(LEN=:), ALLOCATABLE :: CODE !< DATA VARIABLE ENCODED, BINARY OR BASE64 CODEC. + + DATA_TYPE = 'Int64' + N_COMPONENTS = 6 + CODE = ENCODE_BINARY_DATAARRAY(U=U, V=V, W=W, X=X, Y=Y, Z=Z) + CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, & + IS_TUPLES=IS_TUPLES) + ERROR = SELF%ERROR + ENDFUNCTION W_DATA6_RANK3_I8P + + FUNCTION W_DATA6_RANK3_I4P(SELF, DATA_NAME, U, V, W, X, Y, Z, IS_TUPLES) RESULT(ERROR) + !< WRITE `<DATAARRAY... NumberOfComponents="3"...>...</DATAARRAY>` TAG (I4P). + CLASS(XML_WRITER_BINARY_LOCAL), INTENT(INOUT) :: SELF !< WRITER. + CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. + INTEGER(I4P), INTENT(IN) :: U(1:,1:,1:) !< U COMPONENT OF DATA VARIABLE. + INTEGER(I4P), INTENT(IN) :: V(1:,1:,1:) !< V COMPONENT OF DATA VARIABLE. + INTEGER(I4P), INTENT(IN) :: W(1:,1:,1:) !< W COMPONENT OF DATA VARIABLE. + INTEGER(I4P), INTENT(IN) :: X(1:,1:,1:) !< X COMPONENT OF DATA VARIABLE. + INTEGER(I4P), INTENT(IN) :: Y(1:,1:,1:) !< Y COMPONENT OF DATA VARIABLE. + INTEGER(I4P), INTENT(IN) :: Z(1:,1:,1:) !< Z COMPONENT OF DATA VARIABLE. + LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". + INTEGER(I4P) :: ERROR !< ERROR STATUS. + CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. + INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. + CHARACTER(LEN=:), ALLOCATABLE :: CODE !< DATA VARIABLE ENCODED, BINARY OR BASE64 CODEC. + + DATA_TYPE = 'Int32' + N_COMPONENTS = 6 + CODE = ENCODE_BINARY_DATAARRAY(U=U, V=V, W=W, X=X, Y=Y, Z=Z) + CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, & + IS_TUPLES=IS_TUPLES) + ERROR = SELF%ERROR + ENDFUNCTION W_DATA6_RANK3_I4P + + FUNCTION W_DATA6_RANK3_I2P(SELF, DATA_NAME, U, V, W, X, Y, Z, IS_TUPLES) RESULT(ERROR) + !< WRITE `<DATAARRAY... NumberOfComponents="3"...>...</DATAARRAY>` TAG (I2P). + CLASS(XML_WRITER_BINARY_LOCAL), INTENT(INOUT) :: SELF !< WRITER. + CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. + INTEGER(I2P), INTENT(IN) :: U(1:,1:,1:) !< U COMPONENT OF DATA VARIABLE. + INTEGER(I2P), INTENT(IN) :: V(1:,1:,1:) !< V COMPONENT OF DATA VARIABLE. + INTEGER(I2P), INTENT(IN) :: W(1:,1:,1:) !< W COMPONENT OF DATA VARIABLE. + INTEGER(I2P), INTENT(IN) :: X(1:,1:,1:) !< X COMPONENT OF DATA VARIABLE. + INTEGER(I2P), INTENT(IN) :: Y(1:,1:,1:) !< Y COMPONENT OF DATA VARIABLE. + INTEGER(I2P), INTENT(IN) :: Z(1:,1:,1:) !< Z COMPONENT OF DATA VARIABLE. + LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". + INTEGER(I4P) :: ERROR !< ERROR STATUS. + CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. + INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. + CHARACTER(LEN=:), ALLOCATABLE :: CODE !< DATA VARIABLE ENCODED, BINARY OR BASE64 CODEC. + + DATA_TYPE = 'Int16' + N_COMPONENTS = 6 + CODE = ENCODE_BINARY_DATAARRAY(U=U, V=V, W=W, X=X, Y=Y, Z=Z) + CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, & + IS_TUPLES=IS_TUPLES) + ERROR = SELF%ERROR + ENDFUNCTION W_DATA6_RANK3_I2P + + FUNCTION W_DATA6_RANK3_I1P(SELF, DATA_NAME, U, V, W, X, Y, Z, IS_TUPLES) RESULT(ERROR) + !< WRITE `<DATAARRAY... NumberOfComponents="3"...>...</DATAARRAY>` TAG (I1P). + CLASS(XML_WRITER_BINARY_LOCAL), INTENT(INOUT) :: SELF !< WRITER. + CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. + INTEGER(I1P), INTENT(IN) :: U(1:,1:,1:) !< U COMPONENT OF DATA VARIABLE. + INTEGER(I1P), INTENT(IN) :: V(1:,1:,1:) !< V COMPONENT OF DATA VARIABLE. + INTEGER(I1P), INTENT(IN) :: W(1:,1:,1:) !< W COMPONENT OF DATA VARIABLE. + INTEGER(I1P), INTENT(IN) :: X(1:,1:,1:) !< X COMPONENT OF DATA VARIABLE. + INTEGER(I1P), INTENT(IN) :: Y(1:,1:,1:) !< Y COMPONENT OF DATA VARIABLE. + INTEGER(I1P), INTENT(IN) :: Z(1:,1:,1:) !< Z COMPONENT OF DATA VARIABLE. + LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". + INTEGER(I4P) :: ERROR !< ERROR STATUS. + CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. + INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. + CHARACTER(LEN=:), ALLOCATABLE :: CODE !< DATA VARIABLE ENCODED, BINARY OR BASE64 CODEC. + + DATA_TYPE = 'Int8' + N_COMPONENTS = 6 + CODE = ENCODE_BINARY_DATAARRAY(U=U, V=V, W=W, X=X, Y=Y, Z=Z) + CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, & + IS_TUPLES=IS_TUPLES) + ERROR = SELF%ERROR + ENDFUNCTION W_DATA6_RANK3_I1P + + SUBROUTINE W_DATA_APPENDED(SELF) + !< DO NOTHING, BINARY LOCAL IS NOT APPENDED. + CLASS(XML_WRITER_BINARY_LOCAL), INTENT(INOUT) :: SELF !< WRITER. + ENDSUBROUTINE W_DATA_APPENDED +ENDMODULE VTKF_FILE_XML_WRITER_BINARY_LOCAL + + + + + +!< VTM FILE CLASS. +MODULE VTK_FORTRAN_VTM_FILE +!< VTM FILE CLASS. +USE BEFOR64 +USE PENF +USE STRINGIFOR +USE VTKF_FILE_XML_WRITER_ABSTRACT +USE VTKF_FILE_XML_WRITER_ASCII_LOCAL + +IMPLICIT NONE +PRIVATE +PUBLIC :: VTM_FILE + +TYPE :: VTM_FILE + !< VTM FILE CLASS. + CLASS(XML_WRITER_ABSTRACT), ALLOCATABLE, PUBLIC :: XML_WRITER !< XML WRITER. + INTEGER(I4P), ALLOCATABLE :: SCRATCH_UNIT(:) !< SCRATCH UNITS FOR VERY LARGE LIST OF NAMED BLOCKS. + CONTAINS + ! PUBLIC METHODS + PROCEDURE, PASS(SELF) :: INITIALIZE !< INITIALIZE FILE. + PROCEDURE, PASS(SELF) :: FINALIZE !< FINALIZE FILE. + GENERIC :: WRITE_BLOCK => & + WRITE_BLOCK_ARRAY, & + WRITE_BLOCK_STRING, & + WRITE_BLOCK_SCRATCH !< WRITE ONE BLOCK DATASET. + ! PRIVATE METHODS + PROCEDURE, PASS(SELF), PRIVATE :: WRITE_BLOCK_ARRAY !< WRITE ONE BLOCK DATASET (ARRAY INPUT). + PROCEDURE, PASS(SELF), PRIVATE :: WRITE_BLOCK_STRING !< WRITE ONE BLOCK DATASET (STRING INPUT). + ! SCRATCH FILES METHODS`` + PROCEDURE, PASS(SELF), PRIVATE :: PARSE_SCRATCH_FILES !< PARSE SCRATCH FILES. + PROCEDURE, PASS(SELF), PRIVATE :: WRITE_BLOCK_SCRATCH !< WRITE ONE BLOCK DATASET ON SCRATCH FILES. +ENDTYPE VTM_FILE +CONTAINS + ! PUBLIC METHODS + FUNCTION INITIALIZE(SELF, FILENAME, SCRATCH_UNITS_NUMBER) RESULT(ERROR) + !< INITIALIZE FILE (WRITER). + CLASS(VTM_FILE), INTENT(INOUT) :: SELF !< VTM FILE. + CHARACTER(*), INTENT(IN) :: FILENAME !< FILE NAME OF OUTPUT VTM FILE. + INTEGER(I4P), INTENT(IN), OPTIONAL :: SCRATCH_UNITS_NUMBER !< NUMBER OF SCRATCH UNITS FOR VERY LARGE LIST OF NAMED BLOCKS. + INTEGER(I4P) :: SCRATCH_UNITS_NUMBER_ !< NUMBER OF SCRATCH UNITS FOR VERY LARGE LIST OF NAMED BLOCKS. + INTEGER(I4P) :: ERROR !< ERROR STATUS. + + IF (.NOT.IS_INITIALIZED) CALL PENF_INIT + IF (.NOT.IS_B64_INITIALIZED) CALL B64_INIT + SCRATCH_UNITS_NUMBER_ = 0_I4P ; IF (PRESENT(SCRATCH_UNITS_NUMBER)) SCRATCH_UNITS_NUMBER_ = SCRATCH_UNITS_NUMBER + ERROR = SELF%FINALIZE() + IF (ALLOCATED(SELF%XML_WRITER)) DEALLOCATE(SELF%XML_WRITER) + ALLOCATE(XML_WRITER_ASCII_LOCAL :: SELF%XML_WRITER) + ERROR = SELF%XML_WRITER%INITIALIZE(FORMAT='ascii', FILENAME=FILENAME, MESH_TOPOLOGY='VTKMULTIBLOCKDATASET') + IF (SCRATCH_UNITS_NUMBER_>0_I4P) ALLOCATE(SELF%SCRATCH_UNIT(SCRATCH_UNITS_NUMBER_)) + ENDFUNCTION INITIALIZE + + FUNCTION FINALIZE(SELF) RESULT(ERROR) + !< FINALIZE FILE (WRITER). + CLASS(VTM_FILE), INTENT(INOUT) :: SELF !< VTM FILE. + INTEGER(I4P) :: ERROR !< ERROR STATUS. + + ERROR = 1 + IF (ALLOCATED(SELF%SCRATCH_UNIT)) THEN + ERROR = SELF%PARSE_SCRATCH_FILES() + DEALLOCATE(SELF%SCRATCH_UNIT) + ENDIF + IF (ALLOCATED(SELF%XML_WRITER)) ERROR = SELF%XML_WRITER%FINALIZE() + ENDFUNCTION FINALIZE + + ! PRIVATE METHODS + FUNCTION WRITE_BLOCK_ARRAY(SELF, FILENAMES, NAMES, NAME) RESULT(ERROR) + !< WRITE ONE BLOCK DATASET (ARRAY INPUT). + !< + !<#### EXAMPLE OF USAGE: 3 FILES BLOCKS + !<```FORTRAN + !< ERROR = VTM%WRITE_BLOCK(FILENAMES=['FILE_1.VTS', 'FILE_2.VTS', 'FILE_3.VTU'], NAME='MY_BLOCK') + !<``` + !< + !<#### EXAMPLE OF USAGE: 3 FILES BLOCKS WITH CUSTOM NAME + !<```FORTRAN + !< ERROR = VTM%WRITE_BLOCK(FILENAMES=['FILE_1.VTS', 'FILE_2.VTS', 'FILE_3.VTU'], & + !< NAMES=['BLOCK-BAR', 'BLOCK-FOO', 'BLOCK-BAZ'], NAME='MY_BLOCK') + !<``` + CLASS(VTM_FILE), INTENT(INOUT) :: SELF !< VTM FILE. + CHARACTER(*), INTENT(IN) :: FILENAMES(1:) !< FILE NAMES OF VTK FILES GROUPED INTO CURRENT BLOCK. + CHARACTER(*), INTENT(IN), OPTIONAL :: NAMES(1:) !< AUXILIARY NAMES ATTRIBUTED TO EACH FILES. + CHARACTER(*), INTENT(IN), OPTIONAL :: NAME !< BLOCK NAME + INTEGER(I4P) :: ERROR !< ERROR STATUS. + + ERROR = SELF%XML_WRITER%WRITE_PARALLEL_OPEN_BLOCK(NAME=NAME) + ERROR = SELF%XML_WRITER%WRITE_PARALLEL_BLOCK_FILES(FILENAMES=FILENAMES, NAMES=NAMES) + ERROR = SELF%XML_WRITER%WRITE_PARALLEL_CLOSE_BLOCK() + ENDFUNCTION WRITE_BLOCK_ARRAY + + FUNCTION WRITE_BLOCK_STRING(SELF, ACTION, FILENAMES, NAMES, NAME) RESULT(ERROR) + !< WRITE ONE BLOCK DATASET (STRING INPUT). + !< + !<#### EXAMPLE OF USAGE: 3 FILES BLOCKS + !<```FORTRAN + !< ERROR = VTM%WRITE_BLOCK(FILENAMES='FILE_1.VTS FILE_2.VTS FILE_3.VTU', NAME='MY_BLOCK') + !<``` + !< + !<#### EXAMPLE OF USAGE: 3 FILES BLOCKS WITH CUSTOM NAME + !<```FORTRAN + !< ERROR = VTM%WRITE_BLOCK(FILENAMES='FILE_1.VTS FILE_2.VTS FILE_3.VTU', NAMES='BLOCK-BAR BLOCK-FOO BLOCK-BAZ', NAME='MY_BLOCK') + !<``` + CLASS(VTM_FILE), INTENT(INOUT) :: SELF !< VTM FILE. + CHARACTER(*), INTENT(IN), OPTIONAL :: ACTION !< ACTION: [OPEN, CLOSE, WRITE]. + CHARACTER(*), INTENT(IN), OPTIONAL :: FILENAMES !< FILE NAMES OF VTK FILES GROUPED INTO CURRENT BLOCK. + CHARACTER(*), INTENT(IN), OPTIONAL :: NAMES !< AUXILIARY NAMES ATTRIBUTED TO EACH FILES. + CHARACTER(*), INTENT(IN), OPTIONAL :: NAME !< BLOCK NAME + INTEGER(I4P) :: ERROR !< ERROR STATUS. + TYPE(STRING) :: ACTION_ !< ACTION STRING. + + IF (PRESENT(ACTION)) THEN + ACTION_ = TRIM(ADJUSTL(ACTION)) ; ACTION_ = ACTION_%UPPER() + SELECT CASE(ACTION_%CHARS()) + CASE('OPEN') + ERROR = SELF%XML_WRITER%WRITE_PARALLEL_OPEN_BLOCK(NAME=NAME) + CASE('CLOSE') + ERROR = SELF%XML_WRITER%WRITE_PARALLEL_CLOSE_BLOCK() + CASE('WRITE') + IF (PRESENT(FILENAMES)) ERROR = SELF%XML_WRITER%WRITE_PARALLEL_BLOCK_FILES(FILENAMES=FILENAMES, NAMES=NAMES) + ENDSELECT + ELSE + ERROR = SELF%XML_WRITER%WRITE_PARALLEL_OPEN_BLOCK(NAME=NAME) + ERROR = SELF%XML_WRITER%WRITE_PARALLEL_BLOCK_FILES(FILENAMES=FILENAMES, NAMES=NAMES) + ERROR = SELF%XML_WRITER%WRITE_PARALLEL_CLOSE_BLOCK() + ENDIF + ENDFUNCTION WRITE_BLOCK_STRING + + ! SCRATCH FILES METHODS + FUNCTION PARSE_SCRATCH_FILES(SELF) RESULT(ERROR) + !< PARSE SCRATCH FILES. + CLASS(VTM_FILE), INTENT(INOUT) :: SELF !< VTM FILE. + INTEGER(I4P) :: ERROR !< ERROR STATUS. + CHARACTER(9999) :: FILENAME !< FILE NAME OF VTK FILE GROUPED INTO CURRENT BLOCK. + CHARACTER(9999) :: NAME !< BLOCK NAME + INTEGER(I4P) :: S, F !< COUNTER. + + IF (ALLOCATED(SELF%SCRATCH_UNIT)) THEN + DO S=1, SIZE(SELF%SCRATCH_UNIT, DIM=1) + ! REWIND SCRATCH FILE + REWIND(SELF%SCRATCH_UNIT(S)) + ! WRITE GROUP NAME + F = 0_I4P + READ(SELF%SCRATCH_UNIT(S), IOSTAT=ERROR, FMT=*) NAME + ERROR = SELF%WRITE_BLOCK(ACTION='OPEN', NAME=TRIM(ADJUSTL(NAME))) + ! WRITE GROUP FILENAMES + PARSE_FILE_LOOP : DO + READ(SELF%SCRATCH_UNIT(S), IOSTAT=ERROR, FMT=*) FILENAME + IF (IS_IOSTAT_END(ERROR)) EXIT PARSE_FILE_LOOP + ERROR = SELF%XML_WRITER%WRITE_PARALLEL_BLOCK_FILES(FILE_INDEX=F, & + FILENAME=TRIM(ADJUSTL(FILENAME)), & + NAME=TRIM(ADJUSTL(FILENAME))) + F = F + 1_I4P + ENDDO PARSE_FILE_LOOP + ! CLOSE GROUP + ERROR = SELF%WRITE_BLOCK(ACTION='CLOSE') + ! CLOSE SCRATCH FILE + CLOSE(SELF%SCRATCH_UNIT(S)) + ENDDO + ENDIF + ENDFUNCTION PARSE_SCRATCH_FILES + + FUNCTION WRITE_BLOCK_SCRATCH(SELF, SCRATCH, ACTION, FILENAME, NAME) RESULT(ERROR) + !< WRITE ONE BLOCK DATASET ON SCRATCH FILES. + CLASS(VTM_FILE), INTENT(INOUT) :: SELF !< VTM FILE. + INTEGER(I4P), INTENT(IN) :: SCRATCH !< SCRATCH UNIT. + CHARACTER(*), INTENT(IN) :: ACTION !< ACTION: [OPEN, WRITE]. + CHARACTER(*), INTENT(IN), OPTIONAL :: FILENAME !< FILE NAME OF VTK FILE GROUPED INTO CURRENT BLOCK. + CHARACTER(*), INTENT(IN), OPTIONAL :: NAME !< BLOCK NAME + INTEGER(I4P) :: ERROR !< ERROR STATUS. + TYPE(STRING) :: ACTION_ !< ACTION STRING. + TYPE(STRING) :: NAME_ !< BLOCK NAME, LOCAL VARIABLE + + ACTION_ = TRIM(ADJUSTL(ACTION)) ; ACTION_ = ACTION_%UPPER() + SELECT CASE(ACTION_%CHARS()) + CASE('OPEN') + OPEN(NEWUNIT=SELF%SCRATCH_UNIT(SCRATCH), & + FORM='FORMATTED', & + ACTION='READWRITE', & + STATUS='SCRATCH', & + IOSTAT=ERROR) + NAME_ = '' ; IF (PRESENT(NAME)) NAME_ = TRIM(ADJUSTL(NAME)) + WRITE(SELF%SCRATCH_UNIT(SCRATCH), IOSTAT=ERROR, FMT='(A)') NAME_%CHARS() + CASE('WRITE') + IF (PRESENT(FILENAME)) WRITE(SELF%SCRATCH_UNIT(SCRATCH), IOSTAT=ERROR, FMT='(A)') TRIM(FILENAME) + ENDSELECT + ENDFUNCTION WRITE_BLOCK_SCRATCH +ENDMODULE VTK_FORTRAN_VTM_FILE + + + + +!< VTK FILE CLASS. +MODULE VTK_FORTRAN_VTK_FILE +!< VTK FILE CLASS. +USE BEFOR64 +USE PENF +USE STRINGIFOR +USE VTKF_FILE_XML_WRITER_ABSTRACT +USE VTKF_FILE_XML_WRITER_APPENDED +USE VTKF_FILE_XML_WRITER_ASCII_LOCAL +USE VTKF_FILE_XML_WRITER_BINARY_LOCAL + +IMPLICIT NONE +PRIVATE +PUBLIC :: VTK_FILE + +TYPE :: VTK_FILE + !< VTK FILE CLASS. + PRIVATE + CLASS(XML_WRITER_ABSTRACT), ALLOCATABLE, PUBLIC :: XML_WRITER !< XML WRITER. + CONTAINS + PROCEDURE, PASS(SELF) :: GET_XML_VOLATILE !< RETURN THE EVENTUAL XML VOLATILE STRING FILE. + PROCEDURE, PASS(SELF) :: INITIALIZE !< INITIALIZE FILE. + PROCEDURE, PASS(SELF) :: FINALIZE !< FINALIZE FILE. + PROCEDURE, PASS(SELF) :: FREE !< FREE ALLOCATED MEMORY. +ENDTYPE VTK_FILE +CONTAINS + PURE SUBROUTINE GET_XML_VOLATILE(SELF, XML_VOLATILE, ERROR) + !< RETURN THE EVENTUAL XML VOLATILE STRING FILE. + CLASS(VTK_FILE), INTENT(IN) :: SELF !< VTK FILE. + CHARACTER(LEN=:), INTENT(OUT), ALLOCATABLE :: XML_VOLATILE !< XML VOLATILE FILE. + INTEGER(I4P), INTENT(OUT), OPTIONAL :: ERROR !< ERROR STATUS. + + CALL SELF%XML_WRITER%GET_XML_VOLATILE(XML_VOLATILE=XML_VOLATILE, ERROR=ERROR) + ENDSUBROUTINE GET_XML_VOLATILE + + FUNCTION INITIALIZE(SELF, FORMAT, FILENAME, MESH_TOPOLOGY, IS_VOLATILE, NX1, NX2, NY1, NY2, NZ1, NZ2) RESULT(ERROR) + !< INITIALIZE FILE (WRITER). + !< + !< @NOTE THIS FUNCTION MUST BE THE FIRST TO BE CALLED. + !< + !<### SUPPORTED OUTPUT FORMATS ARE (THE PASSED SPECIFIER VALUE IS CASE INSENSITIVE): + !< + !<- ASCII: DATA ARE SAVED IN ASCII FORMAT; + !<- BINARY: DATA ARE SAVED IN BASE64 ENCODED FORMAT; + !<- RAW: DATA ARE SAVED IN RAW-BINARY FORMAT IN THE APPENDED TAG OF THE XML FILE; + !<- BINARY-APPENDED: DATA ARE SAVED IN BASE64 ENCODED FORMAT IN THE APPENDED TAG OF THE XML FILE. + !< + !<### SUPPORTED TOPOLOGIES ARE: + !< + !<- RECTILINEARGRID; + !<- STRUCTUREDGRID; + !<- UNSTRUCTUREDGRID. + !< + !<### EXAMPLE OF USAGE + !< + !<```FORTRAN + !< TYPE(VTK_FILE) :: VTK + !< INTEGER(I4P) :: NX1, NX2, NY1, NY2, NZ1, NZ2 + !< ... + !< ERROR = VTK%INITIALIZE('binary','XML_RECT_BINARY.VTR','RectilinearGrid',NX1=NX1,NX2=NX2,NY1=NY1,NY2=NY2,NZ1=NZ1,NZ2=NZ2) + !< ... + !<``` + !< @NOTE THE FILE EXTENSION IS NECESSARY IN THE FILE NAME. THE XML STANDARD HAS DIFFERENT EXTENSIONS FOR EACH + !< DIFFERENT TOPOLOGIES (E.G. *VTR* FOR RECTILINEAR TOPOLOGY). SEE THE VTK-STANDARD FILE FOR MORE INFORMATION. + CLASS(VTK_FILE), INTENT(INOUT) :: SELF !< VTK FILE. + CHARACTER(*), INTENT(IN) :: FORMAT !< FILE FORMAT: ASCII, BINARY, RAW OR BINARY-APPENDED. + CHARACTER(*), INTENT(IN) :: FILENAME !< FILE NAME. + CHARACTER(*), INTENT(IN) :: MESH_TOPOLOGY !< MESH TOPOLOGY. + LOGICAL, INTENT(IN), OPTIONAL :: IS_VOLATILE !< FLAG TO CHECK VOLATILE WRITER. + INTEGER(I4P), INTENT(IN), OPTIONAL :: NX1 !< INITIAL NODE OF X AXIS. + INTEGER(I4P), INTENT(IN), OPTIONAL :: NX2 !< FINAL NODE OF X AXIS. + INTEGER(I4P), INTENT(IN), OPTIONAL :: NY1 !< INITIAL NODE OF Y AXIS. + INTEGER(I4P), INTENT(IN), OPTIONAL :: NY2 !< FINAL NODE OF Y AXIS. + INTEGER(I4P), INTENT(IN), OPTIONAL :: NZ1 !< INITIAL NODE OF Z AXIS. + INTEGER(I4P), INTENT(IN), OPTIONAL :: NZ2 !< FINAL NODE OF Z AXIS. + INTEGER(I4P) :: ERROR !< ERROR STATUS. + TYPE(STRING) :: FFORMAT !< FILE FORMAT. + + IF (.NOT.IS_INITIALIZED) CALL PENF_INIT + IF (.NOT.IS_B64_INITIALIZED) CALL B64_INIT + FFORMAT = TRIM(ADJUSTL(FORMAT)) + FFORMAT = FFORMAT%UPPER() + IF (ALLOCATED(SELF%XML_WRITER)) DEALLOCATE(SELF%XML_WRITER) + SELECT CASE(FFORMAT%CHARS()) + CASE('ascii') + ALLOCATE(XML_WRITER_ASCII_LOCAL :: SELF%XML_WRITER) + CASE('binary-appended', 'raw') + ALLOCATE(XML_WRITER_APPENDED :: SELF%XML_WRITER) + CASE('binary') + ALLOCATE(XML_WRITER_BINARY_LOCAL :: SELF%XML_WRITER) + CASE DEFAULT + ERROR = 1 + ENDSELECT + ERROR = SELF%XML_WRITER%INITIALIZE(FORMAT=FORMAT, FILENAME=FILENAME, MESH_TOPOLOGY=MESH_TOPOLOGY, & + IS_VOLATILE=IS_VOLATILE, & + NX1=NX1, NX2=NX2, NY1=NY1, NY2=NY2, NZ1=NZ1, NZ2=NZ2) + ENDFUNCTION INITIALIZE + + FUNCTION FINALIZE(SELF) RESULT(ERROR) + !< FINALIZE FILE (WRITER). + CLASS(VTK_FILE), INTENT(INOUT) :: SELF !< VTK FILE. + INTEGER(I4P) :: ERROR !< ERROR STATUS. + CHARACTER(LEN=:), ALLOCATABLE :: XML_VOLATILE !< XML VOLATILE FILE. + + ERROR = 1 + IF (ALLOCATED(SELF%XML_WRITER)) ERROR = SELF%XML_WRITER%FINALIZE() + ENDFUNCTION FINALIZE + + ELEMENTAL SUBROUTINE FREE(SELF, ERROR) + !< FREE ALLOCATED MEMORY. + CLASS(VTK_FILE), INTENT(INOUT) :: SELF !< VTK FILE. + INTEGER(I4P), INTENT(OUT), OPTIONAL :: ERROR !< ERROR STATUS. + + IF (ALLOCATED(SELF%XML_WRITER)) CALL SELF%XML_WRITER%FREE(ERROR=ERROR) + ENDSUBROUTINE FREE +ENDMODULE VTK_FORTRAN_VTK_FILE + + + +!< PARALLEL (PARTIONED) VTK FILE CLASS. +MODULE VTK_FORTRAN_PVTK_FILE +!< PARALLEL (PARTIONED) VTK FILE CLASS. +USE BEFOR64 +USE PENF +USE VTKF_FILE_XML_WRITER_ABSTRACT +USE VTKF_FILE_XML_WRITER_ASCII_LOCAL + +IMPLICIT NONE +PRIVATE +PUBLIC :: PVTK_FILE + +TYPE :: PVTK_FILE + !< VTK PARALLEL (PARTIONED) FILE CLASS. + PRIVATE + CLASS(XML_WRITER_ABSTRACT), ALLOCATABLE, PUBLIC :: XML_WRITER !< XML WRITER. + CONTAINS + PROCEDURE, PASS(SELF) :: INITIALIZE !< INITIALIZE FILE. + PROCEDURE, PASS(SELF) :: FINALIZE !< FINALIZE FILE. +ENDTYPE PVTK_FILE +CONTAINS + FUNCTION INITIALIZE(SELF, FILENAME, MESH_TOPOLOGY, MESH_KIND, NX1, NX2, NY1, NY2, NZ1, NZ2) RESULT(ERROR) + !< INITIALIZE FILE (WRITER). + !< + !< @NOTE THIS FUNCTION MUST BE THE FIRST TO BE CALLED. + !< + !<### SUPPORTED TOPOLOGIES ARE: + !< + !<- PRECTILINEARGRID; + !<- PSTRUCTUREDGRID; + !<- PUNSTRUCTUREDGRID. + !< + !<### EXAMPLE OF USAGE + !< + !<```FORTRAN + !< TYPE(PVTK_FILE) :: PVTK + !< INTEGER(I4P) :: NX1, NX2, NY1, NY2, NZ1, NZ2 + !< ... + !< ERROR = PVTK%INITIALIZE('XML_RECT_BINARY.PVTR','PRectilinearGrid',NX1=NX1,NX2=NX2,NY1=NY1,NY2=NY2,NZ1=NZ1,NZ2=NZ2) + !< ... + !<``` + !< @NOTE THE FILE EXTENSION IS NECESSARY IN THE FILE NAME. THE XML STANDARD HAS DIFFERENT EXTENSIONS FOR EACH + !< DIFFERENT TOPOLOGIES (E.G. *PVTR* FOR RECTILINEAR TOPOLOGY). SEE THE VTK-STANDARD FILE FOR MORE INFORMATION. + CLASS(PVTK_FILE), INTENT(INOUT) :: SELF !< VTK FILE. + CHARACTER(*), INTENT(IN) :: FILENAME !< FILE NAME. + CHARACTER(*), INTENT(IN) :: MESH_TOPOLOGY !< MESH TOPOLOGY. + CHARACTER(*), INTENT(IN) :: MESH_KIND !< KIND OF MESH DATA: FLOAT64, FLOAT32, ECC. + INTEGER(I4P), INTENT(IN), OPTIONAL :: NX1 !< INITIAL NODE OF X AXIS. + INTEGER(I4P), INTENT(IN), OPTIONAL :: NX2 !< FINAL NODE OF X AXIS. + INTEGER(I4P), INTENT(IN), OPTIONAL :: NY1 !< INITIAL NODE OF Y AXIS. + INTEGER(I4P), INTENT(IN), OPTIONAL :: NY2 !< FINAL NODE OF Y AXIS. + INTEGER(I4P), INTENT(IN), OPTIONAL :: NZ1 !< INITIAL NODE OF Z AXIS. + INTEGER(I4P), INTENT(IN), OPTIONAL :: NZ2 !< FINAL NODE OF Z AXIS. + INTEGER(I4P) :: ERROR !< ERROR STATUS. + + IF (.NOT.IS_INITIALIZED) CALL PENF_INIT + IF (.NOT.IS_B64_INITIALIZED) CALL B64_INIT + IF (ALLOCATED(SELF%XML_WRITER)) DEALLOCATE(SELF%XML_WRITER) + ALLOCATE(XML_WRITER_ASCII_LOCAL :: SELF%XML_WRITER) + ERROR = SELF%XML_WRITER%INITIALIZE(FORMAT='ascii', FILENAME=FILENAME, MESH_TOPOLOGY=MESH_TOPOLOGY, & + NX1=NX1, NX2=NX2, NY1=NY1, NY2=NY2, NZ1=NZ1, NZ2=NZ2, MESH_KIND=MESH_KIND) + ENDFUNCTION INITIALIZE + + FUNCTION FINALIZE(SELF) RESULT(ERROR) + !< FINALIZE FILE (WRITER). + CLASS(PVTK_FILE), INTENT(INOUT) :: SELF !< VTK FILE. + INTEGER(I4P) :: ERROR !< ERROR STATUS. + + ERROR = 1 + IF (ALLOCATED(SELF%XML_WRITER)) ERROR = SELF%XML_WRITER%FINALIZE() + ENDFUNCTION FINALIZE +ENDMODULE VTK_FORTRAN_PVTK_FILE + + + + +!< VTK_FORTRAN, PURE FORTRAN (2003+) LIBRARY TO PARSE AND EMITT VTK FILES. +MODULE VTK_FORTRAN +!< VTK_FORTRAN, PURE FORTRAN (2003+) LIBRARY TO PARSE AND EMITT VTK FILES. +USE PENF +USE VTK_FORTRAN_PVTK_FILE, ONLY : PVTK_FILE +USE VTK_FORTRAN_VTK_FILE, ONLY : VTK_FILE +USE VTK_FORTRAN_VTM_FILE, ONLY : VTM_FILE + +IMPLICIT NONE +PRIVATE +PUBLIC :: PVTK_FILE +PUBLIC :: VTK_FILE +PUBLIC :: VTM_FILE +PUBLIC :: WRITE_XML_VOLATILE + +CONTAINS + FUNCTION WRITE_XML_VOLATILE(XML_VOLATILE, FILENAME) RESULT(ERROR) + !< WRITE THE VOLATILE FILE INTO A REAL FILE. + !< THIS IS WHAT A MASTER PROCESS SHOULD DO INTO A PARALLEL SCENARIO WHERE IT BEING THE ONLY PROCESS ALLOWED TO ACCESS TO + !< FILESYSTEM: SLAVE PROCESSES CREATE XML VOLATILE FILE ECONDED INTO A CHARACTERS STRING AND MASTER PROCESS COLLECTS AND WRITES + !< THEM BY MEANS OF `WRITE_XML_VOLATILE`. + CHARACTER(*), INTENT(IN) :: XML_VOLATILE !< XML VOLATILE FILE. + CHARACTER(*), INTENT(IN) :: FILENAME !< XML FILE NAME. + INTEGER(I4P) :: ERROR !< STATUS ERROR. + INTEGER(I4P) :: XML_UNIT !< XML FILE UNIT. + + OPEN(NEWUNIT=XML_UNIT, & + FILE=TRIM(ADJUSTL(FILENAME)), & + FORM='UNFORMATTED', & + ACCESS='STREAM', & + ACTION='WRITE', & + STATUS='REPLACE', & + IOSTAT=ERROR) + WRITE(UNIT=XML_UNIT, IOSTAT=ERROR) XML_VOLATILE + ENDFUNCTION WRITE_XML_VOLATILE +ENDMODULE VTK_FORTRAN + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +!> \brief Routines for handling vtk output + +MODULE VTK_FDS_INTERFACE + +USE MESH_VARIABLES +USE GLOBAL_CONSTANTS +USE MESH_POINTERS +USE OUTPUT_DATA +USE VTK_FORTRAN, ONLY : VTK_FILE, PVTK_FILE + +IMPLICIT NONE (TYPE,EXTERNAL) +PRIVATE + +PUBLIC WRITE_VTK_SLICE_WRAPPER,BUILD_VTK_GAS_PHASE_GEOMETRY,& + WRITE_VTK_SL3D_WRAPPER,WRITE_VTK_SM3D_WRAPPER,& + DEALLOCATE_VTK_GAS_PHASE_GEOMETRY + +CONTAINS + +SUBROUTINE WRITE_VTK_SLICE_WRAPPER(T,NMESHES,MESH_TOPOLOGY) +INTEGER, INTENT(IN) :: NMESHES +CHARACTER(LEN=*), INTENT(IN) :: MESH_TOPOLOGY +REAL(EB), INTENT(IN) :: T +TYPE (SLICE_TYPE), POINTER :: SL +INTEGER :: I,NQT,I1,I2,J1,J2,K1,K2,IQ,ITM,ITM1 +REAL(FB) :: STIME +REAL(EB) :: TT +CHARACTER(200) :: TMP_FILE + +! Generate filename +STIME = REAL(T_BEGIN + (T-T_BEGIN)*TIME_SHRINK_FACTOR,FB) +TT = T_BEGIN + (T-T_BEGIN)*TIME_SHRINK_FACTOR +ITM = INT(TT) +ITM1 = NINT(ABS(TT-ITM)*100) +IF (ITM1==100) THEN + ITM = ITM+1 + ITM1 = 0 +ENDIF +WRITE(FN_SL3D_VTK(NMESHES+1),'(A,A,A,I8.8,I2.2,A)') "",TRIM(CHID),'_SL3D_',ITM,ITM1,'.pvtu' + +! First part of header before quantities +OPEN(LU_SL3D_VTK(NMESHES+1),FILE=FN_SL3D_VTK(NMESHES+1),FORM='FORMATTED') +WRITE(LU_SL3D_VTK(NMESHES+1),'(A)',ADVANCE='YES') '<?xml version="1.0"?>' +WRITE(LU_SL3D_VTK(NMESHES+1),'(A,A,A)',ADVANCE='YES') & + '<VTKFile type="',TRIM(MESH_TOPOLOGY),'" version="1.0" byte_order="LittleEndian">' +WRITE(LU_SL3D_VTK(NMESHES+1),'(A,A,A)',ADVANCE='YES') ' <',TRIM(MESH_TOPOLOGY),' GhostLevel="0">' +WRITE(LU_SL3D_VTK(NMESHES+1),'(A)',ADVANCE='YES') ' <PPointData>' + +! Add PointData arrays +NQT = MESHES(1)%N_SLCF +QUANTITY_LOOP2: DO IQ=1,NQT + SL => SLICE(IQ) + I1 = SL%I1 + I2 = SL%I2 + J1 = SL%J1 + J2 = SL%J2 + K1 = SL%K1 + K2 = SL%K2 + IF (I2-I1==0 .OR. J2-J1==0 .OR. K2-K1==0) CYCLE QUANTITY_LOOP2 + WRITE(LU_SL3D_VTK(NMESHES+1),'(A)',ADVANCE='NO') ' <PDataArray type="Float32" NumberOfComponents="1" Name=' + WRITE(LU_SL3D_VTK(NMESHES+1),'(A,A,A)',ADVANCE='NO') '"',TRIM(SL%SMOKEVIEW_LABEL(1:30)),'" format=' + IF (VTK_BINARY) THEN + WRITE(LU_SL3D_VTK(NMESHES+1),'(A)',ADVANCE='YES') '"binary"/>' + ELSE + WRITE(LU_SL3D_VTK(NMESHES+1),'(A)',ADVANCE='YES') '"ascii"/>' + ENDIF +ENDDO QUANTITY_LOOP2 + +! Close PointData +WRITE(LU_SL3D_VTK(NMESHES+1),'(A)',ADVANCE='YES') ' </PPointData>' + +! Add Point arrays +WRITE(LU_SL3D_VTK(NMESHES+1),'(A)',ADVANCE='YES') ' <PPoints>' +WRITE(LU_SL3D_VTK(NMESHES+1),'(A)',ADVANCE='NO') ' <PDataArray type="Float32" NumberOfComponents="3" Name="Points" format=' +IF (VTK_BINARY) THEN + WRITE(LU_SL3D_VTK(NMESHES+1),'(A)',ADVANCE='YES') '"binary"/>' +ELSE + WRITE(LU_SL3D_VTK(NMESHES+1),'(A)',ADVANCE='YES') '"ascii"/>' +ENDIF +WRITE(LU_SL3D_VTK(NMESHES+1),'(A)',ADVANCE='YES') ' </PPoints>' + +! Add CellData +WRITE(LU_SL3D_VTK(NMESHES+1),'(A)',ADVANCE='YES') ' <PCellData></PCellData>' + +! Write pieces +DO I=1,NMESHES + WRITE(TMP_FILE,'(A,A,I0,A,I8.8,I2.2,A)') TRIM(CHID),'_SL3D_',I,'_',ITM,ITM1,'.vtu' + WRITE(LU_SL3D_VTK(NMESHES+1),'(A,A,A)',ADVANCE='YES') ' <Piece Source="',TRIM(TMP_FILE),'"/>' +ENDDO + +! Finalize file +WRITE(LU_SL3D_VTK(NMESHES+1),'(A,A,A)',ADVANCE='YES') ' </',TRIM(MESH_TOPOLOGY),'>' +WRITE(LU_SL3D_VTK(NMESHES+1),'(A)',ADVANCE='YES') '</VTKFile>' +CLOSE(LU_SL3D_VTK(NMESHES+1)) +END SUBROUTINE WRITE_VTK_SLICE_WRAPPER + + + +SUBROUTINE WRITE_VTK_SL3D_WRAPPER(T,NMESHES,MESH_TOPOLOGY) +INTEGER, INTENT(IN) :: NMESHES +CHARACTER(LEN=*), INTENT(IN) :: MESH_TOPOLOGY +REAL(EB), INTENT(IN) :: T +TYPE (SLICE_TYPE), POINTER :: SL +INTEGER :: I,NQT,I1,I2,J1,J2,K1,K2,IQ,ITM,ITM1 +REAL(FB) :: STIME +REAL(EB) :: TT +TYPE(PVTK_FILE) :: A_PVTK_FILE !< A parallel (partioned) VTK file. +INTEGER(IB8) :: VTK_ERROR=0_IB8 !< IO Error status. +CHARACTER(200) :: TMP_FILE + +! Generate filename +STIME = REAL(T_BEGIN + (T-T_BEGIN)*TIME_SHRINK_FACTOR,FB) +TT = T_BEGIN + (T-T_BEGIN)*TIME_SHRINK_FACTOR +ITM = INT(TT) +ITM1 = NINT(ABS(TT-ITM)*100) +IF (ITM1==100) THEN + ITM = ITM+1 + ITM1 = 0 +ENDIF +WRITE(FN_SL3D_VTK(NMESHES+1),'(A,A,A,I8.8,I2.2,A)') "",TRIM(CHID),'_SL3D_',ITM,ITM1,'.pvtu' +VTK_ERROR = A_PVTK_FILE%INITIALIZE(FILENAME=FN_SL3D_VTK(NMESHES+1), MESH_TOPOLOGY='PUnstructuredGrid',& + MESH_KIND='Float32') +VTK_ERROR = A_PVTK_FILE%XML_WRITER%W_DATA(LOCATION='NODE',ACTION='OPEN') +! Add PointData arrays +NQT = MESHES(1)%N_SLCF +QUANTITY_LOOP2: DO IQ=1,NQT + SL => SLICE(IQ) + I1 = SL%I1 + I2 = SL%I2 + J1 = SL%J1 + J2 = SL%J2 + K1 = SL%K1 + K2 = SL%K2 + IF (I2-I1==0 .OR. J2-J1==0 .OR. K2-K1==0) CYCLE QUANTITY_LOOP2 + VTK_ERROR = A_PVTK_FILE%XML_WRITER%WRITE_PARALLEL_DATAARRAY(DATA_NAME=TRIM(SL%SMOKEVIEW_LABEL(1:30)), & + DATA_TYPE='Float32', NUMBER_OF_COMPONENTS=1) +ENDDO QUANTITY_LOOP2 +VTK_ERROR = A_PVTK_FILE%XML_WRITER%W_DATA(LOCATION='NODE',ACTION='CLOSE') + +DO I=1,NMESHES + WRITE(TMP_FILE,'(A,A,I0,A,I8.8,I2.2,A)') TRIM(CHID),'_SL3D_',I,'_',ITM,ITM1,'.vtu' + VTK_ERROR = A_PVTK_FILE%XML_WRITER%WRITE_PARALLEL_GEO(SOURCE=TMP_FILE) +ENDDO + +VTK_ERROR = A_PVTK_FILE%FINALIZE() +END SUBROUTINE WRITE_VTK_SL3D_WRAPPER + + + + + + + + + + + + + +SUBROUTINE WRITE_VTK_SM3D_WRAPPER(T,NMESHES,MESH_TOPOLOGY) +INTEGER, INTENT(IN) :: NMESHES +CHARACTER(LEN=*), INTENT(IN) :: MESH_TOPOLOGY +REAL(EB), INTENT(IN) :: T +INTEGER :: I,ITM,ITM1,N +REAL(FB) :: STIME +REAL(EB) :: TT +TYPE(SMOKE3D_TYPE), POINTER :: S3 +TYPE(PVTK_FILE) :: A_PVTK_FILE !< A parallel (partioned) VTK file. +INTEGER(IB8) :: VTK_ERROR=0_IB8 !< IO Error status. +CHARACTER(200) :: TMP_FILE + +! Generate filename +STIME = REAL(T_BEGIN + (T-T_BEGIN)*TIME_SHRINK_FACTOR,FB) +TT = T_BEGIN + (T-T_BEGIN)*TIME_SHRINK_FACTOR +ITM = INT(TT) +ITM1 = NINT(ABS(TT-ITM)*100) +IF (ITM1==100) THEN + ITM = ITM+1 + ITM1 = 0 +ENDIF +WRITE(FN_SMOKE3D_VTK(NMESHES+1),'(A,A,A,A,A,I8.8,I2.2,A)') "",TRIM(CHID),'_','SM3D','_',ITM,ITM1,'.pvtu' +VTK_ERROR = A_PVTK_FILE%INITIALIZE(FILENAME=FN_SMOKE3D_VTK(NMESHES+1), MESH_TOPOLOGY='PUnstructuredGrid',& + MESH_KIND='Float32') +! Add PointData arrays +VTK_ERROR = A_PVTK_FILE%XML_WRITER%W_DATA(LOCATION='NODE',ACTION='OPEN') +DATA_FILE_LOOP2: DO N=1,N_SMOKE3D + S3 => SMOKE3D_FILE(N) + VTK_ERROR = A_PVTK_FILE%XML_WRITER%WRITE_PARALLEL_DATAARRAY(DATA_NAME=TRIM(S3%SMOKEVIEW_LABEL(1:30)), & + DATA_TYPE='Float32', NUMBER_OF_COMPONENTS=1) +ENDDO DATA_FILE_LOOP2 +VTK_ERROR = A_PVTK_FILE%XML_WRITER%W_DATA(LOCATION='NODE',ACTION='CLOSE') + +DO I=1,NMESHES + WRITE(TMP_FILE,'(A,A,I0,A,I8.8,I2.2,A)') TRIM(CHID),'_SM3D_',I,'_',ITM,ITM1,'.vtu' + VTK_ERROR = A_PVTK_FILE%XML_WRITER%WRITE_PARALLEL_GEO(SOURCE=TMP_FILE) +ENDDO + +VTK_ERROR = A_PVTK_FILE%FINALIZE() +END SUBROUTINE WRITE_VTK_SM3D_WRAPPER + + + +SUBROUTINE BUILD_VTK_GAS_PHASE_GEOMETRY(NM, MESH_TOPOLOGY, FN, & + NC, NP, X_PTS, Y_PTS, Z_PTS, CONNECT, OFFSETS, VTKC_TYPE) + +INTEGER :: NX, NY, NZ, NC, NP, I, J, K, IFACT, JFACT, KFACT +REAL(FB), ALLOCATABLE, DIMENSION(:) :: X_PTS, Y_PTS, Z_PTS +INTEGER(IB32), ALLOCATABLE, DIMENSION(:) :: CONNECT, OFFSETS +INTEGER(IB8), ALLOCATABLE, DIMENSION(:) :: VTKC_TYPE +CHARACTER(LEN=*), INTENT(IN) :: MESH_TOPOLOGY, FN +INTEGER, INTENT(IN) :: NM + +NX = SIZE(MESHES(NM)%X) +NY = SIZE(MESHES(NM)%Y) +NZ = SIZE(MESHES(NM)%Z) + +NP = NX*NY*NZ +NC = (NX-1)*(NY-1)*(NZ-1) + +! Fill point data +ALLOCATE(X_PTS(NP)) +ALLOCATE(Y_PTS(NP)) +ALLOCATE(Z_PTS(NP)) +IFACT = 1 +DO K = 0, NZ-1 + DO J = 0, NY-1 + DO I = 0, NX-1 + X_PTS(IFACT)=MESHES(NM)%X(I) + Y_PTS(IFACT)=MESHES(NM)%Y(J) + Z_PTS(IFACT)=MESHES(NM)%Z(K) + IFACT = IFACT + 1 + ENDDO + ENDDO +ENDDO + +! Fill cell data +ALLOCATE(CONNECT(NC*8)) +DO I = 1, NX-1 + IFACT = (I-1) + DO J = 1, NY-1 + JFACT = (J-1)*(NX-1) + DO K = 1, NZ-1 + KFACT = (K - 1)*(NY-1)*(NX-1) + CONNECT((IFACT+JFACT+KFACT)*8+1) = (K-1)*(NY*NX) + (J-1)*NX + I-1 + CONNECT((IFACT+JFACT+KFACT)*8+2) = (K-1)*(NY*NX) + (J-1)*NX + I + CONNECT((IFACT+JFACT+KFACT)*8+3) = (K-1)*(NY*NX) + (J)*NX + I-1 + CONNECT((IFACT+JFACT+KFACT)*8+4) = (K-1)*(NY*NX) + (J)*NX + I + CONNECT((IFACT+JFACT+KFACT)*8+5) = (K)*(NY*NX) + (J-1)*NX + I-1 + CONNECT((IFACT+JFACT+KFACT)*8+6) = (K)*(NY*NX) + (J-1)*NX + I + CONNECT((IFACT+JFACT+KFACT)*8+7) = (K)*(NY*NX) + (J)*NX + I-1 + CONNECT((IFACT+JFACT+KFACT)*8+8) = (K)*(NY*NX) + (J)*NX + I + ENDDO + ENDDO +ENDDO + +ALLOCATE(OFFSETS(NC)) +ALLOCATE(VTKC_TYPE(NC)) + +DO I=1,NC + OFFSETS(I) = (I)*8_IB32 + VTKC_TYPE(I) = 11_IB8 +ENDDO + +ENDSUBROUTINE BUILD_VTK_GAS_PHASE_GEOMETRY + + + +SUBROUTINE DEALLOCATE_VTK_GAS_PHASE_GEOMETRY(X_PTS,Y_PTS,Z_PTS,OFFSETS,VTKC_TYPE,CONNECT) + +REAL(FB), DIMENSION(:), ALLOCATABLE :: X_PTS, Y_PTS, Z_PTS +INTEGER(IB32), DIMENSION(:), ALLOCATABLE :: CONNECT, OFFSETS +INTEGER(IB8), DIMENSION(:), ALLOCATABLE :: VTKC_TYPE +DEALLOCATE(OFFSETS) +DEALLOCATE(VTKC_TYPE) +DEALLOCATE(CONNECT) +DEALLOCATE(X_PTS) +DEALLOCATE(Y_PTS) +DEALLOCATE(Z_PTS) + +ENDSUBROUTINE DEALLOCATE_VTK_GAS_PHASE_GEOMETRY + +END MODULE VTK_FDS_INTERFACE + + + + + + + + + + + + + + + + + + + + + + + + + + + From 3445fd0ebd8346fba18be4802d30d17cbf3aeecb Mon Sep 17 00:00:00 2001 From: Jonathan Hodges <johodges@vt.edu> Date: Fri, 5 Jan 2024 15:11:39 -0500 Subject: [PATCH 22/31] Add VTK output for BDNF --- Source/cons.f90 | 7 +- Source/dump.f90 | 495 ++++++++++++++++++++++---------- Source/func.f90 | 1 + Source/vtkf.f90 | 742 ++++++------------------------------------------ 4 files changed, 429 insertions(+), 816 deletions(-) diff --git a/Source/cons.f90 b/Source/cons.f90 index 2169784f3d7..146726680db 100644 --- a/Source/cons.f90 +++ b/Source/cons.f90 @@ -549,7 +549,7 @@ MODULE GLOBAL_CONSTANTS CHARACTER(80), ALLOCATABLE, DIMENSION(:) :: FN_VEG_OUT,FN_GEOM, FN_CFACE_GEOM CHARACTER(80), ALLOCATABLE, DIMENSION(:,:) :: FN_SLCF,FN_SLCF_GEOM,FN_BNDF,FN_BNDG, & FN_ISOF,FN_ISOF2,FN_SMOKE3D,FN_RADF -CHARACTER(200), ALLOCATABLE, DIMENSION(:) :: FN_SL3D_VTK,FN_SMOKE3D_VTK +CHARACTER(200), ALLOCATABLE, DIMENSION(:) :: FN_SL3D_VTK,FN_SMOKE3D_VTK,FN_BNDF_VTK CHARACTER(9) :: FMT_R LOGICAL :: OUT_FILE_OPENED=.FALSE. @@ -762,14 +762,15 @@ MODULE OUTPUT_CLOCKS INTEGER :: RAMP_SPEC_INDEX=0 !< Ramp index for species file time series INTEGER :: RAMP_SL3D_VTK_INDEX=0 !< Ramp index for vtk file time series INTEGER :: RAMP_SM3D_VTK_INDEX=0 !< Ramp index for vtk file time series +INTEGER :: RAMP_BNDF_VTK_INDEX=0 !< Ramp index for boundary file time series REAL(EB), ALLOCATABLE, DIMENSION(:) :: BNDF_CLOCK, CPU_CLOCK,CTRL_CLOCK,DEVC_CLOCK,FLSH_CLOCK,GEOM_CLOCK, HRR_CLOCK,HVAC_CLOCK,& ISOF_CLOCK,MASS_CLOCK,PART_CLOCK,PL3D_CLOCK,PROF_CLOCK,RADF_CLOCK,RSRT_CLOCK,& SLCF_CLOCK,SL3D_CLOCK,SM3D_CLOCK,UVW_CLOCK ,TMP_CLOCK ,SPEC_CLOCK,& - SL3D_VTK_CLOCK,SM3D_VTK_CLOCK + SL3D_VTK_CLOCK,SM3D_VTK_CLOCK,BNDF_VTK_CLOCK INTEGER, ALLOCATABLE, DIMENSION(:) :: BNDF_COUNTER, CPU_COUNTER,CTRL_COUNTER,DEVC_COUNTER,FLSH_COUNTER,GEOM_COUNTER, HRR_COUNTER,& HVAC_COUNTER,ISOF_COUNTER,MASS_COUNTER,PART_COUNTER,PL3D_COUNTER,PROF_COUNTER,RADF_COUNTER,& RSRT_COUNTER,SLCF_COUNTER,SL3D_COUNTER,SM3D_COUNTER,UVW_COUNTER ,TMP_COUNTER ,SPEC_COUNTER,& - SL3D_VTK_COUNTER,SM3D_VTK_COUNTER + SL3D_VTK_COUNTER,SM3D_VTK_COUNTER,BNDF_VTK_COUNTER REAL(EB) :: TURB_INIT_CLOCK=-1.E10_EB REAL(EB) :: MMS_TIMER=1.E10_EB REAL(EB) :: DT_SLCF,DT_BNDF,DT_DEVC,DT_PL3D,DT_PART,DT_RESTART,DT_ISOF,DT_HRR,DT_HVAC,DT_MASS,DT_PROF,DT_CTRL,& diff --git a/Source/dump.f90 b/Source/dump.f90 index 4ac629df9f6..2d4748899a8 100644 --- a/Source/dump.f90 +++ b/Source/dump.f90 @@ -19,7 +19,7 @@ MODULE DUMP CC_VGSC,CC_GASPHASE,MAKE_UNIQUE_VERT_ARRAY,AVERAGE_FACE_VALUES USE CC_SCALARS, ONLY : ADD_Q_DOT_CUTCELLS,GET_PRES_CFACE,GET_PRES_CFACE_TEST,GET_UVWGAS_CFACE,GET_MUDNS_CFACE -USE VTK_FDS_INTERFACE, ONLY : WRITE_VTK_SLICE_WRAPPER,BUILD_VTK_GAS_PHASE_GEOMETRY,& +USE VTK_FDS_INTERFACE, ONLY : WRITE_VTK_SLICE_WRAPPER,BUILD_VTK_GAS_PHASE_GEOMETRY,BUILD_VTK_SOLID_PHASE_GEOMETRY,& WRITE_VTK_SM3D_WRAPPER,WRITE_VTK_SL3D_WRAPPER,DEALLOCATE_VTK_GAS_PHASE_GEOMETRY USE VTK_FORTRAN, ONLY : VTK_FILE, PVTK_FILE @@ -157,8 +157,18 @@ SUBROUTINE DUMP_MESH_OUTPUTS(T,DT,NM) ENDDO ENDIF +! VTK Boundary data + +IF (T>=BNDF_VTK_CLOCK(BNDF_VTK_COUNTER(NM))) THEN + CALL DUMP_BNDF(T,DT,NM,1) + DO WHILE(BNDF_VTK_COUNTER(NM)<SIZE(BNDF_VTK_CLOCK)-1) + BNDF_VTK_COUNTER(NM) = BNDF_VTK_COUNTER(NM) + 1 + IF (BNDF_VTK_CLOCK(BNDF_VTK_COUNTER(NM))>=T) EXIT + ENDDO +ENDIF + IF (T>=BNDF_CLOCK(BNDF_COUNTER(NM))) THEN - CALL DUMP_BNDF(T,DT,NM) + CALL DUMP_BNDF(T,DT,NM,0) DO WHILE(BNDF_COUNTER(NM)<SIZE(BNDF_CLOCK)-1) BNDF_COUNTER(NM) = BNDF_COUNTER(NM) + 1 IF (BNDF_CLOCK(BNDF_COUNTER(NM))>=T) EXIT @@ -395,6 +405,7 @@ SUBROUTINE ASSIGN_FILE_NAMES ALLOCATE(LU_SL3D_VTK(NMESHES+1)) ALLOCATE(FN_SMOKE3D_VTK(NMESHES+1)) ALLOCATE(LU_SMOKE3D_VTK(NMESHES+1)) +ALLOCATE(FN_BNDF_VTK(NMESHES+1)) MESH_LOOP: DO NM=1,NMESHES @@ -4280,11 +4291,13 @@ SUBROUTINE DUMP_SMOKE3D(T,DT,NM,IFRMT) USE ISOSMOKE, ONLY: SMOKE3D_TO_FILE REAL(EB), INTENT(IN) :: T,DT INTEGER, INTENT(IN) :: NM,IFRMT -INTEGER :: I,J,K,N,IFACT,JFACT,KFACT,ITM,ITM1,NC,NP +INTEGER :: I,J,K,N,IFACT,JFACT,KFACT,ITM,ITM1,NC,NP,I1=0,J1=0,K1=0,I2,J2,K2,NX,NY,NZ REAL(FB) :: DXX,STIME REAL(EB), POINTER, DIMENSION(:,:,:) :: FF REAL(FB), ALLOCATABLE, DIMENSION(:) :: QQ_PACK -INTEGER(IB8), ALLOCATABLE, DIMENSION(:) :: QQ_PACK_INT +!INTEGER(IB8), ALLOCATABLE, DIMENSION(:) :: QQ_PACK_INT +REAL(FB), ALLOCATABLE, DIMENSION(:) :: QQ_PACK_INT +CHARACTER(C_CHAR) :: C, MOLD REAL(FB), ALLOCATABLE, DIMENSION(:) :: X_PTS, Y_PTS, Z_PTS INTEGER(IB32), ALLOCATABLE, DIMENSION(:) :: CONNECT, OFFSETS INTEGER(IB8), ALLOCATABLE, DIMENSION(:) :: VTKC_TYPE @@ -4371,30 +4384,30 @@ SUBROUTINE DUMP_SMOKE3D(T,DT,NM,IFRMT) ENDIF WRITE(FN_SMOKE3D_VTK(NM),'(A,A,A,I0,A,I8.8,I2.2,A)') "",TRIM(CHID),'_SM3D_',NM,'_',ITM,ITM1,'.vtu' !WRITE(FN_SMOKE3D_VTK(NM),'(A,A,A,I0,A,I8.8,I2.2,A)') "./results/",TRIM(CHID),'_SM3D_',NM,'_',ITM,ITM1,'.vtu' - !WRITE(*,*) "ARRAY SIZES ", IBAR, JBAR, KBAR, IBP1, JBP1, KBP1 - ALLOCATE(QQ_PACK(IBP1*JBP1*KBP1)) - DO I = 0, IBAR - IFACT = I - DO J = 0, JBAR - JFACT = J*(IBAR) - DO K = 0, KBAR - KFACT = K*(JBAR)*(IBAR) + I2 = MESHES(NM)%IBAR + J2 = MESHES(NM)%JBAR + K2 = MESHES(NM)%KBAR + NX = I2 + 1 - I1 + NY = J2 + 1 - J1 + NZ = K2 + 1 - K1 + ALLOCATE(QQ_PACK(NX*NY*NZ)) + DO I = I1, I2 + IFACT = (I-I1) + DO J = J1, J2 + JFACT = (J-J1)*NX + DO K = K1, K2 + KFACT = (K - K1)*NY*NX QQ_PACK(1+IFACT+JFACT+KFACT) = QQ(I,J,K,1) ENDDO ENDDO ENDDO IF (N .EQ. 1) THEN - !CALL INITIALIZE_VTK(LU_SMOKE3D_VTK(NM),FN_SMOKE3D_VTK(NM),'UnstructuredGrid') - !CALL BUILD_VTK_GAS_PHASE_GEOMETRY(NM, 'UnstructuredGrid', FN_SMOKE3D_VTK(NM), & - ! NC, NP, X_PTS, Y_PTS, Z_PTS, CONNECT, OFFSETS, VTKC_TYPE) - !CALL DEALLOCATE_VTK_GAS_PHASE_GEOMETRY(X_PTS,Y_PTS,Z_PTS,OFFSETS,VTKC_TYPE,CONNECT) - ! IF (VTK_BINARY) THEN VTK_ERROR = A_VTK_FILE%INITIALIZE(FORMAT='raw', FILENAME=FN_SMOKE3D_VTK(NM), MESH_TOPOLOGY='UnstructuredGrid') ELSE VTK_ERROR = A_VTK_FILE%INITIALIZE(FORMAT='ascii', FILENAME=FN_SMOKE3D_VTK(NM), MESH_TOPOLOGY='UnstructuredGrid') ENDIF ! do not change capitalization on mesh topology - CALL BUILD_VTK_GAS_PHASE_GEOMETRY(NM, 'UnstructuredGrid', FN_SMOKE3D_VTK(NM), & + CALL BUILD_VTK_GAS_PHASE_GEOMETRY(NM, 'UnstructuredGrid', & NC, NP, X_PTS, Y_PTS, Z_PTS, CONNECT, OFFSETS, VTKC_TYPE) VTK_ERROR = A_VTK_FILE%XML_WRITER%WRITE_PIECE(NP=NP, NC=NC) VTK_ERROR = A_VTK_FILE%XML_WRITER%WRITE_GEO(NP=NP, NC=NC, X=X_PTS, Y=Y_PTS, Z=Z_PTS) @@ -4403,22 +4416,22 @@ SUBROUTINE DUMP_SMOKE3D(T,DT,NM,IFRMT) CALL DEALLOCATE_VTK_GAS_PHASE_GEOMETRY(X_PTS,Y_PTS,Z_PTS,OFFSETS,VTKC_TYPE,CONNECT) ENDIF - ALLOCATE(QQ_PACK_INT(IBP1*JBP1*KBP1)) + ALLOCATE(QQ_PACK_INT(NX*NY*NZ)) IF (S3%DISPLAY_TYPE=='GAS') THEN FACTOR=-REAL(S3%MASS_EXTINCTION_COEFFICIENT,FB)*DXX DO I=1,NP VAL_FDS = MAX(0.0_FB,QQ_PACK(I)) - VAL_SMV = 254*(1.0_FB-EXP(FACTOR*VAL_FDS)) - QQ_PACK_INT(I) = NINT(VAL_SMV) + VAL_SMV = 127*(1.0_FB-EXP(FACTOR*VAL_FDS)) + QQ_PACK_INT(I) = VAL_SMV !NINT(VAL_SMV) ENDDO ELSEIF (S3%DISPLAY_TYPE=='FIRE') THEN DO I=1,NP VAL_FDS = MIN(HRRPUV_MAX_SMV,MAX(0._FB,QQ_PACK(I))) - VAL_SMV = 254*(VAL_FDS/HRRPUV_MAX_SMV) - QQ_PACK_INT(I) = NINT(VAL_SMV) + VAL_SMV = 127*(VAL_FDS/HRRPUV_MAX_SMV) + QQ_PACK_INT(I) = VAL_SMV !NINT(VAL_SMV) ENDDO ELSEIF (S3%DISPLAY_TYPE=='TEMPERATURE') THEN @@ -4426,13 +4439,13 @@ SUBROUTINE DUMP_SMOKE3D(T,DT,NM,IFRMT) TEMP_MIN = REAL(TMPA-TMPM,FB) DO I=1,NP VAL_FDS = MIN(TEMP_MAX_SMV,MAX(TEMP_MIN,QQ_PACK(I))) - VAL_SMV = 254*((VAL_FDS-TEMP_MIN)/(TEMP_MAX_SMV-TEMP_MIN)) - QQ_PACK_INT(I) = NINT(VAL_SMV) + VAL_SMV = 127*((VAL_FDS-TEMP_MIN)/(TEMP_MAX_SMV-TEMP_MIN)) + QQ_PACK_INT(I) = VAL_SMV !NINT(VAL_SMV) ENDDO ELSE DO I=1,NP - QQ_PACK_INT(I) = NINT(QQ_PACK(I)) + QQ_PACK_INT(I) = QQ_PACK(I) !NINT(QQ_PACK(I)) ENDDO ENDIF @@ -6102,7 +6115,7 @@ SUBROUTINE DUMP_SLCF(T,DT,NM,IFRMT) ELSE VTK_ERROR = A_VTK_FILE%INITIALIZE(FORMAT='ascii', FILENAME=FN_SL3D_VTK(NM), MESH_TOPOLOGY='UnstructuredGrid') ENDIF ! do not change capitalization on mesh topology - CALL BUILD_VTK_GAS_PHASE_GEOMETRY(NM, 'UnstructuredGrid', FN_SL3D_VTK(NM), & + CALL BUILD_VTK_GAS_PHASE_GEOMETRY(NM, 'UnstructuredGrid', & NC, NP, X_PTS, Y_PTS, Z_PTS, CONNECT, OFFSETS, VTKC_TYPE) VTK_ERROR = A_VTK_FILE%XML_WRITER%WRITE_PIECE(NP=NP, NC=NC) VTK_ERROR = A_VTK_FILE%XML_WRITER%WRITE_GEO(NP=NP, NC=NC, X=X_PTS, Y=Y_PTS, Z=Z_PTS) @@ -6376,9 +6389,7 @@ SUBROUTINE DUMP_SLCF(T,DT,NM,IFRMT) CLOSE(LU_SLCF(IQ,NM)) ENDIF ENDIF - - - + ! Dump out the slice file to a .vtk file IF (VTK3D) THEN @@ -6407,13 +6418,6 @@ SUBROUTINE DUMP_SLCF(T,DT,NM,IFRMT) ENDDO VTK_ERROR = A_VTK_FILE%XML_WRITER%W_DATA(DATA_NAME=SL%SMOKEVIEW_LABEL(1:30), X=QQ_PACK) - !IF (VTK_BINARY) THEN - ! CALL WRITE_VTK_SLICE_DATA(LU_SL3D_VTK(NM), FN_SL3D_VTK(NM),& - ! QQ_PACK, SL%SMOKEVIEW_LABEL(1:30), 'ascii') - !ELSE - ! CALL WRITE_VTK_SLICE_DATA(LU_SL3D_VTK(NM), FN_SL3D_VTK(NM),& - ! QQ_PACK, SL%SMOKEVIEW_LABEL(1:30), 'ascii') - !ENDIF DEALLOCATE(QQ_PACK) ENDIF @@ -10739,17 +10743,26 @@ END SUBROUTINE DUMP_MASS !> \param T Current simulation time (s) !> \param DT Current time step size (s) !> \param NM Mesh number +!> \param IFRMT BNDF (IFRMT=0) or VTK (IFRMT=1) -SUBROUTINE DUMP_BNDF(T,DT,NM) +SUBROUTINE DUMP_BNDF(T,DT,NM,IFRMT) REAL(EB), INTENT(IN) :: T,DT REAL(FB) :: STIME, BOUND_MIN, BOUND_MAX, BF_FACTOR -INTEGER :: ISUM,NF,IND,I,J,K,IC,IW,L,L1,L2,N,N1,N2,IP,NC,I1,I2,J1,J2,K1,K2 -INTEGER :: NBF_DEBUG -INTEGER, INTENT(IN) :: NM +INTEGER :: ISUM,NF,IND,I,J,K,IC,IW,L,L1,L2,N,N1,N2,IP,NC,I1,I2,J1,J2,K1,K2,ITM,ITM1 +INTEGER :: NBF_DEBUG,IFACT +INTEGER, INTENT(IN) :: NM,IFRMT TYPE(PATCH_TYPE), POINTER :: PA REAL(FB) BNDF_TIME, BNDF_VAL_MIN, BNDF_VAL_MAX INTEGER :: CHANGE_BOUND, IERROR +INTEGER :: NX, NY, NZ, NCELLS, NPOINTS +REAL(FB), ALLOCATABLE, DIMENSION(:) :: QQ_PACK +REAL(FB), ALLOCATABLE, DIMENSION(:) :: X_PTS, Y_PTS, Z_PTS +INTEGER(IB32), ALLOCATABLE, DIMENSION(:) :: CONNECT, OFFSETS +INTEGER(IB8), ALLOCATABLE, DIMENSION(:) :: VTKC_TYPE +TYPE(VTK_FILE) :: A_VTK_FILE ! A VTK file. +INTEGER(IB8) :: VTK_ERROR=0_IB8 !< IO Error status. +LOGICAL :: VTK_INITIALIZED IF (MESHES(NM)%N_PATCH==0 .AND. MESHES(NM)%N_INTERNAL_CFACE_CELLS==0) RETURN @@ -10759,20 +10772,271 @@ SUBROUTINE DUMP_BNDF(T,DT,NM) CALL POINT_TO_MESH(NM) -FILE_LOOP: DO NF=1,N_BNDF - IF (N_PATCH == 0) CYCLE FILE_LOOP - BF => BOUNDARY_FILE(NF) - PY => PROPERTY(BF%PROP_INDEX) - BOUND_MAX = -1.0E+33_FB - BOUND_MIN = -BOUND_MAX - WRITE(LU_BNDF(NF,NM)) STIME - IND = ABS(BF%INDEX) - NC = 0 +IF (IFRMT.EQ.0) THEN + FILE_LOOP: DO NF=1,N_BNDF + IF (N_PATCH == 0) CYCLE FILE_LOOP + BF => BOUNDARY_FILE(NF) + PY => PROPERTY(BF%PROP_INDEX) + BOUND_MAX = -1.0E+33_FB + BOUND_MIN = -BOUND_MAX + WRITE(LU_BNDF(NF,NM)) STIME + IND = ABS(BF%INDEX) + NC = 0 + + PATCH_LOOP: DO IP=1,N_PATCH + + PA => PATCH(IP) + + PP = REAL(OUTPUT_QUANTITY(-IND)%AMBIENT_VALUE,FB) + PPN = 0._FB + IBK = 0 + + ! Adjust PATCH indices depending on orientation + + SELECT CASE(ABS(PA%IOR)) + CASE(1) ; L1=PA%JG1 ; L2=PA%JG2 ; N1=PA%KG1 ; N2=PA%KG2 + CASE(2) ; L1=PA%IG1 ; L2=PA%IG2 ; N1=PA%KG1 ; N2=PA%KG2 + CASE(3) ; L1=PA%IG1 ; L2=PA%IG2 ; N1=PA%JG1 ; N2=PA%JG2 + END SELECT + + ! Evaluate the given boundary quantity at each cell of the current PATCH + + DO K=PA%KG1,PA%KG2 + DO J=PA%JG1,PA%JG2 + DO I=PA%IG1,PA%IG2 + IC = CELL_INDEX(I,J,K) + IW = CELL(IC)%WALL_INDEX(-PA%IOR) ; IF (IW==0) CYCLE + SELECT CASE(ABS(PA%IOR)) + CASE(1) ; L=J ; N=K + CASE(2) ; L=I ; N=K + CASE(3) ; L=I ; N=J + END SELECT + IF (WALL(IW)%BOUNDARY_TYPE/=NULL_BOUNDARY .AND. & + WALL(IW)%BOUNDARY_TYPE/=INTERPOLATED_BOUNDARY .AND. .NOT.CELL(IC)%SOLID) THEN + IBK(L,N) = 1 + PP(L,N) = REAL(SOLID_PHASE_OUTPUT(NM,IND,BF%Y_INDEX,BF%Z_INDEX,BF%PART_INDEX,OPT_WALL_INDEX=IW,& + OPT_BNDF_INDEX=NF),FB) + ENDIF + ENDDO + ENDDO + ENDDO + + ! Integrate the boundary quantity in time + + IF (BNDF_COUNTER(NM)>0 .AND. BF%TIME_INTEGRAL_INDEX>0) THEN + DO N=N1,N2 + DO L=L1,L2 + NC = NC + 1 + BNDF_TIME_INTEGRAL(NC,BF%TIME_INTEGRAL_INDEX) = BNDF_TIME_INTEGRAL(NC,BF%TIME_INTEGRAL_INDEX) + & + PP(L,N)*REAL(BNDF_CLOCK(BNDF_COUNTER(NM))-BNDF_CLOCK(BNDF_COUNTER(NM)-1),FB) + PP(L,N) = BNDF_TIME_INTEGRAL(NC,BF%TIME_INTEGRAL_INDEX) + ENDDO + ENDDO + ENDIF + + ! Interpolate the boundary quantity PP at cell corners, PPN + + IF (.NOT.BF%CELL_CENTERED) THEN + DO N=N1-1,N2 + DO L=L1-1,L2 + IF (IBK(L,N)==1) PPN(L,N) = PPN(L,N) + PP(L,N) + IF (IBK(L+1,N)==1) PPN(L,N) = PPN(L,N) + PP(L+1,N) + IF (IBK(L,N+1)==1) PPN(L,N) = PPN(L,N) + PP(L,N+1) + IF (IBK(L+1,N+1)==1) PPN(L,N) = PPN(L,N) + PP(L+1,N+1) + ISUM = IBK(L,N)+IBK(L,N+1)+IBK(L+1,N)+IBK(L+1,N+1) + IF (ISUM>0) THEN + PPN(L,N) = PPN(L,N)/REAL(ISUM,FB) + ELSE + PPN(L,N) = REAL(SOLID_PHASE_OUTPUT(NM,IND,BF%Y_INDEX,BF%Z_INDEX,BF%PART_INDEX,OPT_WALL_INDEX=0,& + OPT_BNDF_INDEX=NF),FB) + ENDIF + ENDDO + ENDDO + IF (BF%DEBUG .EQ. 0) THEN + WRITE(LU_BNDF(NF,NM)) ((PPN(L,N),L=L1-1,L2),N=N1-1,N2) + DO L = L1-1, L2 + DO N = N1-1, N2 + BOUND_MIN = MIN(PPN(L,N),BOUND_MIN) + BOUND_MAX = MAX(PPN(L,N),BOUND_MAX) + ENDDO + ENDDO + ELSE + NBF_DEBUG = (2+L2-L1)*(2+N2-N1) + BF_FACTOR = 0.0_FB + IF ( NBF_DEBUG .GT. 1) BF_FACTOR = 2.0_FB*STIME/REAL(NBF_DEBUG-1,FB) + WRITE(LU_BNDF(NF,NM)) (REAL(-STIME+L*BF_FACTOR,FB),L=0,NBF_DEBUG-1) + BOUND_MIN = -STIME + BOUND_MAX = STIME + ENDIF + + ELSE + IF (BF%DEBUG .EQ. 0) THEN + WRITE(LU_BNDF(NF,NM)) ((PP(L,N),L=L1,L2+1),N=N1,N2+1) + DO L = L1, L2+1 + DO N = N1, N2+1 + BOUND_MIN = MIN(PP(L,N),BOUND_MIN) + BOUND_MAX = MAX(PP(L,N),BOUND_MAX) + ENDDO + ENDDO + ELSE + NBF_DEBUG = (2+L2-L1)*(2+N2-N1) + BF_FACTOR = 0.0_FB + IF ( NBF_DEBUG .GT. 1 ) BF_FACTOR = 2.0_FB*STIME/REAL(NBF_DEBUG-1,FB) + WRITE(LU_BNDF(NF,NM)) (REAL(-STIME+L*BF_FACTOR,FB),L=0,NBF_DEBUG-1) + BOUND_MIN = -STIME + BOUND_MAX = STIME + ENDIF + ENDIF - PATCH_LOOP: DO IP=1,N_PATCH + ENDDO PATCH_LOOP + CHANGE_BOUND = 0 + IF (REAL(T-T_BEGIN,FB)<TWO_EPSILON_FB) THEN + BNDF_VAL_MIN = BOUND_MIN + BNDF_VAL_MAX = BOUND_MAX + CHANGE_BOUND = 1 + ELSE + OPEN(LU_BNDF(NF+N_BNDF,NM),FILE=FN_BNDF(NF+N_BNDF,NM),ACTION='READ') + READ(LU_BNDF(NF+N_BNDF,NM),FMT=*,IOSTAT=IERROR)BNDF_TIME, BNDF_VAL_MIN, BNDF_VAL_MAX + CLOSE(LU_BNDF(NF+N_BNDF,NM)) + IF( IERROR /= 0 .OR. BOUND_MIN < BNDF_VAL_MIN) THEN + BNDF_VAL_MIN = BOUND_MIN + CHANGE_BOUND = 1 + ENDIF + IF( IERROR /= 0 .OR. BOUND_MAX > BNDF_VAL_MAX) THEN + BNDF_VAL_MAX = BOUND_MAX + CHANGE_BOUND = 1 + ENDIF + ENDIF + IF (CHANGE_BOUND == 1) THEN + OPEN(LU_BNDF(NF+N_BNDF,NM),FILE=FN_BNDF(NF+N_BNDF,NM),FORM='FORMATTED',STATUS='REPLACE') + WRITE(LU_BNDF(NF+N_BNDF,NM),'(ES13.6,1X,ES13.6,1X,ES13.6)')STIME, BNDF_VAL_MIN, BNDF_VAL_MAX + CLOSE(LU_BNDF(NF+N_BNDF,NM)) + ENDIF + + ENDDO FILE_LOOP + IF (CC_IBM) THEN + FILE_LOOP2 : DO NF=1,N_BNDF + BF => BOUNDARY_FILE(NF) + PY => PROPERTY(BF%PROP_INDEX) + IND = ABS(BF%INDEX) + NC = 0 + I1=0; I2=-1; J1=0; J2=-1; K1=0; K2=-1; ! Just dummy numbers, not needed for INBOUND_FACES + ! write geometry for slice file + CHANGE_BOUND = 0 + IF (REAL(T-T_BEGIN,FB)<TWO_EPSILON_FB) THEN + OPEN(LU_BNDG(NF,NM), FILE=FN_BNDG(NF,NM), FORM='UNFORMATTED',STATUS='REPLACE') + CALL DUMP_SLICE_GEOM_DATA(LU_BNDG(NF,NM), & + .FALSE.,.TRUE.,"INBOUND_FACES",1,STIME,I1,I2,J1,J2,K1,K2,BF%DEBUG, & + IND,0,BF%Y_INDEX,BF%Z_INDEX,BF%PART_INDEX,0,0,BF%PROP_INDEX,0,0,T,DT,NM, & + BOUND_MIN, BOUND_MAX) + BNDF_VAL_MIN = BOUND_MIN + BNDF_VAL_MAX = BOUND_MAX + CHANGE_BOUND = 1 + ELSE + ! data file at subsequent time steps + OPEN(LU_BNDG(NF,NM), FILE=FN_BNDG(NF,NM), FORM='UNFORMATTED',STATUS='OLD',POSITION='APPEND') + CALL DUMP_SLICE_GEOM_DATA(LU_BNDG(NF,NM), & + .FALSE.,.TRUE.,"INBOUND_FACES",0,STIME,I1,I2,J1,J2,K1,K2,BF%DEBUG, & + IND,0,BF%Y_INDEX,BF%Z_INDEX,BF%PART_INDEX,0,0,BF%PROP_INDEX,0,0,T,DT,NM, & + BOUND_MIN, BOUND_MAX) + OPEN(LU_BNDG(NF+N_BNDF,NM),FILE=FN_BNDG(NF+N_BNDF,NM), ACTION='READ') + READ(LU_BNDG(NF+N_BNDF,NM),FMT=*,IOSTAT=IERROR)BNDF_TIME, BNDF_VAL_MIN, BNDF_VAL_MAX + CLOSE(LU_BNDG(NF+N_BNDF,NM)) + IF (IERROR /= 0 .OR. BOUND_MIN < BNDF_VAL_MIN) THEN + BNDF_VAL_MIN = BOUND_MIN + CHANGE_BOUND = 1 + ENDIF + IF (IERROR /= 0 .OR. BOUND_MAX > BNDF_VAL_MAX) THEN + BNDF_VAL_MAX = BOUND_MAX + CHANGE_BOUND = 1 + ENDIF + ENDIF + IF (CHANGE_BOUND == 1) THEN + OPEN(LU_BNDG(NF+N_BNDF,NM),FILE=FN_BNDG(NF+N_BNDF,NM),FORM='FORMATTED',STATUS='REPLACE') + WRITE(LU_BNDG(NF+N_BNDF,NM),'(ES13.6,1X,ES13.6,1X,ES13.6)') STIME, BNDF_VAL_MIN, BNDF_VAL_MAX + CLOSE(LU_BNDG(NF+N_BNDF,NM)) + ENDIF + CLOSE(LU_BNDG(NF,NM)) + ENDDO FILE_LOOP2 + ENDIF +ELSEIF (IFRMT.EQ.1) THEN + ITM = INT(STIME) + ITM1 = NINT(ABS(STIME-ITM)*100) + IF (ITM1==100) THEN + ITM = ITM+1 + ITM1 = 0 + ENDIF + WRITE(FN_BNDF_VTK(NM),'(A,A,A,I0,A,I8.8,I2.2,A)') "",TRIM(CHID),'_BNDF_',NM,'_',ITM,ITM1,'.vtu' + IF (VTK_BINARY) THEN + VTK_ERROR = A_VTK_FILE%INITIALIZE(FORMAT='raw', FILENAME=FN_BNDF_VTK(NM), MESH_TOPOLOGY='UnstructuredGrid') + ELSE + VTK_ERROR = A_VTK_FILE%INITIALIZE(FORMAT='ascii', FILENAME=FN_BNDF_VTK(NM), MESH_TOPOLOGY='UnstructuredGrid') + ENDIF ! do not change capitalization on mesh topology + PATCH_LOOP1: DO IP=1,N_PATCH PA => PATCH(IP) + ! Initialize piece + CALL BUILD_VTK_SOLID_PHASE_GEOMETRY(NM, PA, 'UnstructuredGrid', NCELLS, NPOINTS, & + X_PTS, Y_PTS, Z_PTS, CONNECT, OFFSETS, VTKC_TYPE) + VTK_ERROR = A_VTK_FILE%XML_WRITER%WRITE_PIECE(NP=NPOINTS, NC=NCELLS) + VTK_ERROR = A_VTK_FILE%XML_WRITER%WRITE_GEO(NP=NPOINTS, NC=NCELLS, X=X_PTS, Y=Y_PTS, Z=Z_PTS) + VTK_ERROR = A_VTK_FILE%XML_WRITER%WRITE_CONNECTIVITY(NC=NCELLS, CONNECTIVITY=CONNECT, OFFSET=OFFSETS, VTKC_TYPE=VTKC_TYPE) + VTK_INITIALIZED=.TRUE. + CALL DEALLOCATE_VTK_GAS_PHASE_GEOMETRY(X_PTS,Y_PTS,Z_PTS,OFFSETS,VTKC_TYPE,CONNECT) + + ! Loop through cell centered = F + VTK_ERROR = A_VTK_FILE%XML_WRITER%W_DATA(LOCATION='NODE', ACTION='OPEN') + FILE_LOOPA: DO NF=1,N_BNDF + IF (N_PATCH == 0) CYCLE FILE_LOOPA + BF => BOUNDARY_FILE(NF) + IF (BF%CELL_CENTERED) CYCLE FILE_LOOPA + PY => PROPERTY(BF%PROP_INDEX) + BOUND_MAX = -1.0E+33_FB + BOUND_MIN = -BOUND_MAX + IND = ABS(BF%INDEX) + + CALL PACK_VTK_BNDF(PA,BF,IND,PP,PPN,QQ_PACK) + + VTK_ERROR = A_VTK_FILE%XML_WRITER%W_DATA(DATA_NAME=BF%SMOKEVIEW_LABEL(1:30), X=QQ_PACK) + DEALLOCATE(QQ_PACK) + ENDDO FILE_LOOPA + VTK_ERROR = A_VTK_FILE%XML_WRITER%W_DATA(LOCATION='NODE', ACTION='CLOSE') + + ! Loop through cell centered = T + VTK_ERROR = A_VTK_FILE%XML_WRITER%W_DATA(LOCATION='CELL', ACTION='OPEN') + FILE_LOOPB: DO NF=1,N_BNDF + IF (N_PATCH == 0) CYCLE FILE_LOOPB + BF => BOUNDARY_FILE(NF) + IF (.NOT.BF%CELL_CENTERED) CYCLE FILE_LOOPB + PY => PROPERTY(BF%PROP_INDEX) + BOUND_MAX = -1.0E+33_FB + BOUND_MIN = -BOUND_MAX + IND = ABS(BF%INDEX) + + CALL PACK_VTK_BNDF(PA,BF,IND,PP,PPN,QQ_PACK) + + VTK_ERROR = A_VTK_FILE%XML_WRITER%W_DATA(DATA_NAME=BF%SMOKEVIEW_LABEL(1:30), X=QQ_PACK) + DEALLOCATE(QQ_PACK) + ENDDO FILE_LOOPB + VTK_ERROR = A_VTK_FILE%XML_WRITER%W_DATA(LOCATION='CELL', ACTION='CLOSE') + VTK_ERROR = A_VTK_FILE%XML_WRITER%WRITE_PIECE() + ENDDO PATCH_LOOP1 + VTK_ERROR = A_VTK_FILE%FINALIZE() +ENDIF +FROM_BNDF = .FALSE. + +CONTAINS + + SUBROUTINE PACK_VTK_BNDF(PA,BF,IND,PP,PPN,QQ_PACK) + IMPLICIT NONE + TYPE(PATCH_TYPE), POINTER, INTENT(IN) :: PA + TYPE(BOUNDARY_FILE_TYPE), POINTER, INTENT(IN) :: BF + REAL(FB), POINTER, DIMENSION(:,:), INTENT(IN) :: PP,PPN + INTEGER, INTENT(IN) :: IND + INTEGER :: ISUM,I,J,K,L,L1,L2,N,N1,N2 + REAL(FB), ALLOCATABLE, DIMENSION(:), INTENT(OUT) :: QQ_PACK + PP = REAL(OUTPUT_QUANTITY(-IND)%AMBIENT_VALUE,FB) PPN = 0._FB IBK = 0 @@ -10838,116 +11102,35 @@ SUBROUTINE DUMP_BNDF(T,DT,NM) ENDIF ENDDO ENDDO - IF (BF%DEBUG .EQ. 0) THEN - WRITE(LU_BNDF(NF,NM)) ((PPN(L,N),L=L1-1,L2),N=N1-1,N2) - DO L = L1-1, L2 - DO N = N1-1, N2 - BOUND_MIN = MIN(PPN(L,N),BOUND_MIN) - BOUND_MAX = MAX(PPN(L,N),BOUND_MAX) - ENDDO + ENDIF + + SELECT CASE(ABS(PA%IOR)) + CASE(1) ; L1=PA%JG1 ; L2=PA%JG2 ; N1=PA%KG1 ; N2=PA%KG2; + CASE(2) ; L1=PA%IG1 ; L2=PA%IG2 ; N1=PA%KG1 ; N2=PA%KG2; + CASE(3) ; L1=PA%IG1 ; L2=PA%IG2 ; N1=PA%JG1 ; N2=PA%JG2; + END SELECT + NPOINTS = (L2-L1+2)*(N2-N1+2) + NCELLS = (L2-L1+1)*(N2-N1+1) + IFACT = 1 + IF (.NOT.BF%CELL_CENTERED) THEN + ALLOCATE(QQ_PACK(NPOINTS)) + DO N = N1-1,N2 + DO L = L1-1,L2 + QQ_PACK(IFACT)=PPN(L,N) + IFACT = IFACT+1 ENDDO - ELSE - NBF_DEBUG = (2+L2-L1)*(2+N2-N1) - BF_FACTOR = 0.0_FB - IF ( NBF_DEBUG .GT. 1) BF_FACTOR = 2.0_FB*STIME/REAL(NBF_DEBUG-1,FB) - WRITE(LU_BNDF(NF,NM)) (REAL(-STIME+L*BF_FACTOR,FB),L=0,NBF_DEBUG-1) - BOUND_MIN = -STIME - BOUND_MAX = STIME - ENDIF - + ENDDO ELSE - IF (BF%DEBUG .EQ. 0) THEN - WRITE(LU_BNDF(NF,NM)) ((PP(L,N),L=L1,L2+1),N=N1,N2+1) - DO L = L1, L2+1 - DO N = N1, N2+1 - BOUND_MIN = MIN(PP(L,N),BOUND_MIN) - BOUND_MAX = MAX(PP(L,N),BOUND_MAX) - ENDDO + ALLOCATE(QQ_PACK(NCELLS)) + DO L = L1,L2 + DO N = N1,N2 + QQ_PACK(IFACT)=PP(L,N) + IFACT = IFACT+1 ENDDO - ELSE - NBF_DEBUG = (2+L2-L1)*(2+N2-N1) - BF_FACTOR = 0.0_FB - IF ( NBF_DEBUG .GT. 1 ) BF_FACTOR = 2.0_FB*STIME/REAL(NBF_DEBUG-1,FB) - WRITE(LU_BNDF(NF,NM)) (REAL(-STIME+L*BF_FACTOR,FB),L=0,NBF_DEBUG-1) - BOUND_MIN = -STIME - BOUND_MAX = STIME - ENDIF - ENDIF - - ENDDO PATCH_LOOP - CHANGE_BOUND = 0 - IF (REAL(T-T_BEGIN,FB)<TWO_EPSILON_FB) THEN - BNDF_VAL_MIN = BOUND_MIN - BNDF_VAL_MAX = BOUND_MAX - CHANGE_BOUND = 1 - ELSE - OPEN(LU_BNDF(NF+N_BNDF,NM),FILE=FN_BNDF(NF+N_BNDF,NM),ACTION='READ') - READ(LU_BNDF(NF+N_BNDF,NM),FMT=*,IOSTAT=IERROR)BNDF_TIME, BNDF_VAL_MIN, BNDF_VAL_MAX - CLOSE(LU_BNDF(NF+N_BNDF,NM)) - IF( IERROR /= 0 .OR. BOUND_MIN < BNDF_VAL_MIN) THEN - BNDF_VAL_MIN = BOUND_MIN - CHANGE_BOUND = 1 - ENDIF - IF( IERROR /= 0 .OR. BOUND_MAX > BNDF_VAL_MAX) THEN - BNDF_VAL_MAX = BOUND_MAX - CHANGE_BOUND = 1 - ENDIF - ENDIF - IF (CHANGE_BOUND == 1) THEN - OPEN(LU_BNDF(NF+N_BNDF,NM),FILE=FN_BNDF(NF+N_BNDF,NM),FORM='FORMATTED',STATUS='REPLACE') - WRITE(LU_BNDF(NF+N_BNDF,NM),'(ES13.6,1X,ES13.6,1X,ES13.6)')STIME, BNDF_VAL_MIN, BNDF_VAL_MAX - CLOSE(LU_BNDF(NF+N_BNDF,NM)) - ENDIF - -ENDDO FILE_LOOP - -IF (CC_IBM) THEN - FILE_LOOP2 : DO NF=1,N_BNDF - BF => BOUNDARY_FILE(NF) - PY => PROPERTY(BF%PROP_INDEX) - IND = ABS(BF%INDEX) - NC = 0 - I1=0; I2=-1; J1=0; J2=-1; K1=0; K2=-1; ! Just dummy numbers, not needed for INBOUND_FACES - ! write geometry for slice file - CHANGE_BOUND = 0 - IF (REAL(T-T_BEGIN,FB)<TWO_EPSILON_FB) THEN - OPEN(LU_BNDG(NF,NM), FILE=FN_BNDG(NF,NM), FORM='UNFORMATTED',STATUS='REPLACE') - CALL DUMP_SLICE_GEOM_DATA(LU_BNDG(NF,NM), & - .FALSE.,.TRUE.,"INBOUND_FACES",1,STIME,I1,I2,J1,J2,K1,K2,BF%DEBUG, & - IND,0,BF%Y_INDEX,BF%Z_INDEX,BF%PART_INDEX,0,0,BF%PROP_INDEX,0,0,T,DT,NM, & - BOUND_MIN, BOUND_MAX) - BNDF_VAL_MIN = BOUND_MIN - BNDF_VAL_MAX = BOUND_MAX - CHANGE_BOUND = 1 - ELSE - ! data file at subsequent time steps - OPEN(LU_BNDG(NF,NM), FILE=FN_BNDG(NF,NM), FORM='UNFORMATTED',STATUS='OLD',POSITION='APPEND') - CALL DUMP_SLICE_GEOM_DATA(LU_BNDG(NF,NM), & - .FALSE.,.TRUE.,"INBOUND_FACES",0,STIME,I1,I2,J1,J2,K1,K2,BF%DEBUG, & - IND,0,BF%Y_INDEX,BF%Z_INDEX,BF%PART_INDEX,0,0,BF%PROP_INDEX,0,0,T,DT,NM, & - BOUND_MIN, BOUND_MAX) - OPEN(LU_BNDG(NF+N_BNDF,NM),FILE=FN_BNDG(NF+N_BNDF,NM), ACTION='READ') - READ(LU_BNDG(NF+N_BNDF,NM),FMT=*,IOSTAT=IERROR)BNDF_TIME, BNDF_VAL_MIN, BNDF_VAL_MAX - CLOSE(LU_BNDG(NF+N_BNDF,NM)) - IF (IERROR /= 0 .OR. BOUND_MIN < BNDF_VAL_MIN) THEN - BNDF_VAL_MIN = BOUND_MIN - CHANGE_BOUND = 1 - ENDIF - IF (IERROR /= 0 .OR. BOUND_MAX > BNDF_VAL_MAX) THEN - BNDF_VAL_MAX = BOUND_MAX - CHANGE_BOUND = 1 - ENDIF - ENDIF - IF (CHANGE_BOUND == 1) THEN - OPEN(LU_BNDG(NF+N_BNDF,NM),FILE=FN_BNDG(NF+N_BNDF,NM),FORM='FORMATTED',STATUS='REPLACE') - WRITE(LU_BNDG(NF+N_BNDF,NM),'(ES13.6,1X,ES13.6,1X,ES13.6)') STIME, BNDF_VAL_MIN, BNDF_VAL_MAX - CLOSE(LU_BNDG(NF+N_BNDF,NM)) + ENDDO ENDIF - CLOSE(LU_BNDG(NF,NM)) - ENDDO FILE_LOOP2 -ENDIF -FROM_BNDF = .FALSE. + END SUBROUTINE PACK_VTK_BNDF END SUBROUTINE DUMP_BNDF diff --git a/Source/func.f90 b/Source/func.f90 index ead15d3c3dd..2a987d361a0 100644 --- a/Source/func.f90 +++ b/Source/func.f90 @@ -483,6 +483,7 @@ SUBROUTINE INITIALIZE_OUTPUT_CLOCKS(T) CALL SET_OUTPUT_CLOCK(DT_SPEC ,RAMP_SPEC_INDEX,SPEC_CLOCK,SPEC_COUNTER,.TRUE. ,.TRUE. ) CALL SET_OUTPUT_CLOCK(DT_VTK ,RAMP_SL3D_VTK_INDEX, SL3D_VTK_CLOCK, SL3D_VTK_COUNTER,.TRUE. ,.TRUE. ) CALL SET_OUTPUT_CLOCK(DT_VTK ,RAMP_SM3D_VTK_INDEX, SM3D_VTK_CLOCK, SM3D_VTK_COUNTER,.TRUE. ,.TRUE. ) +CALL SET_OUTPUT_CLOCK(DT_VTK ,RAMP_BNDF_VTK_INDEX, BNDF_VTK_CLOCK, BNDF_VTK_COUNTER,.TRUE. ,.TRUE. ) ! Special cases diff --git a/Source/vtkf.f90 b/Source/vtkf.f90 index 59943682cd5..73b3e802135 100644 --- a/Source/vtkf.f90 +++ b/Source/vtkf.f90 @@ -382,31 +382,7 @@ MODULE PENF_STRINGIFY IMPLICIT NONE PRIVATE SAVE -PUBLIC :: STR_ASCII, STR_UCS4 -PUBLIC :: STR, STRZ, CTON -PUBLIC :: BSTR, BCTON - -INTERFACE STR_ASCII - !< CONVERT STRING OF ANY KIND TO ASCII STRING. - MODULE PROCEDURE STR_ASCII_DEFAULT -#if defined _ASCII_SUPPORTED && defined _ASCII_NEQ_DEFAULT - MODULE PROCEDURE STR_ASCII_ASCII -#endif -#ifdef _UCS4_SUPPORTED - MODULE PROCEDURE STR_ASCII_UCS4 -#endif -ENDINTERFACE - -INTERFACE STR_UCS4 - !< CONVERT STRING OF ANY KIND TO UCS4 STRING. - MODULE PROCEDURE STR_UCS4_DEFAULT -#if defined _ASCII_SUPPORTED && defined _ASCII_NEQ_DEFAULT - MODULE PROCEDURE STR_UCS4_ASCII -#endif -#ifdef _UCS4_SUPPORTED - MODULE PROCEDURE STR_UCS4_UCS4 -#endif -ENDINTERFACE +PUBLIC :: STR INTERFACE STR !< CONVERT NUMBER (REAL AND INTEGER) TO STRING (NUMBER TO STRING TYPE CASTING). @@ -428,143 +404,9 @@ MODULE PENF_STRINGIFY STR_A_I1P ENDINTERFACE -INTERFACE STRZ - !< CONVERT INTEGER, TO STRING, PREFIXING WITH THE RIGHT NUMBER OF ZEROS (INTEGER TO STRING TYPE CASTING WITH ZERO PADDING). - MODULE PROCEDURE STRZ_I8P, STRZ_I4P, STRZ_I2P, STRZ_I1P -ENDINTERFACE - -INTERFACE CTON - !< CONVERT STRING TO NUMBER (REAL AND INTEGER, STRING TO NUMBER TYPE CASTING). - MODULE PROCEDURE & - CTOR_R16P, & - CTOR_R8P, & - CTOR_R4P, & - CTOI_I8P, & - CTOI_I4P, & - CTOI_I2P, & - CTOI_I1P -ENDINTERFACE - -INTERFACE BSTR - !< CONVERT NUMBER (REAL AND INTEGER) TO BIT-STRING (NUMBER TO BIT-STRING TYPE CASTING). - MODULE PROCEDURE & - BSTR_R16P, & - BSTR_R8P, & - BSTR_R4P, & - BSTR_I8P, & - BSTR_I4P, & - BSTR_I2P, & - BSTR_I1P -ENDINTERFACE -INTERFACE BCTON - !< CONVERT BIT-STRING TO NUMBER (REAL AND INTEGER, BIT-STRING TO NUMBER TYPE CASTING). - MODULE PROCEDURE & - BCTOR_R16P, & - BCTOR_R8P, & - BCTOR_R4P, & - BCTOI_I8P, & - BCTOI_I4P, & - BCTOI_I2P, & - BCTOI_I1P -ENDINTERFACE CONTAINS - PURE FUNCTION STR_ASCII_DEFAULT(INPUT) RESULT(OUTPUT) - !< CONVERT STRING OF DEFAULT KIND TO ASCII STRING. - !< - !<```FORTRAN - !< USE PENF - !< CHARACTER(LEN=:, KIND=ASCII), ALLOCATABLE :: STRING - !< STRING = STR_ASCII('I WAS DEFAULT KIND, BUT NOW I AM ASCII') - !< PRINT "(A)", STRING - !<``` - !=> I WAS DEFAULT KIND, BUT NOW I AM ASCII <<< - CHARACTER(LEN=*), INTENT(IN) :: INPUT !< INPUT STRING OF DEFAULT KIND. - CHARACTER(LEN=:, KIND=ASCII), ALLOCATABLE :: OUTPUT !< OUTPUT STRING OF ASCII KIND. - - OUTPUT = INPUT - ENDFUNCTION STR_ASCII_DEFAULT - - PURE FUNCTION STR_ASCII_ASCII(INPUT) RESULT(OUTPUT) - !< CONVERT STRING OF ASCII KIND TO ASCII STRING, JUST FOR CONVENIENCE IN SANITIZE STRINGS. - !< - !<```FORTRAN - !< USE PENF - !< CHARACTER(LEN=:, KIND=ASCII), ALLOCATABLE :: STRING - !< STRING = STR_ASCII('I WAS ASCII KIND AND I AM STILL ASCII') - !< PRINT "(A)", STRING - !<``` - !=> I WAS ASCII KIND AND I AM STILL ASCII <<< - CHARACTER(LEN=*, KIND=ASCII), INTENT(IN) :: INPUT !< INPUT STRING OF ASCII KIND. - CHARACTER(LEN=:, KIND=ASCII), ALLOCATABLE :: OUTPUT !< OUTPUT STRING OF ASCII KIND. - - OUTPUT = INPUT - ENDFUNCTION STR_ASCII_ASCII - - PURE FUNCTION STR_ASCII_UCS4(INPUT) RESULT(OUTPUT) - !< CONVERT STRING OF UCS4 KIND TO ASCII STRING. - !< - !<```FORTRAN - !< USE PENF - !< CHARACTER(LEN=:, KIND=ASCII), ALLOCATABLE :: STRING - !< STRING = STR_ASCII(UCS4_'I WAS UCS4 KIND, BUT NOW I AM ASCII') - !< PRINT "(A)", STRING - !<``` - !=> I WAS UCS4 KIND, BUT NOW I AM ASCII <<< - CHARACTER(LEN=*, KIND=UCS4), INTENT(IN) :: INPUT !< INPUT STRING OF UCS4 KIND. - CHARACTER(LEN=:, KIND=ASCII), ALLOCATABLE :: OUTPUT !< OUTPUT STRING OF ASCII KIND. - - OUTPUT = INPUT - ENDFUNCTION STR_ASCII_UCS4 - - PURE FUNCTION STR_UCS4_DEFAULT(INPUT) RESULT(OUTPUT) - !< CONVERT STRING OF DEFAULT KIND TO UCS4 STRING. - !< - !<```FORTRAN - !< USE PENF - !< CHARACTER(LEN=:, KIND=UCS4), ALLOCATABLE :: STRING - !< STRING = STR_ASCII('I WAS DEFAULT KIND, BUT NOW I AM UCS4') - !< PRINT "(A)", STRING - !<``` - !=> I WAS DEFAULT KIND, BUT NOW I AM UCS4 <<< - CHARACTER(LEN=*), INTENT(IN) :: INPUT !< INPUT STRING OF DEFAULT KIND. - CHARACTER(LEN=:, KIND=UCS4), ALLOCATABLE :: OUTPUT !< OUTPUT STRING OF UCS4 KIND. - - OUTPUT = INPUT - ENDFUNCTION STR_UCS4_DEFAULT - - PURE FUNCTION STR_UCS4_ASCII(INPUT) RESULT(OUTPUT) - !< CONVERT STRING OF ASCII KIND TO UCS4 STRING. - !< - !<```FORTRAN - !< USE PENF - !< CHARACTER(LEN=:, KIND=UCS4), ALLOCATABLE :: STRING - !< STRING = STR_ASCII(ASCII_'I WAS ASCII KIND, BUT NOW I AM UCS4') - !< PRINT "(A)", STRING - !<``` - !=> I WAS ASCII KIND, BUT NOW I AM UCS4 <<< - CHARACTER(LEN=*, KIND=ASCII), INTENT(IN) :: INPUT !< INPUT STRING OF ASCII KIND. - CHARACTER(LEN=:, KIND=UCS4), ALLOCATABLE :: OUTPUT !< OUTPUT STRING OF UCS4 KIND. - - OUTPUT = INPUT - ENDFUNCTION STR_UCS4_ASCII - - PURE FUNCTION STR_UCS4_UCS4(INPUT) RESULT(OUTPUT) - !< CONVERT STRING OF UCS4 KIND TO UCS4 STRING, JUST FOR CONVENIENCE IN SANITIZE STRINGS. - !< - !<```FORTRAN - !< USE PENF - !< CHARACTER(LEN=:, KIND=UCS4), ALLOCATABLE :: STRING - !< STRING = STR_ASCII(UCS4_'I WAS UCS4 KIND AND I AM STILL UCS4') - !< PRINT "(A)", STRING - !<``` - !=> I WAS UCS4 KIND AND I AM STILL UCS4 <<< - CHARACTER(LEN=*, KIND=UCS4), INTENT(IN) :: INPUT !< INPUT STRING OF UCS4 KIND. - CHARACTER(LEN=:, KIND=UCS4), ALLOCATABLE :: OUTPUT !< OUTPUT STRING OF UCS4 KIND. - - OUTPUT = INPUT - ENDFUNCTION STR_UCS4_UCS4 ELEMENTAL FUNCTION STRF_R16P(FM, N) RESULT(STR) !< CONVERT REAL TO STRING. @@ -1315,497 +1157,7 @@ PURE SUBROUTINE COMPACT_REAL_STRING(STRING) ENDIF ENDSUBROUTINE COMPACT_REAL_STRING - ELEMENTAL FUNCTION STRZ_I8P(N, NZ_PAD) RESULT(STR) - !< CONVERTING INTEGER TO STRING, PREFIXING WITH THE RIGHT NUMBER OF ZEROS. - !< - !<```FORTRAN - !< USE PENF - !< PRINT "(A)", STRZ(N=1_I8P) - !<``` - !=> 0000000000000000001 <<< - !< - !<```FORTRAN - !< USE PENF - !< PRINT "(A)", STRZ(N=1_I8P, NZ_PAD=5) - !<``` - !=> 00001 <<< - INTEGER(I8P), INTENT(IN) :: N !< INTEGER TO BE CONVERTED. - INTEGER(I4P), INTENT(IN), OPTIONAL :: NZ_PAD !< NUMBER OF ZEROS PADDING. - CHARACTER(DI8P) :: STR !< RETURNED STRING CONTAINING INPUT NUMBER PLUS PADDING ZEROS. - - WRITE(STR,FI8PZP) N ! CASTING OF N TO STRING. - STR=STR(2:) ! LEAVING OUT THE SIGN. - IF (PRESENT(NZ_PAD)) STR=STR(DI8P-NZ_PAD:DI8P-1) ! LEAVING OUT THE EXTRA ZEROS PADDING - ENDFUNCTION STRZ_I8P - - ELEMENTAL FUNCTION STRZ_I4P(N, NZ_PAD) RESULT(STR) - !< CONVERT INTEGER TO STRING, PREFIXING WITH THE RIGHT NUMBER OF ZEROS. - !< - !<```FORTRAN - !< USE PENF - !< PRINT "(A)", STRZ(N=1_I4P) - !<``` - !=> 0000000001 <<< - !< - !<```FORTRAN - !< USE PENF - !< PRINT "(A)", STRZ(N=1_I4P, NZ_PAD=5) - !<``` - !=> 00001 <<< - INTEGER(I4P), INTENT(IN) :: N !< INTEGER TO BE CONVERTED. - INTEGER(I4P), INTENT(IN), OPTIONAL :: NZ_PAD !< NUMBER OF ZEROS PADDING. - CHARACTER(DI4P) :: STR !< RETURNED STRING CONTAINING INPUT NUMBER PLUS PADDING ZEROS. - - WRITE(STR,FI4PZP) N ! CASTING OF N TO STRING. - STR=STR(2:) ! LEAVING OUT THE SIGN. - IF (PRESENT(NZ_PAD)) STR=STR(DI4P-NZ_PAD:DI4P-1) ! LEAVING OUT THE EXTRA ZEROS PADDING - ENDFUNCTION STRZ_I4P - - ELEMENTAL FUNCTION STRZ_I2P(N, NZ_PAD) RESULT(STR) - !< CONVERT INTEGER TO STRING, PREFIXING WITH THE RIGHT NUMBER OF ZEROS. - !< - !<```FORTRAN - !< USE PENF - !< PRINT "(A)", STRZ(N=1_I2P) - !<``` - !=> 00001 <<< - !< - !<```FORTRAN - !< USE PENF - !< PRINT "(A)", STRZ(N=1_I2P, NZ_PAD=3) - !<``` - !=> 001 <<< - INTEGER(I2P), INTENT(IN) :: N !< INTEGER TO BE CONVERTED. - INTEGER(I4P), INTENT(IN), OPTIONAL :: NZ_PAD !< NUMBER OF ZEROS PADDING. - CHARACTER(DI2P) :: STR !< RETURNED STRING CONTAINING INPUT NUMBER PLUS PADDING ZEROS. - - WRITE(STR,FI2PZP) N ! CASTING OF N TO STRING. - STR=STR(2:) ! LEAVING OUT THE SIGN. - IF (PRESENT(NZ_PAD)) STR=STR(DI2P-NZ_PAD:DI2P-1) ! LEAVING OUT THE EXTRA ZEROS PADDING - ENDFUNCTION STRZ_I2P - - ELEMENTAL FUNCTION STRZ_I1P(N, NZ_PAD) RESULT(STR) - !< CONVERT INTEGER TO STRING, PREFIXING WITH THE RIGHT NUMBER OF ZEROS. - !< - !<```FORTRAN - !< USE PENF - !< PRINT "(A)", STRZ(N=1_I1P) - !<``` - !=> 001 <<< - !< - !<```FORTRAN - !< USE PENF - !< PRINT "(A)", STRZ(N=1_I1P, NZ_PAD=3) - !<``` - !=> 001 <<< - INTEGER(I1P), INTENT(IN) :: N !< INTEGER TO BE CONVERTED. - INTEGER(I4P), INTENT(IN), OPTIONAL :: NZ_PAD !< NUMBER OF ZEROS PADDING. - CHARACTER(DI1P) :: STR !< RETURNED STRING CONTAINING INPUT NUMBER PLUS PADDING ZEROS. - - WRITE(STR,FI1PZP) N ! CASTING OF N TO STRING. - STR=STR(2:) ! LEAVING OUT THE SIGN. - IF (PRESENT(NZ_PAD)) STR=STR(DI1P-NZ_PAD:DI1P-1) ! LEAVING OUT THE EXTRA ZEROS PADDING - ENDFUNCTION STRZ_I1P - - FUNCTION CTOR_R16P(STR, KND, PREF, ERROR) RESULT(N) - !< CONVERT STRING TO REAL. - !< - !<```FORTRAN - !< USE PENF - !< PRINT FR16P, CTON(STR='-1.0', KND=1._R16P) - !<``` - !=> -0.100000000000000000000000000000000E+0001 <<< - CHARACTER(*), INTENT(IN) :: STR !< STRING CONTAINING INPUT NUMBER. - REAL(R16P), INTENT(IN) :: KND !< NUMBER KIND. - CHARACTER(*), OPTIONAL, INTENT(IN) :: PREF !< PREFIXING STRING. - INTEGER(I4P), OPTIONAL, INTENT(OUT) :: ERROR !< ERROR TRAPPING FLAG: 0 NO ERRORS, >0 ERROR OCCURS. - REAL(R16P) :: N !< NUMBER RETURNED. - INTEGER(I4P) :: ERR !< ERROR TRAPPING FLAG: 0 NO ERRORS, >0 ERROR OCCURS. - CHARACTER(LEN=:), ALLOCATABLE :: PREFD !< PREFIXING STRING. - - READ(STR, *, IOSTAT=ERR) N ! CASTING OF STR TO N. - IF (ERR/=0) THEN - PREFD = '' ; IF (PRESENT(PREF)) PREFD = PREF - WRITE(STDERR, '(A,I1,A)') PREFD//' ERROR: CONVERSION OF STRING "'//STR//'" TO REAL FAILED! REAL(', KIND(KND), ')' - ENDIF - IF (PRESENT(ERROR)) ERROR = ERR - ENDFUNCTION CTOR_R16P - - FUNCTION CTOR_R8P(STR, KND, PREF, ERROR) RESULT(N) - !< CONVERT STRING TO REAL. - !< - !<```FORTRAN - !< USE PENF - !< PRINT FR8P, CTON(STR='-1.0', KND=1._R8P) - !<``` - !=> -0.100000000000000E+001 <<< - CHARACTER(*), INTENT(IN) :: STR !< STRING CONTAINING INPUT NUMBER. - REAL(R8P), INTENT(IN) :: KND !< NUMBER KIND. - CHARACTER(*), OPTIONAL, INTENT(IN) :: PREF !< PREFIXING STRING. - INTEGER(I4P), OPTIONAL, INTENT(OUT) :: ERROR !< ERROR TRAPPING FLAG: 0 NO ERRORS, >0 ERROR OCCURS. - REAL(R8P) :: N !< NUMBER RETURNED. - INTEGER(I4P) :: ERR !< ERROR TRAPPING FLAG: 0 NO ERRORS, >0 ERROR OCCURS. - CHARACTER(LEN=:), ALLOCATABLE :: PREFD !< PREFIXING STRING. - - READ(STR, *, IOSTAT=ERR) N ! CASTING OF STR TO N. - IF (ERR/=0) THEN - PREFD = '' ; IF (PRESENT(PREF)) PREFD = PREF - WRITE(STDERR, '(A,I1,A)') PREFD//' ERROR: CONVERSION OF STRING "'//STR//'" TO REAL FAILED! REAL(', KIND(KND), ')' - ENDIF - IF (PRESENT(ERROR)) ERROR = ERR - ENDFUNCTION CTOR_R8P - - FUNCTION CTOR_R4P(STR, KND, PREF, ERROR) RESULT(N) - !< CONVERT STRING TO REAL. - !< - !<```FORTRAN - !< USE PENF - !< PRINT FR4P, CTON(STR='-1.0', KND=1._R4P) - !<``` - !=> -0.100000E+01 <<< - CHARACTER(*), INTENT(IN) :: STR !< STRING CONTAINING INPUT NUMBER. - REAL(R4P), INTENT(IN) :: KND !< NUMBER KIND. - CHARACTER(*), OPTIONAL, INTENT(IN) :: PREF !< PREFIXING STRING. - INTEGER(I4P), OPTIONAL, INTENT(OUT) :: ERROR !< ERROR TRAPPING FLAG: 0 NO ERRORS, >0 ERROR OCCURS. - REAL(R4P) :: N !< NUMBER RETURNED. - INTEGER(I4P) :: ERR !< ERROR TRAPPING FLAG: 0 NO ERRORS, >0 ERROR OCCURS. - CHARACTER(LEN=:), ALLOCATABLE :: PREFD !< PREFIXING STRING. - - READ(STR, *, IOSTAT=ERR) N ! CASTING OF STR TO N. - IF (ERR/=0) THEN - PREFD = '' ; IF (PRESENT(PREF)) PREFD = PREF - WRITE(STDERR, '(A,I1,A)') PREFD//' ERROR: CONVERSION OF STRING "'//STR//'" TO REAL FAILED! REAL(', KIND(KND), ')' - ENDIF - IF (PRESENT(ERROR)) ERROR = ERR - ENDFUNCTION CTOR_R4P - - FUNCTION CTOI_I8P(STR, KND, PREF, ERROR) RESULT(N) - !< CONVERT STRING TO INTEGER. - !< - !<```FORTRAN - !< USE PENF - !< PRINT FI8P, CTON(STR='-1', KND=1_I8P) - !<``` - !=> -1 <<< - CHARACTER(*), INTENT(IN) :: STR !< STRING CONTAINING INPUT NUMBER. - INTEGER(I8P), INTENT(IN) :: KND !< NUMBER KIND. - CHARACTER(*), OPTIONAL, INTENT(IN) :: PREF !< PREFIXING STRING. - INTEGER(I4P), OPTIONAL, INTENT(OUT) :: ERROR !< ERROR TRAPPING FLAG: 0 NO ERRORS, >0 ERROR OCCURS. - INTEGER(I8P) :: N !< NUMBER RETURNED. - INTEGER(I4P) :: ERR !< ERROR TRAPPING FLAG: 0 NO ERRORS, >0 ERROR OCCURS. - CHARACTER(LEN=:), ALLOCATABLE :: PREFD !< PREFIXING STRING. - - READ(STR, *, IOSTAT=ERR) N ! CASTING OF STR TO N. - IF (ERR/=0) THEN - PREFD = '' ; IF (PRESENT(PREF)) PREFD = PREF - WRITE(STDERR, '(A,I1,A)') PREFD//' ERROR: CONVERSION OF STRING "'//STR//'" TO INTEGER FAILED! INTEGER(', KIND(KND), ')' - ENDIF - IF (PRESENT(ERROR)) ERROR = ERR - ENDFUNCTION CTOI_I8P - - FUNCTION CTOI_I4P(STR, KND, PREF, ERROR) RESULT(N) - !< CONVERT STRING TO INTEGER. - !< - !<```FORTRAN - !< USE PENF - !< PRINT FI4P, CTON(STR='-1', KND=1_I4P) - !<``` - !=> -1 <<< - CHARACTER(*), INTENT(IN) :: STR !< STRING CONTAINING INPUT NUMBER. - INTEGER(I4P), INTENT(IN) :: KND !< NUMBER KIND. - CHARACTER(*), OPTIONAL, INTENT(IN) :: PREF !< PREFIXING STRING. - INTEGER(I4P), OPTIONAL, INTENT(OUT) :: ERROR !< ERROR TRAPPING FLAG: 0 NO ERRORS, >0 ERROR OCCURS. - INTEGER(I4P) :: N !< NUMBER RETURNED. - INTEGER(I4P) :: ERR !< ERROR TRAPPING FLAG: 0 NO ERRORS, >0 ERROR OCCURS. - CHARACTER(LEN=:), ALLOCATABLE :: PREFD !< PREFIXING STRING. - - READ(STR, *, IOSTAT=ERR) N ! CASTING OF STR TO N. - IF (ERR/=0) THEN - PREFD = '' ; IF (PRESENT(PREF)) PREFD = PREF - WRITE(STDERR, '(A,I1,A)') PREFD//' ERROR: CONVERSION OF STRING "'//STR//'" TO INTEGER FAILED! INTEGER(', KIND(KND), ')' - ENDIF - IF (PRESENT(ERROR)) ERROR = ERR - ENDFUNCTION CTOI_I4P - - FUNCTION CTOI_I2P(STR, KND, PREF, ERROR) RESULT(N) - !< CONVERT STRING TO INTEGER. - !< - !<```FORTRAN - !< USE PENF - !< PRINT FI2P, CTON(STR='-1', KND=1_I2P) - !<``` - !=> -1 <<< - CHARACTER(*), INTENT(IN) :: STR !< STRING CONTAINING INPUT NUMBER. - INTEGER(I2P), INTENT(IN) :: KND !< NUMBER KIND. - CHARACTER(*), OPTIONAL, INTENT(IN) :: PREF !< PREFIXING STRING. - INTEGER(I4P), OPTIONAL, INTENT(OUT) :: ERROR !< ERROR TRAPPING FLAG: 0 NO ERRORS, >0 ERROR OCCURS. - INTEGER(I2P) :: N !< NUMBER RETURNED. - INTEGER(I4P) :: ERR !< ERROR TRAPPING FLAG: 0 NO ERRORS, >0 ERROR OCCURS. - CHARACTER(LEN=:), ALLOCATABLE :: PREFD !< PREFIXING STRING. - - READ(STR, *, IOSTAT=ERR) N ! CASTING OF STR TO N. - IF (ERR/=0) THEN - PREFD = '' ; IF (PRESENT(PREF)) PREFD = PREF - WRITE(STDERR, '(A,I1,A)') PREFD//' ERROR: CONVERSION OF STRING "'//STR//'" TO INTEGER FAILED! INTEGER(', KIND(KND), ')' - ENDIF - IF (PRESENT(ERROR)) ERROR = ERR - ENDFUNCTION CTOI_I2P - - FUNCTION CTOI_I1P(STR, KND, PREF, ERROR) RESULT(N) - !< CONVERT STRING TO INTEGER. - !< - !<```FORTRAN - !< USE PENF - !< PRINT FI1P, CTON(STR='-1', KND=1_I1P) - !<``` - !=> -1 <<< - CHARACTER(*), INTENT(IN) :: STR !< STRING CONTAINING INPUT NUMBER. - INTEGER(I1P), INTENT(IN) :: KND !< NUMBER KIND. - CHARACTER(*), OPTIONAL, INTENT(IN) :: PREF !< PREFIXING STRING. - INTEGER(I4P), OPTIONAL, INTENT(OUT) :: ERROR !< ERROR TRAPPING FLAG: 0 NO ERRORS, >0 ERROR OCCURS. - INTEGER(I1P) :: N !< NUMBER RETURNED. - INTEGER(I4P) :: ERR !< ERROR TRAPPING FLAG: 0 NO ERRORS, >0 ERROR OCCURS. - CHARACTER(LEN=:), ALLOCATABLE :: PREFD !< PREFIXING STRING. - - READ(STR, *, IOSTAT=ERR) N ! CASTING OF STR TO N. - IF (ERR/=0) THEN - PREFD = '' ; IF (PRESENT(PREF)) PREFD = PREF - WRITE(STDERR, '(A,I1,A)') PREFD//' ERROR: CONVERSION OF STRING "'//STR//'" TO INTEGER FAILED! INTEGER(', KIND(KND), ')' - ENDIF - IF (PRESENT(ERROR)) ERROR = ERR - ENDFUNCTION CTOI_I1P - - ELEMENTAL FUNCTION BSTR_R16P(N) RESULT(BSTR) - !< CONVERT REAL TO STRING OF BITS. - !< - !< @NOTE IT IS ASSUMED THAT R16P IS REPRESENTED BY MEANS OF 128 BITS, BUT THIS IS NOT ENSURED IN ALL ARCHITECTURES. - !< - !<```FORTRAN - !< USE PENF - !< CHARACTER(128) :: B - !< B = BSTR(N=1._R16P) - !< PRINT "(A)", B(17:) - !<``` - !=> 0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001111111100111111 <<< - REAL(R16P), INTENT(IN) :: N !< REAL TO BE CONVERTED. - CHARACTER(128) :: BSTR !< RETURNED BIT-STRING CONTAINING INPUT NUMBER. - INTEGER(I1P) :: BUFFER(16) !< TRANSFER BUFFER. - - BUFFER = TRANSFER(N, BUFFER) - WRITE(BSTR, '(16B8.8)') BUFFER - ENDFUNCTION BSTR_R16P - - ELEMENTAL FUNCTION BSTR_R8P(N) RESULT(BSTR) - !< CONVERT REAL TO STRING OF BITS. - !< - !< @NOTE IT IS ASSUMED THAT R8P IS REPRESENTED BY MEANS OF 64 BITS, BUT THIS IS NOT ENSURED IN ALL ARCHITECTURES. - !< - !<```FORTRAN - !< USE PENF - !< PRINT "(A)", BSTR(N=1._R8P) - !<``` - !=> 0000000000000000000000000000000000000000000000001111000000111111 <<< - REAL(R8P), INTENT(IN) :: N !< REAL TO BE CONVERTED. - CHARACTER(64) :: BSTR !< RETURNED BIT-STRING CONTAINING INPUT NUMBER. - INTEGER(I1P) :: BUFFER(8) !< TRANSFER BUFFER. - - BUFFER = TRANSFER(N, BUFFER) - WRITE(BSTR, '(8B8.8)') BUFFER - ENDFUNCTION BSTR_R8P - - ELEMENTAL FUNCTION BSTR_R4P(N) RESULT(BSTR) - !< CONVERT REAL TO STRING OF BITS. - !< - !< @NOTE IT IS ASSUMED THAT R4P IS REPRESENTED BY MEANS OF 32 BITS, BUT THIS IS NOT ENSURED IN ALL ARCHITECTURES. - !< - !<```FORTRAN - !< USE PENF - !< PRINT "(A)", BSTR(N=1._R4P) - !<``` - !=> 00000000000000001000000000111111 <<< - REAL(R4P), INTENT(IN) :: N !< REAL TO BE CONVERTED. - CHARACTER(32) :: BSTR !< RETURNED BIT-STRING CONTAINING INPUT NUMBER. - INTEGER(I1P) :: BUFFER(4) !< TRANSFER BUFFER. - - BUFFER = TRANSFER(N, BUFFER) - WRITE(BSTR, '(4B8.8)') BUFFER - ENDFUNCTION BSTR_R4P - - ELEMENTAL FUNCTION BSTR_I8P(N) RESULT(BSTR) - !< CONVERT INTEGER TO STRING OF BITS. - !< - !< @NOTE IT IS ASSUMED THAT I8P IS REPRESENTED BY MEANS OF 64 BITS, BUT THIS IS NOT ENSURED IN ALL ARCHITECTURES. - !< - !<```FORTRAN - !< USE PENF - !< PRINT "(A)", BSTR(N=1_I8P) - !<``` - !=> 0000000000000000000000000000000000000000000000000000000000000001 <<< - INTEGER(I8P), INTENT(IN) :: N !< REAL TO BE CONVERTED. - CHARACTER(64) :: BSTR !< RETURNED BIT-STRING CONTAINING INPUT NUMBER. - - WRITE(BSTR, '(B64.64)') N - ENDFUNCTION BSTR_I8P - - ELEMENTAL FUNCTION BSTR_I4P(N) RESULT(BSTR) - !< CONVERT INTEGER TO STRING OF BITS. - !< - !< @NOTE IT IS ASSUMED THAT I4P IS REPRESENTED BY MEANS OF 32 BITS, BUT THIS IS NOT ENSURED IN ALL ARCHITECTURES. - !< - !<```FORTRAN - !< USE PENF - !< PRINT "(A)", BSTR(N=1_I4P) - !<``` - !=> 00000000000000000000000000000001 <<< - INTEGER(I4P), INTENT(IN) :: N !< REAL TO BE CONVERTED. - CHARACTER(32) :: BSTR !< RETURNED BIT-STRING CONTAINING INPUT NUMBER. - - WRITE(BSTR, '(B32.32)') N - ENDFUNCTION BSTR_I4P - - ELEMENTAL FUNCTION BSTR_I2P(N) RESULT(BSTR) - !< CONVERT INTEGER TO STRING OF BITS. - !< - !< @NOTE IT IS ASSUMED THAT I2P IS REPRESENTED BY MEANS OF 16 BITS, BUT THIS IS NOT ENSURED IN ALL ARCHITECTURES. - !< - !<```FORTRAN - !< USE PENF - !< PRINT "(A)", BSTR(N=1_I2P) - !<``` - !=> 0000000000000001 <<< - INTEGER(I2P), INTENT(IN) :: N !< REAL TO BE CONVERTED. - CHARACTER(16) :: BSTR !< RETURNED BIT-STRING CONTAINING INPUT NUMBER. - - WRITE(BSTR, '(B16.16)') N - ENDFUNCTION BSTR_I2P - - ELEMENTAL FUNCTION BSTR_I1P(N) RESULT(BSTR) - !< CONVERT INTEGER TO STRING OF BITS. - !< - !< @NOTE IT IS ASSUMED THAT I1P IS REPRESENTED BY MEANS OF 8 BITS, BUT THIS IS NOT ENSURED IN ALL ARCHITECTURES. - !< - !<```FORTRAN - !< USE PENF - !< PRINT "(A)", BSTR(N=1_I1P) - !<``` - !=> 00000001 <<< - INTEGER(I1P), INTENT(IN) :: N !< REAL TO BE CONVERTED. - CHARACTER(8) :: BSTR !< RETURNED BIT-STRING CONTAINING INPUT NUMBER. - - WRITE(BSTR, '(B8.8)') N - ENDFUNCTION BSTR_I1P - - ELEMENTAL FUNCTION BCTOR_R16P(BSTR, KND) RESULT(N) - !< CONVERT BIT-STRING TO REAL. - !< - !<```FORTRAN - !< USE PENF - !< PRINT FR16P, BCTON('00000000000000000000000000000000000000000000000000000000000000000000000000000'//& - !< '000000000000000000000000000000000001111111100111111', KND=1._R16P) - !<``` - !=> 0.100000000000000000000000000000000E+0001 <<< - CHARACTER(*), INTENT(IN) :: BSTR !< STRING CONTAINING INPUT NUMBER. - REAL(R16P), INTENT(IN) :: KND !< NUMBER KIND. - REAL(R16P) :: N !< NUMBER RETURNED. - INTEGER(I1P) :: BUFFER(16) !< TRANSFER BUFFER. - - READ(BSTR, '(16B8.8)') BUFFER - N = TRANSFER(BUFFER, N) - ENDFUNCTION BCTOR_R16P - - ELEMENTAL FUNCTION BCTOR_R8P(BSTR, KND) RESULT(N) - !< CONVERT BIT-STRING TO REAL. - !< - !<```FORTRAN - !< USE PENF - !< PRINT FR8P, BCTON('0000000000000000000000000000000000000000000000001111000000111111', KND=1._R8P) - !<``` - !=> 0.100000000000000E+001 <<< - CHARACTER(*), INTENT(IN) :: BSTR !< STRING CONTAINING INPUT NUMBER. - REAL(R8P), INTENT(IN) :: KND !< NUMBER KIND. - REAL(R8P) :: N !< NUMBER RETURNED. - INTEGER(I1P) :: BUFFER(8) !< TRANSFER BUFFER. - - READ(BSTR, '(8B8.8)') BUFFER - N = TRANSFER(BUFFER, N) - ENDFUNCTION BCTOR_R8P - - ELEMENTAL FUNCTION BCTOR_R4P(BSTR, KND) RESULT(N) - !< CONVERT BIT-STRING TO REAL. - !< - !<```FORTRAN - !< USE PENF - !< PRINT FR4P, BCTON('00000000000000001000000000111111', KND=1._R4P) - !<``` - !=> 0.100000E+01 <<< - CHARACTER(*), INTENT(IN) :: BSTR !< STRING CONTAINING INPUT NUMBER. - REAL(R4P), INTENT(IN) :: KND !< NUMBER KIND. - REAL(R4P) :: N !< NUMBER RETURNED. - INTEGER(I1P) :: BUFFER(4) !< TRANSFER BUFFER. - - READ(BSTR, '(4B8.8)') BUFFER - N = TRANSFER(BUFFER, N) - ENDFUNCTION BCTOR_R4P - - ELEMENTAL FUNCTION BCTOI_I8P(BSTR, KND) RESULT(N) - !< CONVERT BIT-STRING TO INTEGER. - !< - !<```FORTRAN - !< USE PENF - !< PRINT FI8P, BCTON('0000000000000000000000000000000000000000000000000000000000000001', KND=1_I8P) - !<``` - !=> 1 <<< - CHARACTER(*), INTENT(IN) :: BSTR !< STRING CONTAINING INPUT NUMBER. - INTEGER(I8P), INTENT(IN) :: KND !< NUMBER KIND. - INTEGER(I8P) :: N !< NUMBER RETURNED. - - READ(BSTR,'(B'//TRIM(STR(BIT_SIZE(KND), .TRUE.))//'.'//TRIM(STR(BIT_SIZE(KND), .TRUE.))//')') N - ENDFUNCTION BCTOI_I8P - - ELEMENTAL FUNCTION BCTOI_I4P(BSTR, KND) RESULT(N) - !< CONVERT BIT-STRING TO INTEGER. - !< - !<```FORTRAN - !< USE PENF - !< PRINT FI4P, BCTON('00000000000000000000000000000001', KND=1_I4P) - !<``` - !=> 1 <<< - CHARACTER(*), INTENT(IN) :: BSTR !< STRING CONTAINING INPUT NUMBER. - INTEGER(I4P), INTENT(IN) :: KND !< NUMBER KIND. - INTEGER(I4P) :: N !< NUMBER RETURNED. - - READ(BSTR,'(B'//TRIM(STR(BIT_SIZE(KND), .TRUE.))//'.'//TRIM(STR(BIT_SIZE(KND), .TRUE.))//')') N - ENDFUNCTION BCTOI_I4P - - ELEMENTAL FUNCTION BCTOI_I2P(BSTR, KND) RESULT(N) - !< CONVERT BIT-STRING TO INTEGER. - !< - !<```FORTRAN - !< USE PENF - !< PRINT FI2P, BCTON('0000000000000001', KND=1_I2P) - !<``` - !=> 1 <<< - CHARACTER(*), INTENT(IN) :: BSTR !< STRING CONTAINING INPUT NUMBER. - INTEGER(I2P), INTENT(IN) :: KND !< NUMBER KIND. - INTEGER(I2P) :: N !< NUMBER RETURNED. - - READ(BSTR,'(B'//TRIM(STR(BIT_SIZE(KND), .TRUE.))//'.'//TRIM(STR(BIT_SIZE(KND), .TRUE.))//')') N - ENDFUNCTION BCTOI_I2P - - ELEMENTAL FUNCTION BCTOI_I1P(BSTR, KND) RESULT(N) - !< CONVERT BIT-STRING TO INTEGER. - !< - !<```FORTRAN - !< USE PENF - !< PRINT FI1P, BCTON('00000001', KND=1_I1P) - !<``` - !=> 1 <<< - CHARACTER(*), INTENT(IN) :: BSTR !< STRING CONTAINING INPUT NUMBER. - INTEGER(I1P), INTENT(IN) :: KND !< NUMBER KIND. - INTEGER(I1P) :: N !< NUMBER RETURNED. - READ(BSTR,'(B'//TRIM(STR(BIT_SIZE(KND), .TRUE.))//'.'//TRIM(STR(BIT_SIZE(KND), .TRUE.))//')') N - ENDFUNCTION BCTOI_I1P ENDMODULE PENF_STRINGIFY @@ -1819,7 +1171,7 @@ MODULE PENF #else USE PENF_B_SIZE, ONLY : BIT_SIZE, BYTE_SIZE #endif -USE PENF_STRINGIFY, ONLY : STR_ASCII, STR_UCS4, STR, STRZ, CTON, BSTR, BCTON +USE PENF_STRINGIFY, ONLY : STR IMPLICIT NONE PRIVATE @@ -1841,9 +1193,7 @@ MODULE PENF ! BIT/BYTE SIZE FUNCTIONS PUBLIC :: BIT_SIZE, BYTE_SIZE ! STRINGIFY FACILITY -PUBLIC :: STR_ASCII, STR_UCS4 -PUBLIC :: STR, STRZ, CTON -PUBLIC :: BSTR, BCTON +PUBLIC :: STR ! MISCELLANEA FACILITY PUBLIC :: CHECK_ENDIAN PUBLIC :: DIGIT @@ -19295,7 +18645,7 @@ MODULE VTK_FDS_INTERFACE IMPLICIT NONE (TYPE,EXTERNAL) PRIVATE -PUBLIC WRITE_VTK_SLICE_WRAPPER,BUILD_VTK_GAS_PHASE_GEOMETRY,& +PUBLIC WRITE_VTK_SLICE_WRAPPER,BUILD_VTK_GAS_PHASE_GEOMETRY,BUILD_VTK_SOLID_PHASE_GEOMETRY,& WRITE_VTK_SL3D_WRAPPER,WRITE_VTK_SM3D_WRAPPER,& DEALLOCATE_VTK_GAS_PHASE_GEOMETRY @@ -19484,14 +18834,14 @@ END SUBROUTINE WRITE_VTK_SM3D_WRAPPER -SUBROUTINE BUILD_VTK_GAS_PHASE_GEOMETRY(NM, MESH_TOPOLOGY, FN, & +SUBROUTINE BUILD_VTK_GAS_PHASE_GEOMETRY(NM, MESH_TOPOLOGY, & NC, NP, X_PTS, Y_PTS, Z_PTS, CONNECT, OFFSETS, VTKC_TYPE) INTEGER :: NX, NY, NZ, NC, NP, I, J, K, IFACT, JFACT, KFACT REAL(FB), ALLOCATABLE, DIMENSION(:) :: X_PTS, Y_PTS, Z_PTS INTEGER(IB32), ALLOCATABLE, DIMENSION(:) :: CONNECT, OFFSETS INTEGER(IB8), ALLOCATABLE, DIMENSION(:) :: VTKC_TYPE -CHARACTER(LEN=*), INTENT(IN) :: MESH_TOPOLOGY, FN +CHARACTER(LEN=*), INTENT(IN) :: MESH_TOPOLOGY INTEGER, INTENT(IN) :: NM NX = SIZE(MESHES(NM)%X) @@ -19548,14 +18898,92 @@ SUBROUTINE BUILD_VTK_GAS_PHASE_GEOMETRY(NM, MESH_TOPOLOGY, FN, & ENDSUBROUTINE BUILD_VTK_GAS_PHASE_GEOMETRY +SUBROUTINE BUILD_VTK_SOLID_PHASE_GEOMETRY(NM, PA, MESH_TOPOLOGY, & + NCELLS, NPOINTS, X_PTS, Y_PTS, Z_PTS, CONNECT, OFFSETS, VTKC_TYPE) + +INTEGER :: NX,NY,NZ,NCELLS,NPOINTS,I,J,K,IFACT,JFACT,KFACT,L,L1,L2,N,N1,N2 +REAL(FB), ALLOCATABLE, DIMENSION(:) :: X_PTS, Y_PTS, Z_PTS +INTEGER(IB32), ALLOCATABLE, DIMENSION(:) :: CONNECT, OFFSETS +INTEGER(IB8), ALLOCATABLE, DIMENSION(:) :: VTKC_TYPE +CHARACTER(LEN=*), INTENT(IN) :: MESH_TOPOLOGY +INTEGER, INTENT(IN) :: NM +TYPE(PATCH_TYPE), POINTER, INTENT(IN) :: PA + +! Fill point data +SELECT CASE(ABS(PA%IOR)) + CASE(1) ; L1=PA%JG1 ; L2=PA%JG2 ; N1=PA%KG1 ; N2=PA%KG2 ; NX=1; NY=(L2-L1); NZ=(N2-N1) + CASE(2) ; L1=PA%IG1 ; L2=PA%IG2 ; N1=PA%KG1 ; N2=PA%KG2 ; NX=(L2-L1); NY=1; NZ=(N2-N1) + CASE(3) ; L1=PA%IG1 ; L2=PA%IG2 ; N1=PA%JG1 ; N2=PA%JG2 ; NX=(L2-L1); NY=(N2-N1); NZ=1 +END SELECT +NPOINTS = (L2-L1+2)*(N2-N1+2) +NCELLS = (L2-L1+1)*(N2-N1+1) +ALLOCATE(X_PTS(NPOINTS)) +ALLOCATE(Y_PTS(NPOINTS)) +ALLOCATE(Z_PTS(NPOINTS)) +ALLOCATE(CONNECT(NCELLS*4)) +ALLOCATE(OFFSETS(NCELLS)) +ALLOCATE(VTKC_TYPE(NCELLS)) +IFACT = 1 +SELECT CASE(ABS(PA%IOR)) + CASE(1) + DO K = PA%K1,PA%K2 + DO J = PA%J1,PA%J2 + X_PTS(IFACT)=MESHES(NM)%X(PA%I1) + Y_PTS(IFACT)=MESHES(NM)%Y(J) + Z_PTS(IFACT)=MESHES(NM)%Z(K) + IFACT = IFACT + 1 + ENDDO + ENDDO + CASE(2) + DO K = PA%K1,PA%K2 + DO I = PA%I1,PA%I2 + X_PTS(IFACT)=MESHES(NM)%X(I) + Y_PTS(IFACT)=MESHES(NM)%Y(PA%J1) + Z_PTS(IFACT)=MESHES(NM)%Z(K) + IFACT = IFACT + 1 + ENDDO + ENDDO + CASE(3) + DO J = PA%J1,PA%J2 + DO I = PA%I1,PA%I2 + X_PTS(IFACT)=MESHES(NM)%X(I) + Y_PTS(IFACT)=MESHES(NM)%Y(J) + Z_PTS(IFACT)=MESHES(NM)%Z(PA%K1) + IFACT = IFACT + 1 + ENDDO + ENDDO +END SELECT + +! Fill cell data + +IFACT = 0 +DO I = 1, (L2-L1+1) + DO J = 1, (N2-N1+1) + CONNECT((IFACT)*4+1) = (L2-L1+2)*(J-1)+(I-1) + CONNECT((IFACT)*4+2) = (L2-L1+2)*(J-1)+(I) + CONNECT((IFACT)*4+3) = (L2-L1+2)*(J)+(I-1) + CONNECT((IFACT)*4+4) = (L2-L1+2)*(J)+(I) + IFACT = IFACT+1 + ENDDO +ENDDO + +DO I=1,NCELLS + OFFSETS(I) = (I)*4_IB32 + VTKC_TYPE(I) = 8_IB8 +ENDDO + +ENDSUBROUTINE BUILD_VTK_SOLID_PHASE_GEOMETRY + + SUBROUTINE DEALLOCATE_VTK_GAS_PHASE_GEOMETRY(X_PTS,Y_PTS,Z_PTS,OFFSETS,VTKC_TYPE,CONNECT) REAL(FB), DIMENSION(:), ALLOCATABLE :: X_PTS, Y_PTS, Z_PTS INTEGER(IB32), DIMENSION(:), ALLOCATABLE :: CONNECT, OFFSETS INTEGER(IB8), DIMENSION(:), ALLOCATABLE :: VTKC_TYPE -DEALLOCATE(OFFSETS) + DEALLOCATE(VTKC_TYPE) +DEALLOCATE(OFFSETS) DEALLOCATE(CONNECT) DEALLOCATE(X_PTS) DEALLOCATE(Y_PTS) From 19aafcf561c13773a587c996f8c6ba815f3d956d Mon Sep 17 00:00:00 2001 From: Jonathan Hodges <johodges@vt.edu> Date: Sat, 6 Jan 2024 11:23:40 -0500 Subject: [PATCH 23/31] add GEOM boundary VTK output --- Source/dump.f90 | 110 +++++++++++++++++++++++++++++++++++++++++++++--- Source/vtkf.f90 | 45 +++++++++++++++++++- 2 files changed, 148 insertions(+), 7 deletions(-) diff --git a/Source/dump.f90 b/Source/dump.f90 index 2d4748899a8..3acb8aaf3d0 100644 --- a/Source/dump.f90 +++ b/Source/dump.f90 @@ -20,7 +20,7 @@ MODULE DUMP USE CC_SCALARS, ONLY : ADD_Q_DOT_CUTCELLS,GET_PRES_CFACE,GET_PRES_CFACE_TEST,GET_UVWGAS_CFACE,GET_MUDNS_CFACE USE VTK_FDS_INTERFACE, ONLY : WRITE_VTK_SLICE_WRAPPER,BUILD_VTK_GAS_PHASE_GEOMETRY,BUILD_VTK_SOLID_PHASE_GEOMETRY,& - WRITE_VTK_SM3D_WRAPPER,WRITE_VTK_SL3D_WRAPPER,DEALLOCATE_VTK_GAS_PHASE_GEOMETRY + WRITE_VTK_SM3D_WRAPPER,WRITE_VTK_SL3D_WRAPPER,DEALLOCATE_VTK_GAS_PHASE_GEOMETRY,BUILD_VTK_GEOM_GEOMETRY USE VTK_FORTRAN, ONLY : VTK_FILE, PVTK_FILE IMPLICIT NONE (TYPE,EXTERNAL) @@ -1493,7 +1493,7 @@ SUBROUTINE WRITE_STL_FILE XB(:) = (/OB%X1,OB%X2,OB%Y1,OB%Y2,OB%Z1,OB%Z2/) !COLOR(:) = OB%SURF_INDEX(-1),OB%SURF_INDEX(1),OB%SURF_INDEX(-2),& !OB%SURF_INDEX(2),OB%SURF_INDEX(-3),OB%SURF_INDEX(3) - VERTICES = get_vertices(XB) + VERTICES = GET_VERTICES(XB) DO I=1,12 !CALL write_facet_c(U, & @@ -10750,19 +10750,20 @@ SUBROUTINE DUMP_BNDF(T,DT,NM,IFRMT) REAL(EB), INTENT(IN) :: T,DT REAL(FB) :: STIME, BOUND_MIN, BOUND_MAX, BF_FACTOR INTEGER :: ISUM,NF,IND,I,J,K,IC,IW,L,L1,L2,N,N1,N2,IP,NC,I1,I2,J1,J2,K1,K2,ITM,ITM1 -INTEGER :: NBF_DEBUG,IFACT +INTEGER :: NBF_DEBUG,IFACT,NFACES_CUTCELLS,NVERTS_CUTCELLS,NVERTS,NFACES INTEGER, INTENT(IN) :: NM,IFRMT TYPE(PATCH_TYPE), POINTER :: PA REAL(FB) BNDF_TIME, BNDF_VAL_MIN, BNDF_VAL_MAX INTEGER :: CHANGE_BOUND, IERROR INTEGER :: NX, NY, NZ, NCELLS, NPOINTS +INTEGER, ALLOCATABLE, DIMENSION(:) :: LOCATIONS,FACES,SURFIND,GEOMIND +REAL(FB), ALLOCATABLE, DIMENSION(:) :: VALS, VERTS REAL(FB), ALLOCATABLE, DIMENSION(:) :: QQ_PACK REAL(FB), ALLOCATABLE, DIMENSION(:) :: X_PTS, Y_PTS, Z_PTS INTEGER(IB32), ALLOCATABLE, DIMENSION(:) :: CONNECT, OFFSETS INTEGER(IB8), ALLOCATABLE, DIMENSION(:) :: VTKC_TYPE TYPE(VTK_FILE) :: A_VTK_FILE ! A VTK file. INTEGER(IB8) :: VTK_ERROR=0_IB8 !< IO Error status. -LOGICAL :: VTK_INITIALIZED IF (MESHES(NM)%N_PATCH==0 .AND. MESHES(NM)%N_INTERNAL_CFACE_CELLS==0) RETURN @@ -10981,7 +10982,6 @@ SUBROUTINE DUMP_BNDF(T,DT,NM,IFRMT) VTK_ERROR = A_VTK_FILE%XML_WRITER%WRITE_PIECE(NP=NPOINTS, NC=NCELLS) VTK_ERROR = A_VTK_FILE%XML_WRITER%WRITE_GEO(NP=NPOINTS, NC=NCELLS, X=X_PTS, Y=Y_PTS, Z=Z_PTS) VTK_ERROR = A_VTK_FILE%XML_WRITER%WRITE_CONNECTIVITY(NC=NCELLS, CONNECTIVITY=CONNECT, OFFSET=OFFSETS, VTKC_TYPE=VTKC_TYPE) - VTK_INITIALIZED=.TRUE. CALL DEALLOCATE_VTK_GAS_PHASE_GEOMETRY(X_PTS,Y_PTS,Z_PTS,OFFSETS,VTKC_TYPE,CONNECT) ! Loop through cell centered = F @@ -11021,6 +11021,55 @@ SUBROUTINE DUMP_BNDF(T,DT,NM,IFRMT) VTK_ERROR = A_VTK_FILE%XML_WRITER%W_DATA(LOCATION='CELL', ACTION='CLOSE') VTK_ERROR = A_VTK_FILE%XML_WRITER%WRITE_PIECE() ENDDO PATCH_LOOP1 + + IF (CC_IBM) THEN + CALL POINT_TO_MESH(NM) + CALL GET_GEOMSIZES('INBOUND_FACES',0,0,0,0,0,0,NVERTS,NVERTS_CUTCELLS,NFACES,NFACES_CUTCELLS) + IF (NVERTS>0 .AND. NFACES>0) THEN + ALLOCATE(VERTS(3*NVERTS)) + ALLOCATE(FACES(3*NFACES)) + ALLOCATE(LOCATIONS(NFACES)) + ALLOCATE(SURFIND(NFACES)) + ALLOCATE(GEOMIND(NFACES)) + CALL GET_GEOMINFO('INBOUND_FACES',0,0,0,0,0,0,NVERTS,NVERTS_CUTCELLS,NFACES,NFACES_CUTCELLS,& + VERTS,FACES,LOCATIONS,SURFIND=SURFIND,GEOMIND=GEOMIND) + CALL BUILD_VTK_GEOM_GEOMETRY(VERTS, FACES, NCELLS, NPOINTS, X_PTS, Y_PTS, Z_PTS, CONNECT, OFFSETS, VTKC_TYPE) + DEALLOCATE(VERTS) + DEALLOCATE(FACES) + DEALLOCATE(LOCATIONS) + DEALLOCATE(SURFIND) + DEALLOCATE(GEOMIND) + + VTK_ERROR = A_VTK_FILE%XML_WRITER%WRITE_PIECE(NP=NPOINTS, NC=NCELLS) + VTK_ERROR = A_VTK_FILE%XML_WRITER%WRITE_GEO(NP=NPOINTS, NC=NCELLS, X=X_PTS, Y=Y_PTS, Z=Z_PTS) + VTK_ERROR = A_VTK_FILE%XML_WRITER%WRITE_CONNECTIVITY(NC=NCELLS, CONNECTIVITY=CONNECT, OFFSET=OFFSETS, VTKC_TYPE=VTKC_TYPE) + + CALL DEALLOCATE_VTK_GAS_PHASE_GEOMETRY(X_PTS,Y_PTS,Z_PTS,OFFSETS,VTKC_TYPE,CONNECT) + + ! Loop through cell centered = F + VTK_ERROR = A_VTK_FILE%XML_WRITER%W_DATA(LOCATION='NODE', ACTION='OPEN') + FILE_LOOPC: DO NF=1,N_BNDF + IF (BF%CELL_CENTERED) CYCLE FILE_LOOPC + BF => BOUNDARY_FILE(NF) + CALL PACK_VTK_GEOM(NM, BF%CELL_CENTERED, BF, VALS) + VTK_ERROR = A_VTK_FILE%XML_WRITER%W_DATA(DATA_NAME=BF%SMOKEVIEW_LABEL(1:30), X=VALS) + DEALLOCATE(VALS) + ENDDO FILE_LOOPC + VTK_ERROR = A_VTK_FILE%XML_WRITER%W_DATA(LOCATION='NODE', ACTION='CLOSE') + + ! Loop through cell centered = T + VTK_ERROR = A_VTK_FILE%XML_WRITER%W_DATA(LOCATION='CELL', ACTION='OPEN') + FILE_LOOPD: DO NF=1,N_BNDF + IF (.NOT.BF%CELL_CENTERED) CYCLE FILE_LOOPD + BF => BOUNDARY_FILE(NF) + CALL PACK_VTK_GEOM(NM, BF%CELL_CENTERED, BF, VALS) + VTK_ERROR = A_VTK_FILE%XML_WRITER%W_DATA(DATA_NAME=BF%SMOKEVIEW_LABEL(1:30), X=VALS) + DEALLOCATE(VALS) + ENDDO FILE_LOOPD + VTK_ERROR = A_VTK_FILE%XML_WRITER%W_DATA(LOCATION='CELL', ACTION='CLOSE') + VTK_ERROR = A_VTK_FILE%XML_WRITER%WRITE_PIECE() + ENDIF + ENDIF VTK_ERROR = A_VTK_FILE%FINALIZE() ENDIF @@ -11131,7 +11180,56 @@ SUBROUTINE PACK_VTK_BNDF(PA,BF,IND,PP,PPN,QQ_PACK) ENDIF END SUBROUTINE PACK_VTK_BNDF - + + SUBROUTINE PACK_VTK_GEOM(NM,CELL_CENTERED,BF,VALS) + INTEGER, INTENT(IN) :: NM + LOGICAL, INTENT(IN) :: CELL_CENTERED + TYPE(BOUNDARY_FILE_TYPE), POINTER, INTENT(IN) :: BF + REAL(FB), ALLOCATABLE, DIMENSION(:) :: VALS, VERTS, VERT_VALS + INTEGER, ALLOCATABLE, DIMENSION(:) :: FACES, VERT_UNIQUE + INTEGER :: I, IND + INTEGER :: NPOINTS, NCELLS, NFACES, NVERTS, NVALS + + IND = ABS(BF%INDEX) + CALL POINT_TO_MESH(NM) + CALL GET_GEOMSIZES('INBOUND_FACES',0,0,0,0,0,0,NVERTS,NVERTS_CUTCELLS,NFACES,NFACES_CUTCELLS) + + IF (CELL_CENTERED) THEN + NVALS = NFACES + ALLOCATE(VALS(NFACES)) + ! get values at geometry faces + CALL GET_GEOMVALS(CELL_CENTERED,CELL_CENTERED,'INBOUND_FACES',& + I1,I2,J1,J2,K1,K2,NFACES,NFACES_CUTCELLS,VALS,& + IND,0,BF%Y_INDEX,BF%Z_INDEX,BF%PART_INDEX,0,0,BF%PROP_INDEX,0,0,T,DT,NM) + ELSE + NVALS = NVERTS + ALLOCATE(VALS(MAX(NVERTS,NFACES))) + + ! get values at geometry nodes + ALLOCATE(VERTS(3*NVERTS)) + ALLOCATE(FACES(3*NFACES)) + ALLOCATE(LOCATIONS(NFACES)) + ALLOCATE(VERT_UNIQUE(NVERTS)) + ALLOCATE(VERT_VALS(NVERTS)) + + CALL GET_GEOMVALS(CELL_CENTERED,CELL_CENTERED,'INBOUND_FACES',& + I1,I2,J1,J2,K1,K2,NFACES,NFACES_CUTCELLS,VALS,& + IND,0,BF%Y_INDEX,BF%Z_INDEX,BF%PART_INDEX,0,0,BF%PROP_INDEX,0,0,T,DT,NM) + + ! these two routines need to be moved and called only once + CALL GET_GEOMINFO('INBOUND_FACES',I1,I2,J1,J2,K1,K2,NVERTS,NVERTS_CUTCELLS,NFACES,NFACES_CUTCELLS,VERTS,FACES,LOCATIONS) + CALL MAKE_UNIQUE_VERT_ARRAY(VERTS, VERT_UNIQUE, NVERTS) + + CALL AVERAGE_FACE_VALUES(VERT_UNIQUE, VERT_VALS, NVERTS, FACES, VALS, NFACES) + VALS(1:NVERTS) = VERT_VALS(1:NVERTS) + + DEALLOCATE(VERTS) + DEALLOCATE(FACES) + DEALLOCATE(LOCATIONS) + DEALLOCATE(VERT_UNIQUE) + DEALLOCATE(VERT_VALS) + ENDIF + END SUBROUTINE PACK_VTK_GEOM END SUBROUTINE DUMP_BNDF diff --git a/Source/vtkf.f90 b/Source/vtkf.f90 index 73b3e802135..96b43fafcd6 100644 --- a/Source/vtkf.f90 +++ b/Source/vtkf.f90 @@ -18647,7 +18647,7 @@ MODULE VTK_FDS_INTERFACE PUBLIC WRITE_VTK_SLICE_WRAPPER,BUILD_VTK_GAS_PHASE_GEOMETRY,BUILD_VTK_SOLID_PHASE_GEOMETRY,& WRITE_VTK_SL3D_WRAPPER,WRITE_VTK_SM3D_WRAPPER,& - DEALLOCATE_VTK_GAS_PHASE_GEOMETRY + DEALLOCATE_VTK_GAS_PHASE_GEOMETRY,BUILD_VTK_GEOM_GEOMETRY CONTAINS @@ -18975,6 +18975,49 @@ SUBROUTINE BUILD_VTK_SOLID_PHASE_GEOMETRY(NM, PA, MESH_TOPOLOGY, & ENDSUBROUTINE BUILD_VTK_SOLID_PHASE_GEOMETRY +SUBROUTINE BUILD_VTK_GEOM_GEOMETRY(VERTS, FACES, NCELLS, NPOINTS,& + X_PTS, Y_PTS, Z_PTS, CONNECT, OFFSETS, VTKC_TYPE) + +!INTEGER :: NX,NY,NZ,NCELLS,NPOINTS,I,J,K,IFACT,JFACT,KFACT,L,L1,L2,N,N1,N2 + +REAL(FB), ALLOCATABLE, DIMENSION(:), INTENT(IN) :: VERTS +INTEGER, ALLOCATABLE, DIMENSION(:), INTENT(IN) :: FACES +REAL(FB), ALLOCATABLE, DIMENSION(:) :: X_PTS, Y_PTS, Z_PTS +INTEGER(IB32), ALLOCATABLE, DIMENSION(:) :: CONNECT, OFFSETS +INTEGER(IB8), ALLOCATABLE, DIMENSION(:) :: VTKC_TYPE +INTEGER :: I +INTEGER :: NPOINTS, NCELLS, NFACES + +NPOINTS = SIZE(VERTS)/3 +NCELLS = SIZE(FACES)/3 +NFACES = SIZE(FACES) + +ALLOCATE(X_PTS(NPOINTS)) +ALLOCATE(Y_PTS(NPOINTS)) +ALLOCATE(Z_PTS(NPOINTS)) +ALLOCATE(CONNECT(NCELLS*3)) +ALLOCATE(OFFSETS(NCELLS)) +ALLOCATE(VTKC_TYPE(NCELLS)) + +DO I=1,NPOINTS + X_PTS(I) = VERTS((I-1)*3+1) + Y_PTS(I) = VERTS((I-1)*3+2) + Z_PTS(I) = VERTS((I-1)*3) +ENDDO + +DO I=1,NCELLS + OFFSETS(I) = (I)*3_IB32 + VTKC_TYPE(I) = 5_IB8 +ENDDO + +DO I=1,NFACES + CONNECT(I) = FACES(I-1) +ENDDO + +ENDSUBROUTINE BUILD_VTK_GEOM_GEOMETRY + + + SUBROUTINE DEALLOCATE_VTK_GAS_PHASE_GEOMETRY(X_PTS,Y_PTS,Z_PTS,OFFSETS,VTKC_TYPE,CONNECT) From ab540e5d334b27a7ca6ff527036044712dd87820 Mon Sep 17 00:00:00 2001 From: Jonathan Hodges <johodges@vt.edu> Date: Sat, 6 Jan 2024 13:14:14 -0500 Subject: [PATCH 24/31] fix connectivity in GEOM bndf vtk output --- Source/dump.f90 | 6 +++++- Source/vtkf.f90 | 56 +++++++++++++++++++++++++++++++++++++++++++------ 2 files changed, 55 insertions(+), 7 deletions(-) diff --git a/Source/dump.f90 b/Source/dump.f90 index 3acb8aaf3d0..dd25223d28a 100644 --- a/Source/dump.f90 +++ b/Source/dump.f90 @@ -20,7 +20,8 @@ MODULE DUMP USE CC_SCALARS, ONLY : ADD_Q_DOT_CUTCELLS,GET_PRES_CFACE,GET_PRES_CFACE_TEST,GET_UVWGAS_CFACE,GET_MUDNS_CFACE USE VTK_FDS_INTERFACE, ONLY : WRITE_VTK_SLICE_WRAPPER,BUILD_VTK_GAS_PHASE_GEOMETRY,BUILD_VTK_SOLID_PHASE_GEOMETRY,& - WRITE_VTK_SM3D_WRAPPER,WRITE_VTK_SL3D_WRAPPER,DEALLOCATE_VTK_GAS_PHASE_GEOMETRY,BUILD_VTK_GEOM_GEOMETRY + WRITE_VTK_SM3D_WRAPPER,WRITE_VTK_SL3D_WRAPPER,WRITE_VTK_BNDF_WRAPPER,& + DEALLOCATE_VTK_GAS_PHASE_GEOMETRY,BUILD_VTK_GEOM_GEOMETRY USE VTK_FORTRAN, ONLY : VTK_FILE, PVTK_FILE IMPLICIT NONE (TYPE,EXTERNAL) @@ -160,6 +161,9 @@ SUBROUTINE DUMP_MESH_OUTPUTS(T,DT,NM) ! VTK Boundary data IF (T>=BNDF_VTK_CLOCK(BNDF_VTK_COUNTER(NM))) THEN + IF (NM .EQ. 1) THEN + CALL WRITE_VTK_BNDF_WRAPPER(T,NMESHES,'PUnstructuredGrid') + ENDIF CALL DUMP_BNDF(T,DT,NM,1) DO WHILE(BNDF_VTK_COUNTER(NM)<SIZE(BNDF_VTK_CLOCK)-1) BNDF_VTK_COUNTER(NM) = BNDF_VTK_COUNTER(NM) + 1 diff --git a/Source/vtkf.f90 b/Source/vtkf.f90 index 96b43fafcd6..99d110d0493 100644 --- a/Source/vtkf.f90 +++ b/Source/vtkf.f90 @@ -18646,7 +18646,7 @@ MODULE VTK_FDS_INTERFACE PRIVATE PUBLIC WRITE_VTK_SLICE_WRAPPER,BUILD_VTK_GAS_PHASE_GEOMETRY,BUILD_VTK_SOLID_PHASE_GEOMETRY,& - WRITE_VTK_SL3D_WRAPPER,WRITE_VTK_SM3D_WRAPPER,& + WRITE_VTK_SL3D_WRAPPER,WRITE_VTK_SM3D_WRAPPER,WRITE_VTK_BNDF_WRAPPER,& DEALLOCATE_VTK_GAS_PHASE_GEOMETRY,BUILD_VTK_GEOM_GEOMETRY CONTAINS @@ -18834,6 +18834,51 @@ END SUBROUTINE WRITE_VTK_SM3D_WRAPPER +SUBROUTINE WRITE_VTK_BNDF_WRAPPER(T,NMESHES,MESH_TOPOLOGY) +INTEGER, INTENT(IN) :: NMESHES +CHARACTER(LEN=*), INTENT(IN) :: MESH_TOPOLOGY +REAL(EB), INTENT(IN) :: T +TYPE(BOUNDARY_FILE_TYPE), POINTER :: BF +INTEGER :: I,NQT,I1,I2,J1,J2,K1,K2,IQ,ITM,ITM1 +REAL(FB) :: STIME +REAL(EB) :: TT +TYPE(PVTK_FILE) :: A_PVTK_FILE !< A parallel (partioned) VTK file. +INTEGER(IB8) :: VTK_ERROR=0_IB8 !< IO Error status. +CHARACTER(200) :: TMP_FILE + +! Generate filename +STIME = REAL(T_BEGIN + (T-T_BEGIN)*TIME_SHRINK_FACTOR,FB) +TT = T_BEGIN + (T-T_BEGIN)*TIME_SHRINK_FACTOR +ITM = INT(TT) +ITM1 = NINT(ABS(TT-ITM)*100) +IF (ITM1==100) THEN + ITM = ITM+1 + ITM1 = 0 +ENDIF +WRITE(FN_BNDF_VTK(NMESHES+1),'(A,A,A,I8.8,I2.2,A)') "",TRIM(CHID),'_BNDF_',ITM,ITM1,'.pvtu' +VTK_ERROR = A_PVTK_FILE%INITIALIZE(FILENAME=FN_BNDF_VTK(NMESHES+1), MESH_TOPOLOGY='PUnstructuredGrid',& + MESH_KIND='Float32') +VTK_ERROR = A_PVTK_FILE%XML_WRITER%W_DATA(LOCATION='NODE',ACTION='OPEN') +! Add PointData arrays +QUANTITY_LOOP2: DO IQ=1,N_BNDF + BF => BOUNDARY_FILE(IQ) + VTK_ERROR = A_PVTK_FILE%XML_WRITER%WRITE_PARALLEL_DATAARRAY(DATA_NAME=TRIM(BF%SMOKEVIEW_LABEL(1:30)), & + DATA_TYPE='Float32', NUMBER_OF_COMPONENTS=1) +ENDDO QUANTITY_LOOP2 +VTK_ERROR = A_PVTK_FILE%XML_WRITER%W_DATA(LOCATION='NODE',ACTION='CLOSE') + +DO I=1,NMESHES + WRITE(TMP_FILE,'(A,A,I0,A,I8.8,I2.2,A)') TRIM(CHID),'_BNDF_',I,'_',ITM,ITM1,'.vtu' + VTK_ERROR = A_PVTK_FILE%XML_WRITER%WRITE_PARALLEL_GEO(SOURCE=TMP_FILE) +ENDDO + +VTK_ERROR = A_PVTK_FILE%FINALIZE() +END SUBROUTINE WRITE_VTK_BNDF_WRAPPER + + + + + SUBROUTINE BUILD_VTK_GAS_PHASE_GEOMETRY(NM, MESH_TOPOLOGY, & NC, NP, X_PTS, Y_PTS, Z_PTS, CONNECT, OFFSETS, VTKC_TYPE) @@ -19002,16 +19047,15 @@ SUBROUTINE BUILD_VTK_GEOM_GEOMETRY(VERTS, FACES, NCELLS, NPOINTS,& DO I=1,NPOINTS X_PTS(I) = VERTS((I-1)*3+1) Y_PTS(I) = VERTS((I-1)*3+2) - Z_PTS(I) = VERTS((I-1)*3) + Z_PTS(I) = VERTS((I-1)*3+3) ENDDO DO I=1,NCELLS OFFSETS(I) = (I)*3_IB32 VTKC_TYPE(I) = 5_IB8 -ENDDO - -DO I=1,NFACES - CONNECT(I) = FACES(I-1) + CONNECT(3*(I-1)+1) = FACES(3*(I-1)+1)-1 + CONNECT(3*(I-1)+2) = FACES(3*(I-1)+2)-1 + CONNECT(3*(I-1)+3) = FACES(3*(I-1)+3)-1 ENDDO ENDSUBROUTINE BUILD_VTK_GEOM_GEOMETRY From 131f3f55c5afd0f1634fd58d9b03ed5a0ec1b708 Mon Sep 17 00:00:00 2001 From: Jonathan Hodges <johodges@vt.edu> Date: Sat, 6 Jan 2024 13:41:36 -0500 Subject: [PATCH 25/31] start adding particle vtk output --- Source/cons.f90 | 7 ++++--- Source/dump.f90 | 13 +++++++++++++ Source/func.f90 | 1 + 3 files changed, 18 insertions(+), 3 deletions(-) diff --git a/Source/cons.f90 b/Source/cons.f90 index 146726680db..f67c27be93f 100644 --- a/Source/cons.f90 +++ b/Source/cons.f90 @@ -549,7 +549,7 @@ MODULE GLOBAL_CONSTANTS CHARACTER(80), ALLOCATABLE, DIMENSION(:) :: FN_VEG_OUT,FN_GEOM, FN_CFACE_GEOM CHARACTER(80), ALLOCATABLE, DIMENSION(:,:) :: FN_SLCF,FN_SLCF_GEOM,FN_BNDF,FN_BNDG, & FN_ISOF,FN_ISOF2,FN_SMOKE3D,FN_RADF -CHARACTER(200), ALLOCATABLE, DIMENSION(:) :: FN_SL3D_VTK,FN_SMOKE3D_VTK,FN_BNDF_VTK +CHARACTER(200), ALLOCATABLE, DIMENSION(:) :: FN_SL3D_VTK,FN_SMOKE3D_VTK,FN_BNDF_VTK,FN_PART_VTK CHARACTER(9) :: FMT_R LOGICAL :: OUT_FILE_OPENED=.FALSE. @@ -763,14 +763,15 @@ MODULE OUTPUT_CLOCKS INTEGER :: RAMP_SL3D_VTK_INDEX=0 !< Ramp index for vtk file time series INTEGER :: RAMP_SM3D_VTK_INDEX=0 !< Ramp index for vtk file time series INTEGER :: RAMP_BNDF_VTK_INDEX=0 !< Ramp index for boundary file time series +INTEGER :: RAMP_PART_VTK_INDEX=0 !< Ramp index for boundary file time series REAL(EB), ALLOCATABLE, DIMENSION(:) :: BNDF_CLOCK, CPU_CLOCK,CTRL_CLOCK,DEVC_CLOCK,FLSH_CLOCK,GEOM_CLOCK, HRR_CLOCK,HVAC_CLOCK,& ISOF_CLOCK,MASS_CLOCK,PART_CLOCK,PL3D_CLOCK,PROF_CLOCK,RADF_CLOCK,RSRT_CLOCK,& SLCF_CLOCK,SL3D_CLOCK,SM3D_CLOCK,UVW_CLOCK ,TMP_CLOCK ,SPEC_CLOCK,& - SL3D_VTK_CLOCK,SM3D_VTK_CLOCK,BNDF_VTK_CLOCK + SL3D_VTK_CLOCK,SM3D_VTK_CLOCK,BNDF_VTK_CLOCK,PART_VTK_CLOCK INTEGER, ALLOCATABLE, DIMENSION(:) :: BNDF_COUNTER, CPU_COUNTER,CTRL_COUNTER,DEVC_COUNTER,FLSH_COUNTER,GEOM_COUNTER, HRR_COUNTER,& HVAC_COUNTER,ISOF_COUNTER,MASS_COUNTER,PART_COUNTER,PL3D_COUNTER,PROF_COUNTER,RADF_COUNTER,& RSRT_COUNTER,SLCF_COUNTER,SL3D_COUNTER,SM3D_COUNTER,UVW_COUNTER ,TMP_COUNTER ,SPEC_COUNTER,& - SL3D_VTK_COUNTER,SM3D_VTK_COUNTER,BNDF_VTK_COUNTER + SL3D_VTK_COUNTER,SM3D_VTK_COUNTER,BNDF_VTK_COUNTER,PART_VTK_COUNTER REAL(EB) :: TURB_INIT_CLOCK=-1.E10_EB REAL(EB) :: MMS_TIMER=1.E10_EB REAL(EB) :: DT_SLCF,DT_BNDF,DT_DEVC,DT_PL3D,DT_PART,DT_RESTART,DT_ISOF,DT_HRR,DT_HVAC,DT_MASS,DT_PROF,DT_CTRL,& diff --git a/Source/dump.f90 b/Source/dump.f90 index dd25223d28a..e54ebd78010 100644 --- a/Source/dump.f90 +++ b/Source/dump.f90 @@ -171,6 +171,18 @@ SUBROUTINE DUMP_MESH_OUTPUTS(T,DT,NM) ENDDO ENDIF +! VTK Particle data +IF (T>=PART_VTK_CLOCK(PART_VTK_COUNTER(NM)) .AND. PARTICLE_FILE) THEN + IF (NM .EQ. 1) THEN + !CALL WRITE_VTK_PART_WRAPPER(T,NMESHES,'PPolyData') + ENDIF + !CALL DUMP_PART(T,NM) + DO WHILE(PART_VTK_COUNTER(NM)<SIZE(PART_VTK_CLOCK)-1) + PART_VTK_COUNTER(NM) = PART_VTK_COUNTER(NM) + 1 + IF (PART_VTK_CLOCK(PART_VTK_COUNTER(NM))>=T) EXIT + ENDDO +ENDIF + IF (T>=BNDF_CLOCK(BNDF_COUNTER(NM))) THEN CALL DUMP_BNDF(T,DT,NM,0) DO WHILE(BNDF_COUNTER(NM)<SIZE(BNDF_CLOCK)-1) @@ -410,6 +422,7 @@ SUBROUTINE ASSIGN_FILE_NAMES ALLOCATE(FN_SMOKE3D_VTK(NMESHES+1)) ALLOCATE(LU_SMOKE3D_VTK(NMESHES+1)) ALLOCATE(FN_BNDF_VTK(NMESHES+1)) +ALLOCATE(FN_PART_VTK(NMESHES+1)) MESH_LOOP: DO NM=1,NMESHES diff --git a/Source/func.f90 b/Source/func.f90 index 6697bfd5a78..ed2a96e515c 100644 --- a/Source/func.f90 +++ b/Source/func.f90 @@ -484,6 +484,7 @@ SUBROUTINE INITIALIZE_OUTPUT_CLOCKS(T) CALL SET_OUTPUT_CLOCK(DT_VTK ,RAMP_SL3D_VTK_INDEX, SL3D_VTK_CLOCK, SL3D_VTK_COUNTER,.TRUE. ,.TRUE. ) CALL SET_OUTPUT_CLOCK(DT_VTK ,RAMP_SM3D_VTK_INDEX, SM3D_VTK_CLOCK, SM3D_VTK_COUNTER,.TRUE. ,.TRUE. ) CALL SET_OUTPUT_CLOCK(DT_VTK ,RAMP_BNDF_VTK_INDEX, BNDF_VTK_CLOCK, BNDF_VTK_COUNTER,.TRUE. ,.TRUE. ) +CALL SET_OUTPUT_CLOCK(DT_VTK ,RAMP_PART_VTK_INDEX, PART_VTK_CLOCK, PART_VTK_COUNTER,.TRUE. ,.TRUE. ) ! Special cases From 841423604384928fb1aaa9c3756e3e3011ad1ce0 Mon Sep 17 00:00:00 2001 From: Jonathan Hodges <johodges@vt.edu> Date: Sat, 6 Jan 2024 13:42:03 -0500 Subject: [PATCH 26/31] Start adding PPOLYDATA type --- Source/vtkf.f90 | 175 +++++++++++++++++++++++++++++------------------- 1 file changed, 106 insertions(+), 69 deletions(-) diff --git a/Source/vtkf.f90 b/Source/vtkf.f90 index 99d110d0493..98e01719cac 100644 --- a/Source/vtkf.f90 +++ b/Source/vtkf.f90 @@ -3856,10 +3856,10 @@ MODULE STRINGIFOR_STRING_T PROCEDURE, PRIVATE, PASS(SELF) :: INSERT_CHARACTER !< INSERT SUBSTRING INTO STRING AT A SPECIFIED POSITION. PROCEDURE, PRIVATE, PASS(SELF) :: JOIN_STRINGS !< RETURN JOIN STRING OF AN ARRAY OF STRINGS. PROCEDURE, PRIVATE, PASS(SELF) :: JOIN_CHARACTERS !< RETURN JOIN STRING OF AN ARRAY OF CHARACTERS. - PROCEDURE, PRIVATE, NOPASS :: STRJOIN_STRINGS !< RETURN JOIN STRING OF AN ARRAY OF STRINGS. - PROCEDURE, PRIVATE, NOPASS :: STRJOIN_CHARACTERS !< RETURN JOIN STRING OF AN ARRAY OF STRINGS. - PROCEDURE, PRIVATE, NOPASS :: STRJOIN_STRINGS_ARRAY !< RETURN JOIN 1D STRING ARRAY OF AN 2D ARRAY OF STRINGS IN COLUMNS OR ROWS. - PROCEDURE, PRIVATE, NOPASS :: STRJOIN_CHARACTERS_ARRAY !< RETURN JOIN 1D STRING ARRAY OF AN 2D ARRAY OF CHARACTERS IN COLUMNS OR ROWS. + PROCEDURE, PRIVATE, NOPASS :: STRJOIN_STRINGS !< RETURN JOIN STRING OF AN ARRAY OF STRINGS. + PROCEDURE, PRIVATE, NOPASS :: STRJOIN_CHARACTERS !< RETURN JOIN STRING OF AN ARRAY OF STRINGS. + PROCEDURE, PRIVATE, NOPASS :: STRJOIN_STRINGS_ARRAY !< RETURN JOIN 1D STRING ARRAY OF AN 2D ARRAY OF STRINGS IN C OR R. + PROCEDURE, PRIVATE, NOPASS :: STRJOIN_CHARACTERS_ARRAY !< RETURN JOIN 1D STRING ARRAY OF AN 2D ARRAY OF CHARACTERS IN C OR R. PROCEDURE, PRIVATE, PASS(SELF) :: TO_INTEGER_I1P !< CAST STRING TO INTEGER. #ifndef _NVF PROCEDURE, PRIVATE, PASS(SELF) :: TO_INTEGER_I2P !< CAST STRING TO INTEGER. @@ -4126,7 +4126,7 @@ ELEMENTAL FUNCTION SINDEX_CHARACTER_STRING(S, SUBSTRING, BACK) RESULT(I) ENDFUNCTION SINDEX_CHARACTER_STRING ELEMENTAL FUNCTION SSCAN_CHARACTER_STRING(S, SET, BACK) RESULT(I) - !< RETURN THE LEFTMOST (IF `BACK` IS EITHER ABSENT OR EQUALS FALSE, OTHERWISE THE RIGHTMOST) CHARACTER OF STRING THAT IS IN `SET`. + !< RETURN THE LEFTMOST (IF BACK IS EITHER ABSENT OR EQUALS FALSE, OTHERWISE THE RIGHTMOST) CHARACTER OF STRING THAT IS IN SET. !< !<```FORTRAN !< TYPE(STRING) :: STRING1 @@ -4215,8 +4215,8 @@ ELEMENTAL FUNCTION SCOUNT(SELF, SUBSTRING, IGNORE_ISOLATED) RESULT(NO) !< COUNT THE NUMBER OF OCCURENCES OF A SUBSTRING INTO A STRING. !< !< @NOTE IF `IGNORE_ISOLATED` IS SET TO TRUE THE EVENTUAL "ISOLATED" OCCURENCES ARE IGNORED: AN ISOLATED OCCURRENCES ARE THOSE - !< OCCURRENCES HAPPENING AT THE START OF STRING (THUS NOT HAVING A LEFT COMPANION) OR AT THE END OF THE STRING (THUS NOT HAVING A - !< RIGHT COMPANION). + !< OCCURRENCES HAPPENING AT THE START OF STRING (THUS NOT HAVING A LEFT COMPANION) OR AT THE END OF THE STRING (THUS NOT HAVING + !< A RIGHT COMPANION). !< !<```FORTRAN !< TYPE(STRING) :: ASTRING @@ -4299,7 +4299,7 @@ ELEMENTAL FUNCTION SINDEX_STRING_CHARACTER(SELF, SUBSTRING, BACK) RESULT(I) !< LOGICAL :: TEST_PASSED(2) !< STRING1 = 'HELLO WORLD HELLO!' !< TEST_PASSED(1) = STRING1%INDEX(SUBSTRING='LLO')==INDEX(STRING='HELLO WORLD HELLO!', SUBSTRING='LLO') - !< TEST_PASSED(2) = STRING1%INDEX(SUBSTRING='LLO', BACK=.TRUE.)==INDEX(STRING='HELLO WORLD HELLO!', SUBSTRING='LLO', BACK=.TRUE.) + !< TEST_PASSED(2) = STRING1%INDEX(SUBSTRING='LLO',BACK=.TRUE.)==INDEX(STRING='HELLO WORLD HELLO!', SUBSTRING='LLO', BACK=.TRUE.) !< PRINT '(L1)', ALL(TEST_PASSED) !<``` !=> T <<< @@ -4394,7 +4394,7 @@ ELEMENTAL FUNCTION SREPEAT_CHARACTER_STRING(RSTRING, NCOPIES) RESULT(REPEATED) ENDFUNCTION SREPEAT_CHARACTER_STRING ELEMENTAL FUNCTION SSCAN_STRING_STRING(SELF, SET, BACK) RESULT(I) - !< RETURN THE LEFTMOST (IF `BACK` IS EITHER ABSENT OR EQUALS FALSE, OTHERWISE THE RIGHTMOST) CHARACTER OF STRING THAT IS IN `SET`. + !< RETURN THE LEFTMOST (IF BACK IS EITHER ABSENT OR EQUALS FALSE, OTHERWISE THE RIGHTMOST) CHARACTER OF STRING THAT IS IN SET. !< !<```FORTRAN !< TYPE(STRING) :: STRING1 @@ -4420,7 +4420,7 @@ ELEMENTAL FUNCTION SSCAN_STRING_STRING(SELF, SET, BACK) RESULT(I) ENDFUNCTION SSCAN_STRING_STRING ELEMENTAL FUNCTION SSCAN_STRING_CHARACTER(SELF, SET, BACK) RESULT(I) - !< RETURN THE LEFTMOST (IF `BACK` IS EITHER ABSENT OR EQUALS FALSE, OTHERWISE THE RIGHTMOST) CHARACTER OF STRING THAT IS IN `SET`. + !< RETURN THE LEFTMOST (IF BACK IS EITHER ABSENT OR EQUALS FALSE, OTHERWISE THE RIGHTMOST) CHARACTER OF STRING THAT IS IN SET. !< !<```FORTRAN !< TYPE(STRING) :: STRING1 @@ -4821,7 +4821,8 @@ ELEMENTAL SUBROUTINE FREE(SELF) ENDSUBROUTINE FREE SUBROUTINE GLOB_CHARACTER(SELF, PATTERN, LIST) - !< GLOB SEARCH (CHARACTER OUTPUT), FINDS ALL THE PATHNAMES MATCHING A GIVEN PATTERN ACCORDING TO THE RULES USED BY THE UNIX SHELL. + !< GLOB SEARCH (CHARACTER OUTPUT), FINDS ALL THE PATHNAMES MATCHING A GIVEN PATTERN ACCORDING TO THE RULES USED BY THE UNIX + !< SHELL. !< !< @NOTE METHOD NOT PORTABLE: WORKS ONLY ON UNIX/GNU LINUX OS. !< @@ -5172,55 +5173,6 @@ PURE FUNCTION STRJOIN_CHARACTERS(ARRAY, SEP, IS_TRIM) RESULT(JOIN) !< THE JOIN-SEPARATOR IS SET EQUALS TO A NULL STRING '' IF CUSTOM SEPARATOR ISN'T SPECIFIED. !< THE TRIM FUNCTION IS APPLIED TO ARRAY ITEMS IF OPTIONAL LOGICAL IS_TRIM VARIABLE ISN'T SET TO .FALSE. !< - !<```FORTRAN - !< CHARACTER(5) :: CHARACTERS(3) - !< LOGICAL :: TEST_PASSED(13) - !< CHARACTERS(1) = 'ONE' - !< CHARACTERS(2) = 'TWO' - !< CHARACTERS(3) = 'THREE' - !< TEST_PASSED(1) = (STRJOIN(ARRAY=CHARACTERS)//''==TRIM(CHARACTERS(1))//TRIM(CHARACTERS(2))//TRIM(CHARACTERS(3))) - !< TEST_PASSED(2) = (STRJOIN(ARRAY=CHARACTERS, SEP='-')//''==TRIM(CHARACTERS(1))//'-'//TRIM(CHARACTERS(2))//'-'//TRIM(CHARACTERS(3))) - !< TEST_PASSED(3) = ( STRJOIN(ARRAY=CHARACTERS, IS_TRIM=.FALSE.)//''==CHARACTERS(1)//CHARACTERS(2)//CHARACTERS(3)) - !< TEST_PASSED(4) = ( STRJOIN(ARRAY=CHARACTERS, SEP='-', IS_TRIM=.FALSE.)//''==CHARACTERS(1)//'-'//CHARACTERS(2)//'-'//CHARACTERS(3)) - !< CHARACTERS(1) = '' - !< CHARACTERS(2) = 'TWO' - !< CHARACTERS(3) = 'THREE' - !< TEST_PASSED(5) = (STRJOIN(ARRAY=CHARACTERS)//''==TRIM(CHARACTERS(2))//TRIM(CHARACTERS(3))) - !< CHARACTERS(1) = 'ONE' - !< CHARACTERS(2) = 'TWO' - !< CHARACTERS(3) = '' - !< TEST_PASSED(6) = (STRJOIN(ARRAY=CHARACTERS)//''==TRIM(CHARACTERS(1))//TRIM(CHARACTERS(2))) - !< CHARACTERS(1) = 'ONE' - !< CHARACTERS(2) = '' - !< CHARACTERS(3) = 'THREE' - !< TEST_PASSED(7) = (STRJOIN(ARRAY=CHARACTERS)//''==TRIM(CHARACTERS(1))//TRIM(CHARACTERS(3))) - !< CHARACTERS(1) = '' - !< CHARACTERS(2) = 'TWO' - !< CHARACTERS(3) = 'THREE' - !< TEST_PASSED(8) = (STRJOIN(ARRAY=CHARACTERS, SEP='-')//''==TRIM(CHARACTERS(2))//'-'//TRIM(CHARACTERS(3))) - !< CHARACTERS(1) = 'ONE' - !< CHARACTERS(2) = 'TWO' - !< CHARACTERS(3) = '' - !< TEST_PASSED(9) = (STRJOIN(ARRAY=CHARACTERS, SEP='-')//''==TRIM(CHARACTERS(1))//'-'//TRIM(CHARACTERS(2))) - !< CHARACTERS(1) = 'ONE' - !< CHARACTERS(2) = '' - !< CHARACTERS(3) = 'THREE' - !< TEST_PASSED(10) = (STRJOIN(ARRAY=CHARACTERS, SEP='-')//''==TRIM(CHARACTERS(1))//'-'//TRIM(CHARACTERS(3))) - !< CHARACTERS(1) = '' - !< CHARACTERS(2) = 'TWO' - !< CHARACTERS(3) = 'THREE' - !< TEST_PASSED(11) = (STRJOIN(ARRAY=CHARACTERS, SEP='-', IS_TRIM=.FALSE.)//''==CHARACTERS(2)//'-'//CHARACTERS(3)) - !< CHARACTERS(1) = 'ONE' - !< CHARACTERS(2) = 'TWO' - !< CHARACTERS(3) = '' - !< TEST_PASSED(12) = (STRJOIN(ARRAY=CHARACTERS, SEP='-', IS_TRIM=.FALSE.)//''==CHARACTERS(1)//'-'//CHARACTERS(2)) - !< CHARACTERS(1) = 'ONE' - !< CHARACTERS(2) = '' - !< CHARACTERS(3) = 'THREE' - !< TEST_PASSED(13) = (STRJOIN(ARRAY=CHARACTERS, SEP='-', IS_TRIM=.FALSE.)//''==CHARACTERS(1)//'-'//CHARACTERS(3)) - !< PRINT '(L1)', ALL(TEST_PASSED) - !<``` - !=> T <<< CHARACTER(KIND=CK, LEN=*), INTENT(IN) :: ARRAY(1:) !< ARRAY TO BE JOINED. CHARACTER(KIND=CK, LEN=*), INTENT(IN), OPTIONAL :: SEP !< SEPARATOR. LOGICAL, INTENT(IN), OPTIONAL :: IS_TRIM !< FLAG TO SETUP TRIM CHARACTER OR NOT @@ -5301,7 +5253,7 @@ PURE FUNCTION STRJOIN_STRINGS_ARRAY(ARRAY, SEP, IS_COL) RESULT(JOIN) TYPE(STRING), ALLOCATABLE :: SLICE(:) !< THE COLUMN OR ROW SLICE OF ARRAY CHARACTER(KIND=CK, LEN=:), ALLOCATABLE :: SEP_ !< SEPARATOR, DEFAULT VALUE. LOGICAL :: IS_COL_ !< DIRECTION, DEFAULT VALUE. - INTEGER :: A, JOIN_SIZE, SLICE_SIZE !< COUNTER, SIZES OF JOIN VECTOR AND OF SLICE OF ARRAY + INTEGER :: A, JOIN_SIZE, SLICE_SIZE !< COUNTER, SIZES OF JOIN VECTOR AND OF SLICE OF ARRAY SEP_ = '' ; IF (PRESENT(SEP)) SEP_ = SEP IS_COL_ = .TRUE. ; IF (PRESENT(IS_COL)) IS_COL_ = IS_COL @@ -5399,8 +5351,8 @@ PURE FUNCTION STRJOIN_CHARACTERS_ARRAY(ARRAY, SEP, IS_TRIM, IS_COL) RESULT(JOIN) CHARACTER(KIND=CK, LEN=:), ALLOCATABLE :: SEP_ !< SEPARATOR, DEFAULT VALUE. LOGICAL :: IS_TRIM_ !< FLAG TO SETUP TRIM CHARACTER OR NOT LOGICAL :: IS_COL_ !< DIRECTION, DEFAULT VALUE. - INTEGER :: A, JOIN_SIZE, SLICE_SIZE !< COUNTER, SIZES OF JOIN VECTOR AND OF SLICE OF ARRAY - INTEGER :: ITEM_LEN !< LENGTH OF ARRAY ITEM (ALL ITEMS OF CHARACTER ARRAY HAVE EQUAL LENGTHS) + INTEGER :: A, JOIN_SIZE, SLICE_SIZE !< COUNTER, SIZES OF JOIN VECTOR AND OF SLICE OF ARRAY + INTEGER :: ITEM_LEN !< LENGTH OF ARRAY ITEM (ALL ITEMS OF CHARACTER ARRAY HAVE EQUAL LENGTHS) ITEM_LEN = LEN(ARRAY(1,1)) !< ALL ITEMS OF CHARACTER ARRAY HAVE EQUAL LENGTHS SEP_ = '' ; IF (PRESENT(SEP)) SEP_ = SEP @@ -6626,7 +6578,8 @@ SUBROUTINE WRITE_FILE(SELF, FILE, FORM, IOSTAT, IOMSG) SUBROUTINE WRITE_LINE(SELF, UNIT, FORM, IOSTAT, IOMSG) !< WRITE LINE (RECORD) TO A CONNECTED UNIT. !< - !< @NOTE IF THE CONNECTED UNIT IS UNFORMATTED A `NEW_LINE()` CHARACTER IS ADDED AT THE END (IF NECESSARY) TO MARK THE END OF LINE. + !< @NOTE IF THE CONNECTED UNIT IS UNFORMATTED A `NEW_LINE()` CHARACTER IS ADDED AT THE END (IF NECESSARY) TO MARK THE END OF + !< LINE. !< !< @NOTE THERE IS NO DOCTESTS, THIS BEING TESTED BY MEANS OF [[STRING:WRITE_FILE]] DOCTESTS. CLASS(STRING), INTENT(IN) :: SELF !< THE STRING. @@ -6662,7 +6615,8 @@ SUBROUTINE WRITE_LINES(SELF, UNIT, FORM, IOSTAT, IOMSG) !< !< THIS METHOD CHECKS IF SELF CONTAINS MORE THAN ONE LINE (RECORDS) AND WRITES THEM AS LINES (RECORDS). !< - !< @NOTE IF THE CONNECTED UNIT IS UNFORMATTED A `NEW_LINE()` CHARACTER IS ADDED AT THE END (IF NECESSARY) TO MARK THE END OF LINE. + !< @NOTE IF THE CONNECTED UNIT IS UNFORMATTED A `NEW_LINE()` CHARACTER IS ADDED AT THE END (IF NECESSARY) TO MARK THE END OF + !< LINE. !< !< @NOTE THERE IS NO DOCTESTS, THIS BEING TESTED BY MEANS OF [[STRING:WRITE_FILE]] DOCTESTS. CLASS(STRING), INTENT(IN) :: SELF !< THE STRING. @@ -9721,6 +9675,10 @@ MODULE VTKF_FILE_XML_WRITER_ABSTRACT PROCEDURE, PASS(SELF), PRIVATE :: WRITE_GEO_UNST_DATA1_RANK2_R4P !< WRITE **UNSTRUCTUREDGRID** MESH (DATA 1, RANK 2, R4P). PROCEDURE, PASS(SELF), PRIVATE :: WRITE_GEO_UNST_DATA3_RANK1_R8P !< WRITE **UNSTRUCTUREDGRID** MESH (DATA 3, RANK 1, R8P). PROCEDURE, PASS(SELF), PRIVATE :: WRITE_GEO_UNST_DATA3_RANK1_R4P !< WRITE **UNSTRUCTUREDGRID** MESH (DATA 3, RANK 1, R4P). + PROCEDURE, PASS(SELF), PRIVATE :: WRITE_GEO_POLY_DATA1_RANK2_R8P !< WRITE **POLYDATA** MESH (DATA 1, RANK 2, R8P). + PROCEDURE, PASS(SELF), PRIVATE :: WRITE_GEO_POLY_DATA1_RANK2_R4P !< WRITE **POLYDATA** MESH (DATA 1, RANK 2, R4P). + PROCEDURE, PASS(SELF), PRIVATE :: WRITE_GEO_POLY_DATA3_RANK1_R8P !< WRITE **POLYDATA** MESH (DATA 3, RANK 1, R8P). + PROCEDURE, PASS(SELF), PRIVATE :: WRITE_GEO_POLY_DATA3_RANK1_R4P !< WRITE **POLYDATA** MESH (DATA 3, RANK 1, R4P). PROCEDURE, PASS(SELF), PRIVATE :: WRITE_PIECE_START_TAG !< WRITE `<PIECE ...>` START TAG. PROCEDURE, PASS(SELF), PRIVATE :: WRITE_PIECE_START_TAG_UNST !< WRITE `<PIECE ...>` START TAG FOR UNSTRUCTURED TOPOLOGY. PROCEDURE, PASS(SELF), PRIVATE :: WRITE_PIECE_END_TAG !< WRITE `</PIECE>` END TAG. @@ -10503,7 +10461,7 @@ SUBROUTINE WRITE_TOPOLOGY_TAG(SELF, NX1, NX2, NY1, NY2, NZ1, NZ2, MESH_KIND) TRIM(STR(N=NX1))//' '//TRIM(STR(N=NX2))//' '//& TRIM(STR(N=NY1))//' '//TRIM(STR(N=NY2))//' '//& TRIM(STR(N=NZ1))//' '//TRIM(STR(N=NZ2))//'" GhostLevel="#"' - CASE('PUnstructuredGrid') + CASE('PUnstructuredGrid','PPolyData') BUFFER = 'GhostLevel="0"' ENDSELECT CALL SELF%WRITE_START_TAG(NAME=SELF%TOPOLOGY%CHARS(), ATTRIBUTES=BUFFER%CHARS()) @@ -10519,7 +10477,7 @@ SUBROUTINE WRITE_TOPOLOGY_TAG(SELF, NX1, NX2, NY1, NY2, NZ1, NZ2, MESH_KIND) CALL SELF%WRITE_SELF_CLOSING_TAG(NAME='PDataArray', ATTRIBUTES='type="'//TRIM(MESH_KIND)//'"') CALL SELF%WRITE_SELF_CLOSING_TAG(NAME='PDataArray', ATTRIBUTES='type="'//TRIM(MESH_KIND)//'"') CALL SELF%WRITE_END_TAG(NAME='PCoordinates') - CASE('PStructuredGrid', 'PUnstructuredGrid') + CASE('PStructuredGrid', 'PUnstructuredGrid','PPolyData') IF (.NOT.PRESENT(MESH_KIND)) THEN SELF%ERROR = 1 RETURN @@ -10633,7 +10591,7 @@ FUNCTION W_DATA_LOCATION_TAG(SELF, LOCATION, ACTION) RESULT(ERROR) LOCATION_ = 'PointData' ENDSELECT SELECT CASE(SELF%TOPOLOGY%CHARS()) - CASE('PRectilinearGrid', 'PStructuredGrid', 'PUnstructuredGrid') + CASE('PRectilinearGrid', 'PStructuredGrid', 'PUnstructuredGrid','PPolyData') LOCATION_ = 'P'//LOCATION_ ENDSELECT SELECT CASE(ACTION_%CHARS()) @@ -10968,6 +10926,83 @@ FUNCTION WRITE_GEO_UNST_DATA3_RANK1_R4P(SELF, NP, NC, X, Y, Z) RESULT(ERROR) ERROR = SELF%ERROR ENDFUNCTION WRITE_GEO_UNST_DATA3_RANK1_R4P + ! WRITE_GEO_POLY METHODS + FUNCTION WRITE_GEO_POLY_DATA1_RANK2_R8P(SELF, NP, NC, XYZ) RESULT(ERROR) + !< WRITE MESH WITH **POLYDATA** TOPOLOGY (DATA 1, RANK 2, R8P). + CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT) :: SELF !< WRITER. + INTEGER(I4P), INTENT(IN) :: NP !< NUMBER OF POINTS. + INTEGER(I4P), INTENT(IN) :: NC !< NUMBER OF CELLS. + REAL(R8P), INTENT(IN) :: XYZ(1:,1:) !< X, Y, Z COORDINATES [1:3,:]. + INTEGER(I4P) :: ERROR !< ERROR STATUS. + + IF (NP/=SIZE(XYZ, DIM=2)) THEN + SELF%ERROR = 1 + RETURN + ENDIF + CALL SELF%WRITE_START_TAG(NAME='Points') + ERROR = SELF%W_DATA(DATA_NAME='Points', X=XYZ) + CALL SELF%WRITE_END_TAG(NAME='Points') + ERROR = SELF%ERROR + ENDFUNCTION WRITE_GEO_POLY_DATA1_RANK2_R8P + + FUNCTION WRITE_GEO_POLY_DATA1_RANK2_R4P(SELF, NP, NC, XYZ) RESULT(ERROR) + !< WRITE MESH WITH **POLYDATA** TOPOLOGY (DATA 1, RANK 2, R4P). + CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT) :: SELF !< WRITER. + INTEGER(I4P), INTENT(IN) :: NP !< NUMBER OF POINTS. + INTEGER(I4P), INTENT(IN) :: NC !< NUMBER OF CELLS. + REAL(R4P), INTENT(IN) :: XYZ(1:,1:) !< X, Y, Z COORDINATES [1:3,:]. + INTEGER(I4P) :: ERROR !< ERROR STATUS. + + IF (NP/=SIZE(XYZ, DIM=2)) THEN + SELF%ERROR = 1 + RETURN + ENDIF + CALL SELF%WRITE_START_TAG(NAME='Points') + ERROR = SELF%W_DATA(DATA_NAME='Points', X=XYZ) + CALL SELF%WRITE_END_TAG(NAME='Points') + ERROR = SELF%ERROR + ENDFUNCTION WRITE_GEO_POLY_DATA1_RANK2_R4P + + FUNCTION WRITE_GEO_POLY_DATA3_RANK1_R8P(SELF, NP, NC, X, Y, Z) RESULT(ERROR) + !< WRITE MESH WITH **POLYDATA** TOPOLOGY (DATA 3, RANK 1, R8P). + CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT) :: SELF !< WRITER. + INTEGER(I4P), INTENT(IN) :: NP !< NUMBER OF POINTS. + INTEGER(I4P), INTENT(IN) :: NC !< NUMBER OF CELLS. + REAL(R8P), INTENT(IN) :: X(1:) !< X COORDINATES. + REAL(R8P), INTENT(IN) :: Y(1:) !< Y COORDINATES. + REAL(R8P), INTENT(IN) :: Z(1:) !< Z COORDINATES. + INTEGER(I4P) :: ERROR !< ERROR STATUS. + + IF ((NP/=SIZE(X, DIM=1)).OR.(NP/=SIZE(Y, DIM=1)).OR.(NP/=SIZE(Z, DIM=1))) THEN + SELF%ERROR = 1 + RETURN + ENDIF + CALL SELF%WRITE_START_TAG(NAME='Points') + ERROR = SELF%W_DATA(DATA_NAME='Points', X=X, Y=Y, Z=Z) + CALL SELF%WRITE_END_TAG(NAME='Points') + ERROR = SELF%ERROR + ENDFUNCTION WRITE_GEO_POLY_DATA3_RANK1_R8P + + FUNCTION WRITE_GEO_POLY_DATA3_RANK1_R4P(SELF, NP, NC, X, Y, Z) RESULT(ERROR) + !< WRITE MESH WITH **POLYDATA** TOPOLOGY (DATA 3, RANK 1, R4P). + CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT) :: SELF !< WRITER. + INTEGER(I4P), INTENT(IN) :: NP !< NUMBER OF POINTS. + INTEGER(I4P), INTENT(IN) :: NC !< NUMBER OF CELLS. + REAL(R4P), INTENT(IN) :: X(1:) !< X COORDINATES. + REAL(R4P), INTENT(IN) :: Y(1:) !< Y COORDINATES. + REAL(R4P), INTENT(IN) :: Z(1:) !< Z COORDINATES. + INTEGER(I4P) :: ERROR !< ERROR STATUS. + + IF ((NP/=SIZE(X, DIM=1)).OR.(NP/=SIZE(Y, DIM=1)).OR.(NP/=SIZE(Z, DIM=1))) THEN + SELF%ERROR = 1 + RETURN + ENDIF + CALL SELF%WRITE_START_TAG(NAME='Points') + ERROR = SELF%W_DATA(DATA_NAME='Points', X=X, Y=Y, Z=Z) + CALL SELF%WRITE_END_TAG(NAME='Points') + ERROR = SELF%ERROR + ENDFUNCTION WRITE_GEO_POLY_DATA3_RANK1_R4P + FUNCTION WRITE_CONNECTIVITY(SELF, NC, CONNECTIVITY, OFFSET, VTKC_TYPE, FACE, FACEOFFSET) RESULT(ERROR) !< WRITE MESH CONNECTIVITY. !< @@ -11109,7 +11144,7 @@ FUNCTION WRITE_PARALLEL_GEO(SELF, SOURCE, NX1, NX2, NY1, NY2, NZ1, NZ2) RESULT(E TRIM(STR(N=NX1))//' '//TRIM(STR(N=NX2))//' '// & TRIM(STR(N=NY1))//' '//TRIM(STR(N=NY2))//' '// & TRIM(STR(N=NZ1))//' '//TRIM(STR(N=NZ2))//'" Source="'//TRIM(ADJUSTL(SOURCE))//'"' - CASE('PUnstructuredGrid') + CASE('PUnstructuredGrid','PPolyData') BUFFER = 'Source="'//TRIM(ADJUSTL(SOURCE))//'"' ENDSELECT CALL SELF%WRITE_SELF_CLOSING_TAG(NAME='Piece', ATTRIBUTES=BUFFER%CHARS()) @@ -18424,6 +18459,7 @@ FUNCTION INITIALIZE(SELF, FORMAT, FILENAME, MESH_TOPOLOGY, IS_VOLATILE, NX1, NX2 !<- RECTILINEARGRID; !<- STRUCTUREDGRID; !<- UNSTRUCTUREDGRID. + !<- POLYDATA !< !<### EXAMPLE OF USAGE !< @@ -18522,6 +18558,7 @@ FUNCTION INITIALIZE(SELF, FILENAME, MESH_TOPOLOGY, MESH_KIND, NX1, NX2, NY1, NY2 !<- PRECTILINEARGRID; !<- PSTRUCTUREDGRID; !<- PUNSTRUCTUREDGRID. + !<- PPOLYDATA !< !<### EXAMPLE OF USAGE !< From 84571391626b1fc2ea9639f770e164bb85f2d59f Mon Sep 17 00:00:00 2001 From: Jonathan Hodges <johodges@vt.edu> Date: Sat, 6 Jan 2024 15:05:44 -0500 Subject: [PATCH 27/31] Remove unused routines from vtkf --- Source/dump.f90 | 2 +- Source/vtkf.f90 | 7095 +++-------------------------------------------- 2 files changed, 378 insertions(+), 6719 deletions(-) diff --git a/Source/dump.f90 b/Source/dump.f90 index e54ebd78010..0aed6f61b17 100644 --- a/Source/dump.f90 +++ b/Source/dump.f90 @@ -19,7 +19,7 @@ MODULE DUMP CC_VGSC,CC_GASPHASE,MAKE_UNIQUE_VERT_ARRAY,AVERAGE_FACE_VALUES USE CC_SCALARS, ONLY : ADD_Q_DOT_CUTCELLS,GET_PRES_CFACE,GET_PRES_CFACE_TEST,GET_UVWGAS_CFACE,GET_MUDNS_CFACE -USE VTK_FDS_INTERFACE, ONLY : WRITE_VTK_SLICE_WRAPPER,BUILD_VTK_GAS_PHASE_GEOMETRY,BUILD_VTK_SOLID_PHASE_GEOMETRY,& +USE VTK_FDS_INTERFACE, ONLY : BUILD_VTK_GAS_PHASE_GEOMETRY,BUILD_VTK_SOLID_PHASE_GEOMETRY,& WRITE_VTK_SM3D_WRAPPER,WRITE_VTK_SL3D_WRAPPER,WRITE_VTK_BNDF_WRAPPER,& DEALLOCATE_VTK_GAS_PHASE_GEOMETRY,BUILD_VTK_GEOM_GEOMETRY USE VTK_FORTRAN, ONLY : VTK_FILE, PVTK_FILE diff --git a/Source/vtkf.f90 b/Source/vtkf.f90 index 98e01719cac..74db6a9bdc6 100644 --- a/Source/vtkf.f90 +++ b/Source/vtkf.f90 @@ -3390,295 +3390,6 @@ PURE SUBROUTINE B64_DECODE_STRING_A(CODE, S) -!< FACE, FORTRAN ANSI COLORS ENVIRONMENT. -MODULE FACE -!< FACE, FORTRAN ANSI COLORS ENVIRONMENT. -USE, INTRINSIC :: ISO_FORTRAN_ENV, ONLY: INT32 - -IMPLICIT NONE -PRIVATE -PUBLIC :: COLORIZE -PUBLIC :: COLORS_SAMPLES -PUBLIC :: STYLES_SAMPLES -PUBLIC :: ASCII -PUBLIC :: UCS4 - -INTERFACE COLORIZE -#if defined ASCII_SUPPORTED && defined ASCII_NEQ_DEFAULT - MODULE PROCEDURE COLORIZE_ASCII - MODULE PROCEDURE COLORIZE_DEFAULT -#else - MODULE PROCEDURE COLORIZE_DEFAULT -#endif -#ifdef UCS4_SUPPORTED - MODULE PROCEDURE COLORIZE_UCS4 -#endif -ENDINTERFACE - -! KIND PARAMETERS -#ifdef ASCII_SUPPORTED -INTEGER, PARAMETER :: ASCII = SELECTED_CHAR_KIND('ASCII') !< ASCII CHARACTER SET KIND. -#else -INTEGER, PARAMETER :: ASCII = SELECTED_CHAR_KIND('DEFAULT') !< ASCII CHARACTER SET KIND. -#endif -#ifdef UCS4_SUPPORTED -INTEGER, PARAMETER :: UCS4 = SELECTED_CHAR_KIND('ISO_10646') !< UNICODE CHARACTER SET KIND. -#else -INTEGER, PARAMETER :: UCS4 = SELECTED_CHAR_KIND('DEFAULT') !< UNICODE CHARACTER SET KIND. -#endif -! PARAMETERS -CHARACTER(26), PARAMETER :: UPPER_ALPHABET='ABCDEFGHIJKLMNOPQRSTUVWXYZ' !< UPPER CASE ALPHABET. -CHARACTER(26), PARAMETER :: LOWER_ALPHABET='ABCDEFGHIJKLMNOPQRSTUVWXYZ' !< LOWER CASE ALPHABET. -CHARACTER(1), PARAMETER :: NL=NEW_LINE('A') !< NEW LINE CHARACTER. -CHARACTER(1), PARAMETER :: ESCAPE=ACHAR(27) !< "\" CHARACTER. -! CODES -CHARACTER(2), PARAMETER :: CODE_START=ESCAPE//'[' !< START ANSI CODE, "\[". -CHARACTER(1), PARAMETER :: CODE_END='M' !< END ANSI CODE, "M". -CHARACTER(4), PARAMETER :: CODE_CLEAR=CODE_START//'0'//CODE_END !< CLEAR ALL STYLES, "\[0M". -! STYLES CODES -CHARACTER(17), PARAMETER :: STYLES(1:2,1:16)=RESHAPE([& - 'BOLD_ON ','1 ', & ! BOLD ON. - 'ITALICS_ON ','3 ', & ! ITALICS ON. - 'UNDERLINE_ON ','4 ', & ! UNDERLINE ON. - 'INVERSE_ON ','7 ', & ! INVERSE ON: REVERSE FOREGROUND AND BACKGROUND COLORS. - 'STRIKETHROUGH_ON ','9 ', & ! STRIKETHROUGH ON. - 'BOLD_OFF ','22 ', & ! BOLD OFF. - 'ITALICS_OFF ','23 ', & ! ITALICS OFF. - 'UNDERLINE_OFF ','24 ', & ! UNDERLINE OFF. - 'INVERSE_OFF ','27 ', & ! INVERSE OFF: REVERSE FOREGROUND AND BACKGROUND COLORS. - 'STRIKETHROUGH_OFF','29 ', & ! STRIKETHROUGH OFF. - 'FRAMED_ON ','51 ', & ! FRAMED ON. - 'ENCIRCLED_ON ','52 ', & ! ENCIRCLED ON. - 'OVERLINED_ON ','53 ', & ! OVERLINED ON. - 'FRAMED_OFF ','54 ', & ! FRAMED OFF. - 'ENCIRCLED_OFF ','54 ', & ! ENCIRCLED OFF. - 'OVERLINED_OFF ','55 ' & ! OVERLINED OFF. - ], [2,16]) !< STYLES. -! COLORS CODES -CHARACTER(15), PARAMETER :: COLORS_FG(1:2,1:17)=RESHAPE([& - 'BLACK ','30 ', & ! BLACK. - 'RED ','31 ', & ! RED. - 'GREEN ','32 ', & ! GREEN. - 'YELLOW ','33 ', & ! YELLOW. - 'BLUE ','34 ', & ! BLUE. - 'MAGENTA ','35 ', & ! MAGENTA. - 'CYAN ','36 ', & ! CYAN. - 'WHITE ','37 ', & ! WHITE. - 'DEFAULT ','39 ', & ! DEFAULT (WHITE). - 'BLACK_INTENSE ','90 ', & ! BLACK INTENSE. - 'RED_INTENSE ','91 ', & ! RED INTENSE. - 'GREEN_INTENSE ','92 ', & ! GREEN INTENSE. - 'YELLOW_INTENSE ','93 ', & ! YELLOW INTENSE. - 'BLUE_INTENSE ','94 ', & ! BLUE INTENSE. - 'MAGENTA_INTENSE','95 ', & ! MAGENTA INTENSE. - 'CYAN_INTENSE ','96 ', & ! CYAN INTENSE. - 'WHITE_INTENSE ','97 ' & ! WHITE INTENSE. - ], [2,17]) !< FOREGROUND COLORS. -CHARACTER(15), PARAMETER :: COLORS_BG(1:2,1:17)=RESHAPE([& - 'BLACK ','40 ', & ! BLACK. - 'RED ','41 ', & ! RED. - 'GREEN ','42 ', & ! GREEN. - 'YELLOW ','43 ', & ! YELLOW. - 'BLUE ','44 ', & ! BLUE. - 'MAGENTA ','45 ', & ! MAGENTA. - 'CYAN ','46 ', & ! CYAN. - 'WHITE ','47 ', & ! WHITE. - 'DEFAULT ','49 ', & ! DEFAULT (BLACK). - 'BLACK_INTENSE ','100 ', & ! BLACK INTENSE. - 'RED_INTENSE ','101 ', & ! RED INTENSE. - 'GREEN_INTENSE ','102 ', & ! GREEN INTENSE. - 'YELLOW_INTENSE ','103 ', & ! YELLOW INTENSE. - 'BLUE_INTENSE ','104 ', & ! BLUE INTENSE. - 'MAGENTA_INTENSE','105 ', & ! MAGENTA INTENSE. - 'CYAN_INTENSE ','106 ', & ! CYAN INTENSE. - 'WHITE_INTENSE ','107 ' & ! WHITE INTENSE. - ], [2,17]) !< BACKGROUND COLORS. -CONTAINS - ! PUBLIC PROCEDURES - SUBROUTINE COLORS_SAMPLES() - !< PRINT TO STANDARD OUTPUT ALL COLORS SAMPLES. - INTEGER(INT32) :: C !< COUNTER. - - PRINT '(A)', COLORIZE('FOREGROUND COLORS SAMPLES', COLOR_FG='RED_INTENSE') - DO C=1, SIZE(COLORS_FG, DIM=2) - PRINT '(A)', ' COLORIZE("'//COLORS_FG(1, C)//'", COLOR_FG="'//COLORS_FG(1, C)//'") => '//& - COLORIZE(COLORS_FG(1, C), COLOR_FG=COLORS_FG(1, C))//& - ' CODE: '//COLORIZE(TRIM(COLORS_FG(2, C)), COLOR_FG=COLORS_FG(1, C), STYLE='INVERSE_ON') - ENDDO - PRINT '(A)', COLORIZE('BACKGROUND COLORS SAMPLES', COLOR_FG='RED_INTENSE') - DO C=1, SIZE(COLORS_BG, DIM=2) - PRINT '(A)', ' COLORIZE("'//COLORS_BG(1, C)//'", COLOR_BG="'//COLORS_BG(1, C)//'") => '//& - COLORIZE(COLORS_BG(1, C), COLOR_BG=COLORS_BG(1, C))//& - ' CODE: '//COLORIZE(TRIM(COLORS_BG(2, C)), COLOR_BG=COLORS_BG(1, C), STYLE='INVERSE_ON') - ENDDO - ENDSUBROUTINE COLORS_SAMPLES - - SUBROUTINE STYLES_SAMPLES() - !< PRINT TO STANDARD OUTPUT ALL STYLES SAMPLES. - INTEGER(INT32) :: S !< COUNTER. - - PRINT '(A)', COLORIZE('STYLES SAMPLES', COLOR_FG='RED_INTENSE') - DO S=1, SIZE(STYLES, DIM=2) - PRINT '(A)', ' COLORIZE("'//STYLES(1, S)//'", STYLE="'//STYLES(1, S)//'") => '//& - COLORIZE(STYLES(1, S), STYLE=STYLES(1, S))//& - ' CODE: '//COLORIZE(TRIM(STYLES(2, S)), COLOR_FG='MAGENTA', STYLE='INVERSE_ON') - ENDDO - ENDSUBROUTINE STYLES_SAMPLES - - ! PRIVATE PROCEDURES - PURE FUNCTION COLORIZE_ASCII(STRING, COLOR_FG, COLOR_BG, STYLE) RESULT(COLORIZED) - !< COLORIZE AND STYLIZE STRINGS, ASCII KIND. - CHARACTER(LEN=*, KIND=ASCII), INTENT(IN) :: STRING !< INPUT STRING. - CHARACTER(LEN=*), INTENT(IN), OPTIONAL :: COLOR_FG !< FOREGROUND COLOR DEFINITION. - CHARACTER(LEN=*), INTENT(IN), OPTIONAL :: COLOR_BG !< BACKGROUND COLOR DEFINITION. - CHARACTER(LEN=*), INTENT(IN), OPTIONAL :: STYLE !< STYLE DEFINITION. - CHARACTER(LEN=:, KIND=ASCII), ALLOCATABLE :: COLORIZED !< COLORIZED STRING. - CHARACTER(LEN=:, KIND=ASCII), ALLOCATABLE :: BUFFER !< TEMPORARY BUFFER. - INTEGER(INT32) :: I !< COUNTER. - - COLORIZED = STRING - IF (PRESENT(COLOR_FG)) THEN - I = COLOR_INDEX(UPPER(COLOR_FG)) - IF (I>0) THEN - BUFFER = CODE_START//TRIM(COLORS_FG(2, I))//CODE_END - COLORIZED = BUFFER//COLORIZED - BUFFER = CODE_CLEAR - COLORIZED = COLORIZED//BUFFER - ENDIF - ENDIF - IF (PRESENT(COLOR_BG)) THEN - I = COLOR_INDEX(UPPER(COLOR_BG)) - IF (I>0) THEN - BUFFER = CODE_START//TRIM(COLORS_BG(2, I))//CODE_END - COLORIZED = BUFFER//COLORIZED - BUFFER = CODE_CLEAR - COLORIZED = COLORIZED//BUFFER - ENDIF - ENDIF - IF (PRESENT(STYLE)) THEN - I = STYLE_INDEX(UPPER(STYLE)) - IF (I>0) THEN - BUFFER = CODE_START//TRIM(STYLES(2, I))//CODE_END - COLORIZED = BUFFER//COLORIZED - BUFFER = CODE_CLEAR - COLORIZED = COLORIZED//BUFFER - ENDIF - ENDIF - ENDFUNCTION COLORIZE_ASCII - - PURE FUNCTION COLORIZE_DEFAULT(STRING, COLOR_FG, COLOR_BG, STYLE) RESULT(COLORIZED) - !< COLORIZE AND STYLIZE STRINGS, DEFAULT KIND. - CHARACTER(LEN=*), INTENT(IN) :: STRING !< INPUT STRING. - CHARACTER(LEN=*), INTENT(IN), OPTIONAL :: COLOR_FG !< FOREGROUND COLOR DEFINITION. - CHARACTER(LEN=*), INTENT(IN), OPTIONAL :: COLOR_BG !< BACKGROUND COLOR DEFINITION. - CHARACTER(LEN=*), INTENT(IN), OPTIONAL :: STYLE !< STYLE DEFINITION. - CHARACTER(LEN=:), ALLOCATABLE :: COLORIZED !< COLORIZED STRING. - INTEGER(INT32) :: I !< COUNTER. - - COLORIZED = STRING - IF (PRESENT(COLOR_FG)) THEN - I = COLOR_INDEX(UPPER(COLOR_FG)) - IF (I>0) COLORIZED = CODE_START//TRIM(COLORS_FG(2, I))//CODE_END//COLORIZED//CODE_CLEAR - ENDIF - IF (PRESENT(COLOR_BG)) THEN - I = COLOR_INDEX(UPPER(COLOR_BG)) - IF (I>0) COLORIZED = CODE_START//TRIM(COLORS_BG(2, I))//CODE_END//COLORIZED//CODE_CLEAR - ENDIF - IF (PRESENT(STYLE)) THEN - I = STYLE_INDEX(UPPER(STYLE)) - IF (I>0) COLORIZED = CODE_START//TRIM(STYLES(2, I))//CODE_END//COLORIZED//CODE_CLEAR - ENDIF - ENDFUNCTION COLORIZE_DEFAULT - - PURE FUNCTION COLORIZE_UCS4(STRING, COLOR_FG, COLOR_BG, STYLE) RESULT(COLORIZED) - !< COLORIZE AND STYLIZE STRINGS, UCS4 KIND. - CHARACTER(LEN=*, KIND=UCS4), INTENT(IN) :: STRING !< INPUT STRING. - CHARACTER(LEN=*), INTENT(IN), OPTIONAL :: COLOR_FG !< FOREGROUND COLOR DEFINITION. - CHARACTER(LEN=*), INTENT(IN), OPTIONAL :: COLOR_BG !< BACKGROUND COLOR DEFINITION. - CHARACTER(LEN=*), INTENT(IN), OPTIONAL :: STYLE !< STYLE DEFINITION. - CHARACTER(LEN=:, KIND=UCS4), ALLOCATABLE :: COLORIZED !< COLORIZED STRING. - CHARACTER(LEN=:, KIND=UCS4), ALLOCATABLE :: BUFFER !< TEMPORARY BUFFER. - INTEGER(INT32) :: I !< COUNTER. - - COLORIZED = STRING - IF (PRESENT(COLOR_FG)) THEN - I = COLOR_INDEX(UPPER(COLOR_FG)) - IF (I>0) THEN - BUFFER = CODE_START//TRIM(COLORS_FG(2, I))//CODE_END - COLORIZED = BUFFER//COLORIZED - BUFFER = CODE_CLEAR - COLORIZED = COLORIZED//BUFFER - ENDIF - ENDIF - IF (PRESENT(COLOR_BG)) THEN - I = COLOR_INDEX(UPPER(COLOR_BG)) - IF (I>0) THEN - BUFFER = CODE_START//TRIM(COLORS_BG(2, I))//CODE_END - COLORIZED = BUFFER//COLORIZED - BUFFER = CODE_CLEAR - COLORIZED = COLORIZED//BUFFER - ENDIF - ENDIF - IF (PRESENT(STYLE)) THEN - I = STYLE_INDEX(UPPER(STYLE)) - IF (I>0) THEN - BUFFER = CODE_START//TRIM(STYLES(2, I))//CODE_END - COLORIZED = BUFFER//COLORIZED - BUFFER = CODE_CLEAR - COLORIZED = COLORIZED//BUFFER - ENDIF - ENDIF - ENDFUNCTION COLORIZE_UCS4 - - ELEMENTAL FUNCTION COLOR_INDEX(COLOR) - !< RETURN THE ARRAY-INDEX CORRESPONDING TO THE QUERIED COLOR. - !< - !< @NOTE BECAUSE FOREGROUND AND BACKROUND COLORS LISTS SHARE THE SAME NAME, NO MATTER WHAT ARRAY IS USED TO FIND THE COLOR INDEX. - !< THUS, THE FOREGROUND ARRAY IS USED. - CHARACTER(LEN=*), INTENT(IN) :: COLOR !< COLOR DEFINITION. - INTEGER(INT32) :: COLOR_INDEX !< INDEX INTO THE COLORS ARRAYS. - INTEGER(INT32) :: C !< COUNTER. - - COLOR_INDEX = 0 - DO C=1, SIZE(COLORS_FG, DIM=2) - IF (TRIM(COLORS_FG(1, C))==TRIM(ADJUSTL(COLOR))) THEN - COLOR_INDEX = C - EXIT - ENDIF - ENDDO - ENDFUNCTION COLOR_INDEX - - ELEMENTAL FUNCTION STYLE_INDEX(STYLE) - !< RETURN THE ARRAY-INDEX CORRESPONDING TO THE QUERIED STYLE. - CHARACTER(LEN=*), INTENT(IN) :: STYLE !< STYLE DEFINITION. - INTEGER(INT32) :: STYLE_INDEX !< INDEX INTO THE STYLES ARRAY. - INTEGER(INT32) :: S !< COUNTER. - - STYLE_INDEX = 0 - DO S=1, SIZE(STYLES, DIM=2) - IF (TRIM(STYLES(1, S))==TRIM(ADJUSTL(STYLE))) THEN - STYLE_INDEX = S - EXIT - ENDIF - ENDDO - ENDFUNCTION STYLE_INDEX - - ELEMENTAL FUNCTION UPPER(STRING) - !< RETURN A STRING WITH ALL UPPERCASE CHARACTERS. - CHARACTER(LEN=*), INTENT(IN) :: STRING !< INPUT STRING. - CHARACTER(LEN=LEN(STRING)) :: UPPER !< UPPER CASE STRING. - INTEGER :: N1 !< CHARACTERS COUNTER. - INTEGER :: N2 !< CHARACTERS COUNTER. - - UPPER = STRING - DO N1=1, LEN(STRING) - N2 = INDEX(LOWER_ALPHABET, STRING(N1:N1)) - IF (N2>0) UPPER(N1:N1) = UPPER_ALPHABET(N2:N2) - ENDDO - ENDFUNCTION UPPER -ENDMODULE FACE - - @@ -3687,7 +3398,6 @@ MODULE STRINGIFOR_STRING_T !< STRINGIFOR, DEFINITION OF `STRING` TYPE. USE, INTRINSIC :: ISO_FORTRAN_ENV, ONLY : IOSTAT_EOR USE BEFOR64, ONLY : B64_DECODE, B64_ENCODE -USE FACE, ONLY : COLORIZE USE PENF, ONLY : I1P, I2P, I4P, I8P, R4P, R8P, R16P, STR IMPLICIT NONE @@ -3730,8 +3440,6 @@ MODULE STRINGIFOR_STRING_T PROCEDURE, PASS(SELF) :: CAMELCASE !< RETURN A STRING WITH ALL WORDS CAPITALIZED WITHOUT SPACES. PROCEDURE, PASS(SELF) :: CAPITALIZE !< RETURN A STRING WITH ITS FIRST CHARACTER CAPITALIZED AND THE REST LOWERCASED. PROCEDURE, PASS(SELF) :: CHARS !< RETURN THE RAW CHARACTERS DATA. - GENERIC :: COLORIZE => & - COLORIZE_STR !< COLORIZE AND STYLIZE STRINGS. PROCEDURE, PASS(SELF) :: DECODE !< DECODE STRING. PROCEDURE, PASS(SELF) :: ENCODE !< ENCODE STRING. PROCEDURE, PASS(SELF) :: ESCAPE !< ESCAPE BACKSLASHES (OR CUSTOM ESCAPE CHARACTER). @@ -3849,7 +3557,6 @@ MODULE STRINGIFOR_STRING_T PROCEDURE, PRIVATE, PASS(SELF) :: SVERIFY_STRING_STRING !< VERIFY REPLACEMENT. PROCEDURE, PRIVATE, PASS(SELF) :: SVERIFY_STRING_CHARACTER !< VERIFY REPLACEMENT. ! AUXILIARY METHODS - PROCEDURE, PRIVATE, PASS(SELF) :: COLORIZE_STR !< COLORIZE AND STYLIZE STRINGS. PROCEDURE, PRIVATE, PASS(SELF) :: GLOB_CHARACTER !< GLOB SEARCH (CHARACTER OUTPUT). PROCEDURE, PRIVATE, PASS(SELF) :: GLOB_STRING !< GLOB SEARCH (STRING OUTPUT). PROCEDURE, PRIVATE, PASS(SELF) :: INSERT_STRING !< INSERT SUBSTRING INTO STRING AT A SPECIFIED POSITION. @@ -4649,24 +4356,6 @@ PURE FUNCTION CHARS(SELF) RESULT(RAW) ENDIF ENDFUNCTION CHARS - PURE FUNCTION COLORIZE_STR(SELF, COLOR_FG, COLOR_BG, STYLE) RESULT(COLORIZED) - !< COLORIZE AND STYLIZE STRINGS, DEFAULT KIND. - !< - !<```FORTRAN - !< TYPE(STRING) :: ASTRING - !< ASTRING = 'SAY ALL HELLO WORLD!' - !< PRINT '(L1)', ASTRING%COLORIZE(COLOR_FG='RED')=='[31MSAY ALL HELLO WORLD![0M' - !<``` - !=> T <<< - CLASS(STRING), INTENT(IN) :: SELF !< THE STRING. - CHARACTER(LEN=*), INTENT(IN), OPTIONAL :: COLOR_FG !< FOREGROUND COLOR DEFINITION. - CHARACTER(LEN=*), INTENT(IN), OPTIONAL :: COLOR_BG !< BACKGROUND COLOR DEFINITION. - CHARACTER(LEN=*), INTENT(IN), OPTIONAL :: STYLE !< STYLE DEFINITION. - CHARACTER(LEN=:), ALLOCATABLE :: COLORIZED !< COLORIZED STRING. - - COLORIZED = COLORIZE(STRING=SELF%CHARS(), COLOR_FG=COLOR_FG, COLOR_BG=COLOR_BG, STYLE=STYLE) - ENDFUNCTION COLORIZE_STR - ELEMENTAL FUNCTION DECODE(SELF, CODEC) RESULT(DECODED) !< RETURN A STRING DECODED ACCORDINGLY THE CODEC. !< @@ -9539,65 +9228,21 @@ MODULE VTKF_FILE_XML_WRITER_ABSTRACT W_DATA1_RANK1_I4P, & W_DATA1_RANK1_I2P, & W_DATA1_RANK1_I1P, & - W_DATA1_RANK2_R8P, & - W_DATA1_RANK2_R4P, & - W_DATA1_RANK2_I8P, & - W_DATA1_RANK2_I4P, & - W_DATA1_RANK2_I2P, & - W_DATA1_RANK2_I1P, & - W_DATA1_RANK3_R8P, & - W_DATA1_RANK3_R4P, & - W_DATA1_RANK3_I8P, & - W_DATA1_RANK3_I4P, & - W_DATA1_RANK3_I2P, & - W_DATA1_RANK3_I1P, & - W_DATA1_RANK4_R8P, & - W_DATA1_RANK4_R4P, & - W_DATA1_RANK4_I8P, & - W_DATA1_RANK4_I4P, & - W_DATA1_RANK4_I2P, & - W_DATA1_RANK4_I1P, & W_DATA3_RANK1_R8P, & W_DATA3_RANK1_R4P, & W_DATA3_RANK1_I8P, & W_DATA3_RANK1_I4P, & W_DATA3_RANK1_I2P, & W_DATA3_RANK1_I1P, & - W_DATA3_RANK3_R8P, & - W_DATA3_RANK3_R4P, & - W_DATA3_RANK3_I8P, & - W_DATA3_RANK3_I4P, & - W_DATA3_RANK3_I2P, & - W_DATA3_RANK3_I1P, & - W_DATA6_RANK1_R8P, & - W_DATA6_RANK1_R4P, & - W_DATA6_RANK1_I8P, & - W_DATA6_RANK1_I4P, & - W_DATA6_RANK1_I2P, & - W_DATA6_RANK1_I1P, & - W_DATA6_RANK3_R8P, & - W_DATA6_RANK3_R4P, & - W_DATA6_RANK3_I8P, & - W_DATA6_RANK3_I4P, & - W_DATA6_RANK3_I2P, & - W_DATA6_RANK3_I1P, & W_DATA_LOCATION_TAG !< WRITE DATA (ARRAY). GENERIC :: WRITE_FIELDDATA => & WRITE_FIELDDATA1_RANK0, & WRITE_FIELDDATA_TAG !< WRITE FIELDDATA TAG. GENERIC :: WRITE_GEO => & - WRITE_GEO_STRG_DATA1_RANK2_R8P, & - WRITE_GEO_STRG_DATA1_RANK2_R4P, & - WRITE_GEO_STRG_DATA1_RANK4_R8P, & - WRITE_GEO_STRG_DATA1_RANK4_R4P, & WRITE_GEO_STRG_DATA3_RANK1_R8P, & WRITE_GEO_STRG_DATA3_RANK1_R4P, & - WRITE_GEO_STRG_DATA3_RANK3_R8P, & - WRITE_GEO_STRG_DATA3_RANK3_R4P, & WRITE_GEO_RECT_DATA3_RANK1_R8P, & WRITE_GEO_RECT_DATA3_RANK1_R4P, & - WRITE_GEO_UNST_DATA1_RANK2_R8P, & - WRITE_GEO_UNST_DATA1_RANK2_R4P, & WRITE_GEO_UNST_DATA3_RANK1_R8P, & WRITE_GEO_UNST_DATA3_RANK1_R4P !< WRITE MESH. GENERIC :: WRITE_PARALLEL_BLOCK_FILES => & @@ -9615,68 +9260,22 @@ MODULE VTKF_FILE_XML_WRITER_ABSTRACT PROCEDURE(W_DATA1_RANK1_I4P_INTERFACE), DEFERRED, PASS(SELF) :: W_DATA1_RANK1_I4P !< DATA 1, RANK 1, I4P. PROCEDURE(W_DATA1_RANK1_I2P_INTERFACE), DEFERRED, PASS(SELF) :: W_DATA1_RANK1_I2P !< DATA 1, RANK 1, I2P. PROCEDURE(W_DATA1_RANK1_I1P_INTERFACE), DEFERRED, PASS(SELF) :: W_DATA1_RANK1_I1P !< DATA 1, RANK 1, I1P. - PROCEDURE(W_DATA1_RANK2_R8P_INTERFACE), DEFERRED, PASS(SELF) :: W_DATA1_RANK2_R8P !< DATA 1, RANK 2, R8P. - PROCEDURE(W_DATA1_RANK2_R4P_INTERFACE), DEFERRED, PASS(SELF) :: W_DATA1_RANK2_R4P !< DATA 1, RANK 2, R4P. - PROCEDURE(W_DATA1_RANK2_I8P_INTERFACE), DEFERRED, PASS(SELF) :: W_DATA1_RANK2_I8P !< DATA 1, RANK 2, I8P. - PROCEDURE(W_DATA1_RANK2_I4P_INTERFACE), DEFERRED, PASS(SELF) :: W_DATA1_RANK2_I4P !< DATA 1, RANK 2, I4P. - PROCEDURE(W_DATA1_RANK2_I2P_INTERFACE), DEFERRED, PASS(SELF) :: W_DATA1_RANK2_I2P !< DATA 1, RANK 2, I2P. - PROCEDURE(W_DATA1_RANK2_I1P_INTERFACE), DEFERRED, PASS(SELF) :: W_DATA1_RANK2_I1P !< DATA 1, RANK 2, I1P. - PROCEDURE(W_DATA1_RANK3_R8P_INTERFACE), DEFERRED, PASS(SELF) :: W_DATA1_RANK3_R8P !< DATA 1, RANK 3, R8P. - PROCEDURE(W_DATA1_RANK3_R4P_INTERFACE), DEFERRED, PASS(SELF) :: W_DATA1_RANK3_R4P !< DATA 1, RANK 3, R4P. - PROCEDURE(W_DATA1_RANK3_I8P_INTERFACE), DEFERRED, PASS(SELF) :: W_DATA1_RANK3_I8P !< DATA 1, RANK 3, I8P. - PROCEDURE(W_DATA1_RANK3_I4P_INTERFACE), DEFERRED, PASS(SELF) :: W_DATA1_RANK3_I4P !< DATA 1, RANK 3, I4P. - PROCEDURE(W_DATA1_RANK3_I2P_INTERFACE), DEFERRED, PASS(SELF) :: W_DATA1_RANK3_I2P !< DATA 1, RANK 3, I2P. - PROCEDURE(W_DATA1_RANK3_I1P_INTERFACE), DEFERRED, PASS(SELF) :: W_DATA1_RANK3_I1P !< DATA 1, RANK 3, I1P. - PROCEDURE(W_DATA1_RANK4_R8P_INTERFACE), DEFERRED, PASS(SELF) :: W_DATA1_RANK4_R8P !< DATA 1, RANK 4, R8P. - PROCEDURE(W_DATA1_RANK4_R4P_INTERFACE), DEFERRED, PASS(SELF) :: W_DATA1_RANK4_R4P !< DATA 1, RANK 4, R4P. - PROCEDURE(W_DATA1_RANK4_I8P_INTERFACE), DEFERRED, PASS(SELF) :: W_DATA1_RANK4_I8P !< DATA 1, RANK 4, I8P. - PROCEDURE(W_DATA1_RANK4_I4P_INTERFACE), DEFERRED, PASS(SELF) :: W_DATA1_RANK4_I4P !< DATA 1, RANK 4, I4P. - PROCEDURE(W_DATA1_RANK4_I2P_INTERFACE), DEFERRED, PASS(SELF) :: W_DATA1_RANK4_I2P !< DATA 1, RANK 4, I2P. - PROCEDURE(W_DATA1_RANK4_I1P_INTERFACE), DEFERRED, PASS(SELF) :: W_DATA1_RANK4_I1P !< DATA 1, RANK 4, I1P. PROCEDURE(W_DATA3_RANK1_R8P_INTERFACE), DEFERRED, PASS(SELF) :: W_DATA3_RANK1_R8P !< DATA 3, RANK 1, R8P. PROCEDURE(W_DATA3_RANK1_R4P_INTERFACE), DEFERRED, PASS(SELF) :: W_DATA3_RANK1_R4P !< DATA 3, RANK 1, R4P. PROCEDURE(W_DATA3_RANK1_I8P_INTERFACE), DEFERRED, PASS(SELF) :: W_DATA3_RANK1_I8P !< DATA 3, RANK 1, I8P. PROCEDURE(W_DATA3_RANK1_I4P_INTERFACE), DEFERRED, PASS(SELF) :: W_DATA3_RANK1_I4P !< DATA 3, RANK 1, I4P. PROCEDURE(W_DATA3_RANK1_I2P_INTERFACE), DEFERRED, PASS(SELF) :: W_DATA3_RANK1_I2P !< DATA 3, RANK 1, I2P. PROCEDURE(W_DATA3_RANK1_I1P_INTERFACE), DEFERRED, PASS(SELF) :: W_DATA3_RANK1_I1P !< DATA 3, RANK 1, I1P. - PROCEDURE(W_DATA3_RANK3_R8P_INTERFACE), DEFERRED, PASS(SELF) :: W_DATA3_RANK3_R8P !< DATA 3, RANK 3, R8P. - PROCEDURE(W_DATA3_RANK3_R4P_INTERFACE), DEFERRED, PASS(SELF) :: W_DATA3_RANK3_R4P !< DATA 3, RANK 3, R4P. - PROCEDURE(W_DATA3_RANK3_I8P_INTERFACE), DEFERRED, PASS(SELF) :: W_DATA3_RANK3_I8P !< DATA 3, RANK 3, I8P. - PROCEDURE(W_DATA3_RANK3_I4P_INTERFACE), DEFERRED, PASS(SELF) :: W_DATA3_RANK3_I4P !< DATA 3, RANK 3, I4P. - PROCEDURE(W_DATA3_RANK3_I2P_INTERFACE), DEFERRED, PASS(SELF) :: W_DATA3_RANK3_I2P !< DATA 3, RANK 3, I2P. - PROCEDURE(W_DATA3_RANK3_I1P_INTERFACE), DEFERRED, PASS(SELF) :: W_DATA3_RANK3_I1P !< DATA 3, RANK 3, I1P. - PROCEDURE(W_DATA6_RANK1_R8P_INTERFACE), DEFERRED, PASS(SELF) :: W_DATA6_RANK1_R8P !< DATA 3, RANK 1, R8P. - PROCEDURE(W_DATA6_RANK1_R4P_INTERFACE), DEFERRED, PASS(SELF) :: W_DATA6_RANK1_R4P !< DATA 3, RANK 1, R4P. - PROCEDURE(W_DATA6_RANK1_I8P_INTERFACE), DEFERRED, PASS(SELF) :: W_DATA6_RANK1_I8P !< DATA 3, RANK 1, I8P. - PROCEDURE(W_DATA6_RANK1_I4P_INTERFACE), DEFERRED, PASS(SELF) :: W_DATA6_RANK1_I4P !< DATA 3, RANK 1, I4P. - PROCEDURE(W_DATA6_RANK1_I2P_INTERFACE), DEFERRED, PASS(SELF) :: W_DATA6_RANK1_I2P !< DATA 3, RANK 1, I2P. - PROCEDURE(W_DATA6_RANK1_I1P_INTERFACE), DEFERRED, PASS(SELF) :: W_DATA6_RANK1_I1P !< DATA 3, RANK 1, I1P. - PROCEDURE(W_DATA6_RANK3_R8P_INTERFACE), DEFERRED, PASS(SELF) :: W_DATA6_RANK3_R8P !< DATA 3, RANK 3, R8P. - PROCEDURE(W_DATA6_RANK3_R4P_INTERFACE), DEFERRED, PASS(SELF) :: W_DATA6_RANK3_R4P !< DATA 3, RANK 3, R4P. - PROCEDURE(W_DATA6_RANK3_I8P_INTERFACE), DEFERRED, PASS(SELF) :: W_DATA6_RANK3_I8P !< DATA 3, RANK 3, I8P. - PROCEDURE(W_DATA6_RANK3_I4P_INTERFACE), DEFERRED, PASS(SELF) :: W_DATA6_RANK3_I4P !< DATA 3, RANK 3, I4P. - PROCEDURE(W_DATA6_RANK3_I2P_INTERFACE), DEFERRED, PASS(SELF) :: W_DATA6_RANK3_I2P !< DATA 3, RANK 3, I2P. - PROCEDURE(W_DATA6_RANK3_I1P_INTERFACE), DEFERRED, PASS(SELF) :: W_DATA6_RANK3_I1P !< DATA 3, RANK 3, I1P. PROCEDURE(W_DATA_APPENDED_INTERFACE), DEFERRED, PASS(SELF) :: W_DATA_APPENDED !< WRITE APPENDED. ! PRIVATE METHODS PROCEDURE, PASS(SELF), PRIVATE :: WRITE_FIELDDATA1_RANK0 !< WRITE FIELDDATA TAG (DATA 1, RANK 0, R8P). PROCEDURE, PASS(SELF), PRIVATE :: WRITE_FIELDDATA_TAG !< WRITE FIELDDATA TAG. - PROCEDURE, PASS(SELF), PRIVATE :: WRITE_GEO_STRG_DATA1_RANK2_R8P !< WRITE **STRUCTUREDGRID** MESH (DATA 1, RANK 2, R8P). - PROCEDURE, PASS(SELF), PRIVATE :: WRITE_GEO_STRG_DATA1_RANK2_R4P !< WRITE **STRUCTUREDGRID** MESH (DATA 1, RANK 2, R4P). - PROCEDURE, PASS(SELF), PRIVATE :: WRITE_GEO_STRG_DATA1_RANK4_R8P !< WRITE **STRUCTUREDGRID** MESH (DATA 1, RANK 4, R8P). - PROCEDURE, PASS(SELF), PRIVATE :: WRITE_GEO_STRG_DATA1_RANK4_R4P !< WRITE **STRUCTUREDGRID** MESH (DATA 1, RANK 4, R4P). PROCEDURE, PASS(SELF), PRIVATE :: WRITE_GEO_STRG_DATA3_RANK1_R8P !< WRITE **STRUCTUREDGRID** MESH (DATA 3, RANK 1, R8P). PROCEDURE, PASS(SELF), PRIVATE :: WRITE_GEO_STRG_DATA3_RANK1_R4P !< WRITE **STRUCTUREDGRID** MESH (DATA 3, RANK 1, R4P). - PROCEDURE, PASS(SELF), PRIVATE :: WRITE_GEO_STRG_DATA3_RANK3_R8P !< WRITE **STRUCTUREDGRID** MESH (DATA 3, RANK 3, R8P). - PROCEDURE, PASS(SELF), PRIVATE :: WRITE_GEO_STRG_DATA3_RANK3_R4P !< WRITE **STRUCTUREDGRID** MESH (DATA 3, RANK 3, R4P). PROCEDURE, PASS(SELF), PRIVATE :: WRITE_GEO_RECT_DATA3_RANK1_R8P !< WRITE **RECTILINEARGRID** MESH (DATA 3, RANK 1, R8P). PROCEDURE, PASS(SELF), PRIVATE :: WRITE_GEO_RECT_DATA3_RANK1_R4P !< WRITE **RECTILINEARGRID** MESH (DATA 3, RANK 1, R4P). - PROCEDURE, PASS(SELF), PRIVATE :: WRITE_GEO_UNST_DATA1_RANK2_R8P !< WRITE **UNSTRUCTUREDGRID** MESH (DATA 1, RANK 2, R8P). - PROCEDURE, PASS(SELF), PRIVATE :: WRITE_GEO_UNST_DATA1_RANK2_R4P !< WRITE **UNSTRUCTUREDGRID** MESH (DATA 1, RANK 2, R4P). PROCEDURE, PASS(SELF), PRIVATE :: WRITE_GEO_UNST_DATA3_RANK1_R8P !< WRITE **UNSTRUCTUREDGRID** MESH (DATA 3, RANK 1, R8P). PROCEDURE, PASS(SELF), PRIVATE :: WRITE_GEO_UNST_DATA3_RANK1_R4P !< WRITE **UNSTRUCTUREDGRID** MESH (DATA 3, RANK 1, R4P). - PROCEDURE, PASS(SELF), PRIVATE :: WRITE_GEO_POLY_DATA1_RANK2_R8P !< WRITE **POLYDATA** MESH (DATA 1, RANK 2, R8P). - PROCEDURE, PASS(SELF), PRIVATE :: WRITE_GEO_POLY_DATA1_RANK2_R4P !< WRITE **POLYDATA** MESH (DATA 1, RANK 2, R4P). PROCEDURE, PASS(SELF), PRIVATE :: WRITE_GEO_POLY_DATA3_RANK1_R8P !< WRITE **POLYDATA** MESH (DATA 3, RANK 1, R8P). PROCEDURE, PASS(SELF), PRIVATE :: WRITE_GEO_POLY_DATA3_RANK1_R4P !< WRITE **POLYDATA** MESH (DATA 3, RANK 1, R4P). PROCEDURE, PASS(SELF), PRIVATE :: WRITE_PIECE_START_TAG !< WRITE `<PIECE ...>` START TAG. @@ -9774,204 +9373,6 @@ FUNCTION W_DATA1_RANK1_I1P_INTERFACE(SELF, DATA_NAME, X, IS_TUPLES) RESULT(ERROR INTEGER(I4P) :: ERROR !< ERROR STATUS. ENDFUNCTION W_DATA1_RANK1_I1P_INTERFACE - FUNCTION W_DATA1_RANK2_R8P_INTERFACE(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR) - !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (R8P). - IMPORT :: XML_WRITER_ABSTRACT, I4P, R8P - CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT) :: SELF !< WRITER. - CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. - REAL(R8P), INTENT(IN) :: X(1:,1:) !< DATA VARIABLE. - LOGICAL, INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT. - LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". - INTEGER(I4P) :: ERROR !< ERROR STATUS. - ENDFUNCTION W_DATA1_RANK2_R8P_INTERFACE - - FUNCTION W_DATA1_RANK2_R4P_INTERFACE(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR) - !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (R4P). - IMPORT :: XML_WRITER_ABSTRACT, I4P, R4P - CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT) :: SELF !< WRITER. - CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. - REAL(R4P), INTENT(IN) :: X(1:,1:) !< DATA VARIABLE. - LOGICAL, INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT. - LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". - INTEGER(I4P) :: ERROR !< ERROR STATUS. - ENDFUNCTION W_DATA1_RANK2_R4P_INTERFACE - - FUNCTION W_DATA1_RANK2_I8P_INTERFACE(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR) - !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (I8P). - IMPORT :: XML_WRITER_ABSTRACT, I4P, I8P - CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT) :: SELF !< WRITER. - CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. - INTEGER(I8P), INTENT(IN) :: X(1:,1:) !< DATA VARIABLE. - LOGICAL, INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT. - LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". - INTEGER(I4P) :: ERROR !< ERROR STATUS. - ENDFUNCTION W_DATA1_RANK2_I8P_INTERFACE - - FUNCTION W_DATA1_RANK2_I4P_INTERFACE(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR) - !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (I4P). - IMPORT :: XML_WRITER_ABSTRACT, I4P - CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT) :: SELF !< WRITER. - CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. - INTEGER(I4P), INTENT(IN) :: X(1:,1:) !< DATA VARIABLE. - LOGICAL, INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT. - LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". - INTEGER(I4P) :: ERROR !< ERROR STATUS. - ENDFUNCTION W_DATA1_RANK2_I4P_INTERFACE - - FUNCTION W_DATA1_RANK2_I2P_INTERFACE(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR) - !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (I2P). - IMPORT :: XML_WRITER_ABSTRACT, I2P, I4P - CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT) :: SELF !< WRITER. - CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. - INTEGER(I2P), INTENT(IN) :: X(1:,1:) !< DATA VARIABLE. - LOGICAL, INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT. - LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". - INTEGER(I4P) :: ERROR !< ERROR STATUS. - ENDFUNCTION W_DATA1_RANK2_I2P_INTERFACE - - FUNCTION W_DATA1_RANK2_I1P_INTERFACE(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR) - !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (I1P). - IMPORT :: XML_WRITER_ABSTRACT, I1P, I4P - CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT) :: SELF !< WRITER. - CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. - INTEGER(I1P), INTENT(IN) :: X(1:,1:) !< DATA VARIABLE. - LOGICAL, INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT. - LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". - INTEGER(I4P) :: ERROR !< ERROR STATUS. - ENDFUNCTION W_DATA1_RANK2_I1P_INTERFACE - - FUNCTION W_DATA1_RANK3_R8P_INTERFACE(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR) - !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (R8P). - IMPORT :: XML_WRITER_ABSTRACT, I4P, R8P - CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT) :: SELF !< WRITER. - CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. - REAL(R8P), INTENT(IN) :: X(1:,1:,1:) !< DATA VARIABLE. - LOGICAL, INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT. - LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". - INTEGER(I4P) :: ERROR !< ERROR STATUS. - ENDFUNCTION W_DATA1_RANK3_R8P_INTERFACE - - FUNCTION W_DATA1_RANK3_R4P_INTERFACE(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR) - !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (R4P). - IMPORT :: XML_WRITER_ABSTRACT, I4P, R4P - CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT) :: SELF !< WRITER. - CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. - REAL(R4P), INTENT(IN) :: X(1:,1:,1:) !< DATA VARIABLE. - LOGICAL, INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT. - LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". - INTEGER(I4P) :: ERROR !< ERROR STATUS. - ENDFUNCTION W_DATA1_RANK3_R4P_INTERFACE - - FUNCTION W_DATA1_RANK3_I8P_INTERFACE(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR) - !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (I8P). - IMPORT :: XML_WRITER_ABSTRACT, I4P, I8P - CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT) :: SELF !< WRITER. - CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. - INTEGER(I8P), INTENT(IN) :: X(1:,1:,1:) !< DATA VARIABLE. - LOGICAL, INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT. - LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". - INTEGER(I4P) :: ERROR !< ERROR STATUS. - ENDFUNCTION W_DATA1_RANK3_I8P_INTERFACE - - FUNCTION W_DATA1_RANK3_I4P_INTERFACE(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR) - !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (I4P). - IMPORT :: XML_WRITER_ABSTRACT, I4P - CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT) :: SELF !< WRITER. - CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. - INTEGER(I4P), INTENT(IN) :: X(1:,1:,1:) !< DATA VARIABLE. - LOGICAL, INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT. - LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". - INTEGER(I4P) :: ERROR !< ERROR STATUS. - ENDFUNCTION W_DATA1_RANK3_I4P_INTERFACE - - FUNCTION W_DATA1_RANK3_I2P_INTERFACE(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR) - !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (I2P). - IMPORT :: XML_WRITER_ABSTRACT, I2P, I4P - CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT) :: SELF !< WRITER. - CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. - INTEGER(I2P), INTENT(IN) :: X(1:,1:,1:) !< DATA VARIABLE. - LOGICAL, INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT. - LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". - INTEGER(I4P) :: ERROR !< ERROR STATUS. - ENDFUNCTION W_DATA1_RANK3_I2P_INTERFACE - - FUNCTION W_DATA1_RANK3_I1P_INTERFACE(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR) - !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (I1P). - IMPORT :: XML_WRITER_ABSTRACT, I1P, I4P - CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT) :: SELF !< WRITER. - CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. - INTEGER(I1P), INTENT(IN) :: X(1:,1:,1:) !< DATA VARIABLE. - LOGICAL, INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT. - LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". - INTEGER(I4P) :: ERROR !< ERROR STATUS. - ENDFUNCTION W_DATA1_RANK3_I1P_INTERFACE - - FUNCTION W_DATA1_RANK4_R8P_INTERFACE(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR) - !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (R8P). - IMPORT :: XML_WRITER_ABSTRACT, I4P, R8P - CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT) :: SELF !< WRITER. - CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. - REAL(R8P), INTENT(IN) :: X(1:,1:,1:,1:) !< DATA VARIABLE. - LOGICAL, INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT. - LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". - INTEGER(I4P) :: ERROR !< ERROR STATUS. - ENDFUNCTION W_DATA1_RANK4_R8P_INTERFACE - - FUNCTION W_DATA1_RANK4_R4P_INTERFACE(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR) - !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (R4P). - IMPORT :: XML_WRITER_ABSTRACT, I4P, R4P - CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT) :: SELF !< WRITER. - CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. - REAL(R4P), INTENT(IN) :: X(1:,1:,1:,1:) !< DATA VARIABLE. - LOGICAL, INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT. - LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". - INTEGER(I4P) :: ERROR !< ERROR STATUS. - ENDFUNCTION W_DATA1_RANK4_R4P_INTERFACE - - FUNCTION W_DATA1_RANK4_I8P_INTERFACE(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR) - !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (I8P). - IMPORT :: XML_WRITER_ABSTRACT, I4P, I8P - CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT) :: SELF !< WRITER. - CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. - INTEGER(I8P), INTENT(IN) :: X(1:,1:,1:,1:) !< DATA VARIABLE. - LOGICAL, INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT. - LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". - INTEGER(I4P) :: ERROR !< ERROR STATUS. - ENDFUNCTION W_DATA1_RANK4_I8P_INTERFACE - - FUNCTION W_DATA1_RANK4_I4P_INTERFACE(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR) - !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (I4P). - IMPORT :: XML_WRITER_ABSTRACT, I4P - CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT) :: SELF !< WRITER. - CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. - INTEGER(I4P), INTENT(IN) :: X(1:,1:,1:,1:) !< DATA VARIABLE. - LOGICAL, INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT. - LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". - INTEGER(I4P) :: ERROR !< ERROR STATUS. - ENDFUNCTION W_DATA1_RANK4_I4P_INTERFACE - - FUNCTION W_DATA1_RANK4_I2P_INTERFACE(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR) - !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (I2P). - IMPORT :: XML_WRITER_ABSTRACT, I2P, I4P - CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT) :: SELF !< WRITER. - CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. - INTEGER(I2P), INTENT(IN) :: X(1:,1:,1:,1:) !< DATA VARIABLE. - LOGICAL, INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT. - LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". - INTEGER(I4P) :: ERROR !< ERROR STATUS. - ENDFUNCTION W_DATA1_RANK4_I2P_INTERFACE - - FUNCTION W_DATA1_RANK4_I1P_INTERFACE(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR) - !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (I1P). - IMPORT :: XML_WRITER_ABSTRACT, I1P, I4P - CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT) :: SELF !< WRITER. - CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. - INTEGER(I1P), INTENT(IN) :: X(1:,1:,1:,1:) !< DATA VARIABLE. - LOGICAL, INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT. - LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". - INTEGER(I4P) :: ERROR !< ERROR STATUS. - ENDFUNCTION W_DATA1_RANK4_I1P_INTERFACE - FUNCTION W_DATA3_RANK1_R8P_INTERFACE(SELF, DATA_NAME, X, Y, Z, IS_TUPLES) RESULT(ERROR) !< WRITE `<DATAARRAY... NumberOfComponents="3"...>...</DATAARRAY>` TAG (R8P). IMPORT :: XML_WRITER_ABSTRACT, I4P, R8P @@ -10044,258 +9445,6 @@ FUNCTION W_DATA3_RANK1_I1P_INTERFACE(SELF, DATA_NAME, X, Y, Z, IS_TUPLES) RESULT INTEGER(I4P) :: ERROR !< ERROR STATUS. ENDFUNCTION W_DATA3_RANK1_I1P_INTERFACE - FUNCTION W_DATA3_RANK3_R8P_INTERFACE(SELF, DATA_NAME, X, Y, Z, IS_TUPLES) RESULT(ERROR) - !< WRITE `<DATAARRAY... NumberOfComponents="3"...>...</DATAARRAY>` TAG (R8P). - IMPORT :: XML_WRITER_ABSTRACT, I4P, R8P - CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT) :: SELF !< WRITER. - CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. - REAL(R8P), INTENT(IN) :: X(1:,1:,1:) !< X COMPONENT OF DATA VARIABLE. - REAL(R8P), INTENT(IN) :: Y(1:,1:,1:) !< Y COMPONENT OF DATA VARIABLE. - REAL(R8P), INTENT(IN) :: Z(1:,1:,1:) !< Z COMPONENT OF DATA VARIABLE. - LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". - INTEGER(I4P) :: ERROR !< ERROR STATUS. - ENDFUNCTION W_DATA3_RANK3_R8P_INTERFACE - - FUNCTION W_DATA3_RANK3_R4P_INTERFACE(SELF, DATA_NAME, X, Y, Z, IS_TUPLES) RESULT(ERROR) - !< WRITE `<DATAARRAY... NumberOfComponents="3"...>...</DATAARRAY>` TAG (R4P). - IMPORT :: XML_WRITER_ABSTRACT, I4P, R4P - CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT) :: SELF !< WRITER. - CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. - REAL(R4P), INTENT(IN) :: X(1:,1:,1:) !< X COMPONENT OF DATA VARIABLE. - REAL(R4P), INTENT(IN) :: Y(1:,1:,1:) !< Y COMPONENT OF DATA VARIABLE. - REAL(R4P), INTENT(IN) :: Z(1:,1:,1:) !< Z COMPONENT OF DATA VARIABLE. - LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". - INTEGER(I4P) :: ERROR !< ERROR STATUS. - ENDFUNCTION W_DATA3_RANK3_R4P_INTERFACE - - FUNCTION W_DATA3_RANK3_I8P_INTERFACE(SELF, DATA_NAME, X, Y, Z, IS_TUPLES) RESULT(ERROR) - !< WRITE `<DATAARRAY... NumberOfComponents="3"...>...</DATAARRAY>` TAG (I8P). - IMPORT :: XML_WRITER_ABSTRACT, I4P, I8P - CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT) :: SELF !< WRITER. - CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. - INTEGER(I8P), INTENT(IN) :: X(1:,1:,1:) !< X COMPONENT OF DATA VARIABLE. - INTEGER(I8P), INTENT(IN) :: Y(1:,1:,1:) !< Y COMPONENT OF DATA VARIABLE. - INTEGER(I8P), INTENT(IN) :: Z(1:,1:,1:) !< Z COMPONENT OF DATA VARIABLE. - LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". - INTEGER(I4P) :: ERROR !< ERROR STATUS. - ENDFUNCTION W_DATA3_RANK3_I8P_INTERFACE - - FUNCTION W_DATA3_RANK3_I4P_INTERFACE(SELF, DATA_NAME, X, Y, Z, IS_TUPLES) RESULT(ERROR) - !< WRITE `<DATAARRAY... NumberOfComponents="3"...>...</DATAARRAY>` TAG (I4P). - IMPORT :: XML_WRITER_ABSTRACT, I4P - CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT) :: SELF !< WRITER. - CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. - INTEGER(I4P), INTENT(IN) :: X(1:,1:,1:) !< X COMPONENT OF DATA VARIABLE. - INTEGER(I4P), INTENT(IN) :: Y(1:,1:,1:) !< Y COMPONENT OF DATA VARIABLE. - INTEGER(I4P), INTENT(IN) :: Z(1:,1:,1:) !< Z COMPONENT OF DATA VARIABLE. - LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". - INTEGER(I4P) :: ERROR !< ERROR STATUS. - ENDFUNCTION W_DATA3_RANK3_I4P_INTERFACE - - FUNCTION W_DATA3_RANK3_I2P_INTERFACE(SELF, DATA_NAME, X, Y, Z, IS_TUPLES) RESULT(ERROR) - !< WRITE `<DATAARRAY... NumberOfComponents="3"...>...</DATAARRAY>` TAG (I2P). - IMPORT :: XML_WRITER_ABSTRACT, I2P, I4P - CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT) :: SELF !< WRITER. - CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. - INTEGER(I2P), INTENT(IN) :: X(1:,1:,1:) !< X COMPONENT OF DATA VARIABLE. - INTEGER(I2P), INTENT(IN) :: Y(1:,1:,1:) !< Y COMPONENT OF DATA VARIABLE. - INTEGER(I2P), INTENT(IN) :: Z(1:,1:,1:) !< Z COMPONENT OF DATA VARIABLE. - LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". - INTEGER(I4P) :: ERROR !< ERROR STATUS. - ENDFUNCTION W_DATA3_RANK3_I2P_INTERFACE - - FUNCTION W_DATA3_RANK3_I1P_INTERFACE(SELF, DATA_NAME, X, Y, Z, IS_TUPLES) RESULT(ERROR) - !< WRITE `<DATAARRAY... NumberOfComponents="3"...>...</DATAARRAY>` TAG (I1P). - IMPORT :: XML_WRITER_ABSTRACT, I1P, I4P - CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT) :: SELF !< WRITER. - CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. - INTEGER(I1P), INTENT(IN) :: X(1:,1:,1:) !< X COMPONENT OF DATA VARIABLE. - INTEGER(I1P), INTENT(IN) :: Y(1:,1:,1:) !< Y COMPONENT OF DATA VARIABLE. - INTEGER(I1P), INTENT(IN) :: Z(1:,1:,1:) !< Z COMPONENT OF DATA VARIABLE. - LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". - INTEGER(I4P) :: ERROR !< ERROR STATUS. - ENDFUNCTION W_DATA3_RANK3_I1P_INTERFACE - - FUNCTION W_DATA6_RANK1_R8P_INTERFACE(SELF, DATA_NAME, U, V, W, X, Y, Z, IS_TUPLES) RESULT(ERROR) - !< WRITE `<DATAARRAY... NumberOfComponents="6"...>...</DATAARRAY>` TAG (R8P). - IMPORT :: XML_WRITER_ABSTRACT, I4P, R8P - CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT) :: SELF !< WRITER. - CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. - REAL(R8P), INTENT(IN) :: U(1:) !< U COMPONENT OF DATA VARIABLE. - REAL(R8P), INTENT(IN) :: V(1:) !< V COMPONENT OF DATA VARIABLE. - REAL(R8P), INTENT(IN) :: W(1:) !< W COMPONENT OF DATA VARIABLE. - REAL(R8P), INTENT(IN) :: X(1:) !< X COMPONENT OF DATA VARIABLE. - REAL(R8P), INTENT(IN) :: Y(1:) !< Y COMPONENT OF DATA VARIABLE. - REAL(R8P), INTENT(IN) :: Z(1:) !< Z COMPONENT OF DATA VARIABLE. - LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". - INTEGER(I4P) :: ERROR !< ERROR STATUS. - ENDFUNCTION W_DATA6_RANK1_R8P_INTERFACE - - FUNCTION W_DATA6_RANK1_R4P_INTERFACE(SELF, DATA_NAME, U, V, W, X, Y, Z, IS_TUPLES) RESULT(ERROR) - !< WRITE `<DATAARRAY... NumberOfComponents="6"...>...</DATAARRAY>` TAG (R4P). - IMPORT :: XML_WRITER_ABSTRACT, I4P, R4P - CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT) :: SELF !< WRITER. - CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. - REAL(R4P), INTENT(IN) :: U(1:) !< U COMPONENT OF DATA VARIABLE. - REAL(R4P), INTENT(IN) :: V(1:) !< V COMPONENT OF DATA VARIABLE. - REAL(R4P), INTENT(IN) :: W(1:) !< W COMPONENT OF DATA VARIABLE. - REAL(R4P), INTENT(IN) :: X(1:) !< X COMPONENT OF DATA VARIABLE. - REAL(R4P), INTENT(IN) :: Y(1:) !< Y COMPONENT OF DATA VARIABLE. - REAL(R4P), INTENT(IN) :: Z(1:) !< Z COMPONENT OF DATA VARIABLE. - LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". - INTEGER(I4P) :: ERROR !< ERROR STATUS. - ENDFUNCTION W_DATA6_RANK1_R4P_INTERFACE - - FUNCTION W_DATA6_RANK1_I8P_INTERFACE(SELF, DATA_NAME, U, V, W, X, Y, Z, IS_TUPLES) RESULT(ERROR) - !< WRITE `<DATAARRAY... NumberOfComponents="6"...>...</DATAARRAY>` TAG (I8P). - IMPORT :: XML_WRITER_ABSTRACT, I4P, I8P - CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT) :: SELF !< WRITER. - CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. - INTEGER(I8P), INTENT(IN) :: U(1:) !< U COMPONENT OF DATA VARIABLE. - INTEGER(I8P), INTENT(IN) :: V(1:) !< V COMPONENT OF DATA VARIABLE. - INTEGER(I8P), INTENT(IN) :: W(1:) !< W COMPONENT OF DATA VARIABLE. - INTEGER(I8P), INTENT(IN) :: X(1:) !< X COMPONENT OF DATA VARIABLE. - INTEGER(I8P), INTENT(IN) :: Y(1:) !< Y COMPONENT OF DATA VARIABLE. - INTEGER(I8P), INTENT(IN) :: Z(1:) !< Z COMPONENT OF DATA VARIABLE. - LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". - INTEGER(I4P) :: ERROR !< ERROR STATUS. - ENDFUNCTION W_DATA6_RANK1_I8P_INTERFACE - - FUNCTION W_DATA6_RANK1_I4P_INTERFACE(SELF, DATA_NAME, U, V, W, X, Y, Z, IS_TUPLES) RESULT(ERROR) - !< WRITE `<DATAARRAY... NumberOfComponents="6"...>...</DATAARRAY>` TAG (I4P). - IMPORT :: XML_WRITER_ABSTRACT, I4P - CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT) :: SELF !< WRITER. - CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. - INTEGER(I4P), INTENT(IN) :: U(1:) !< U COMPONENT OF DATA VARIABLE. - INTEGER(I4P), INTENT(IN) :: V(1:) !< V COMPONENT OF DATA VARIABLE. - INTEGER(I4P), INTENT(IN) :: W(1:) !< W COMPONENT OF DATA VARIABLE. - INTEGER(I4P), INTENT(IN) :: X(1:) !< X COMPONENT OF DATA VARIABLE. - INTEGER(I4P), INTENT(IN) :: Y(1:) !< Y COMPONENT OF DATA VARIABLE. - INTEGER(I4P), INTENT(IN) :: Z(1:) !< Z COMPONENT OF DATA VARIABLE. - LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". - INTEGER(I4P) :: ERROR !< ERROR STATUS. - ENDFUNCTION W_DATA6_RANK1_I4P_INTERFACE - - FUNCTION W_DATA6_RANK1_I2P_INTERFACE(SELF, DATA_NAME, U, V, W, X, Y, Z, IS_TUPLES) RESULT(ERROR) - !< WRITE `<DATAARRAY... NumberOfComponents="6"...>...</DATAARRAY>` TAG (I2P). - IMPORT :: XML_WRITER_ABSTRACT, I2P, I4P - CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT) :: SELF !< WRITER. - CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. - INTEGER(I2P), INTENT(IN) :: U(1:) !< U COMPONENT OF DATA VARIABLE. - INTEGER(I2P), INTENT(IN) :: V(1:) !< V COMPONENT OF DATA VARIABLE. - INTEGER(I2P), INTENT(IN) :: W(1:) !< W COMPONENT OF DATA VARIABLE. - INTEGER(I2P), INTENT(IN) :: X(1:) !< X COMPONENT OF DATA VARIABLE. - INTEGER(I2P), INTENT(IN) :: Y(1:) !< Y COMPONENT OF DATA VARIABLE. - INTEGER(I2P), INTENT(IN) :: Z(1:) !< Z COMPONENT OF DATA VARIABLE. - LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". - INTEGER(I4P) :: ERROR !< ERROR STATUS. - ENDFUNCTION W_DATA6_RANK1_I2P_INTERFACE - - FUNCTION W_DATA6_RANK1_I1P_INTERFACE(SELF, DATA_NAME, U, V, W, X, Y, Z, IS_TUPLES) RESULT(ERROR) - !< WRITE `<DATAARRAY... NumberOfComponents="6"...>...</DATAARRAY>` TAG (I1P). - IMPORT :: XML_WRITER_ABSTRACT, I1P, I4P - CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT) :: SELF !< WRITER. - CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. - INTEGER(I1P), INTENT(IN) :: U(1:) !< U COMPONENT OF DATA VARIABLE. - INTEGER(I1P), INTENT(IN) :: V(1:) !< V COMPONENT OF DATA VARIABLE. - INTEGER(I1P), INTENT(IN) :: W(1:) !< W COMPONENT OF DATA VARIABLE. - INTEGER(I1P), INTENT(IN) :: X(1:) !< X COMPONENT OF DATA VARIABLE. - INTEGER(I1P), INTENT(IN) :: Y(1:) !< Y COMPONENT OF DATA VARIABLE. - INTEGER(I1P), INTENT(IN) :: Z(1:) !< Z COMPONENT OF DATA VARIABLE. - LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". - INTEGER(I4P) :: ERROR !< ERROR STATUS. - ENDFUNCTION W_DATA6_RANK1_I1P_INTERFACE - - FUNCTION W_DATA6_RANK3_R8P_INTERFACE(SELF, DATA_NAME, U, V, W, X, Y, Z, IS_TUPLES) RESULT(ERROR) - !< WRITE `<DATAARRAY... NumberOfComponents="6"...>...</DATAARRAY>` TAG (R8P). - IMPORT :: XML_WRITER_ABSTRACT, I4P, R8P - CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT) :: SELF !< WRITER. - CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. - REAL(R8P), INTENT(IN) :: U(1:,1:,1:) !< U COMPONENT OF DATA VARIABLE. - REAL(R8P), INTENT(IN) :: V(1:,1:,1:) !< V COMPONENT OF DATA VARIABLE. - REAL(R8P), INTENT(IN) :: W(1:,1:,1:) !< W COMPONENT OF DATA VARIABLE. - REAL(R8P), INTENT(IN) :: X(1:,1:,1:) !< X COMPONENT OF DATA VARIABLE. - REAL(R8P), INTENT(IN) :: Y(1:,1:,1:) !< Y COMPONENT OF DATA VARIABLE. - REAL(R8P), INTENT(IN) :: Z(1:,1:,1:) !< Z COMPONENT OF DATA VARIABLE. - LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". - INTEGER(I4P) :: ERROR !< ERROR STATUS. - ENDFUNCTION W_DATA6_RANK3_R8P_INTERFACE - - FUNCTION W_DATA6_RANK3_R4P_INTERFACE(SELF, DATA_NAME, U, V, W, X, Y, Z, IS_TUPLES) RESULT(ERROR) - !< WRITE `<DATAARRAY... NumberOfComponents="6"...>...</DATAARRAY>` TAG (R4P). - IMPORT :: XML_WRITER_ABSTRACT, I4P, R4P - CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT) :: SELF !< WRITER. - CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. - REAL(R4P), INTENT(IN) :: U(1:,1:,1:) !< U COMPONENT OF DATA VARIABLE. - REAL(R4P), INTENT(IN) :: V(1:,1:,1:) !< V COMPONENT OF DATA VARIABLE. - REAL(R4P), INTENT(IN) :: W(1:,1:,1:) !< W COMPONENT OF DATA VARIABLE. - REAL(R4P), INTENT(IN) :: X(1:,1:,1:) !< X COMPONENT OF DATA VARIABLE. - REAL(R4P), INTENT(IN) :: Y(1:,1:,1:) !< Y COMPONENT OF DATA VARIABLE. - REAL(R4P), INTENT(IN) :: Z(1:,1:,1:) !< Z COMPONENT OF DATA VARIABLE. - LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". - INTEGER(I4P) :: ERROR !< ERROR STATUS. - ENDFUNCTION W_DATA6_RANK3_R4P_INTERFACE - - FUNCTION W_DATA6_RANK3_I8P_INTERFACE(SELF, DATA_NAME, U, V, W, X, Y, Z, IS_TUPLES) RESULT(ERROR) - !< WRITE `<DATAARRAY... NumberOfComponents="6"...>...</DATAARRAY>` TAG (I8P). - IMPORT :: XML_WRITER_ABSTRACT, I4P, I8P - CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT) :: SELF !< WRITER. - CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. - INTEGER(I8P), INTENT(IN) :: U(1:,1:,1:) !< U COMPONENT OF DATA VARIABLE. - INTEGER(I8P), INTENT(IN) :: V(1:,1:,1:) !< V COMPONENT OF DATA VARIABLE. - INTEGER(I8P), INTENT(IN) :: W(1:,1:,1:) !< W COMPONENT OF DATA VARIABLE. - INTEGER(I8P), INTENT(IN) :: X(1:,1:,1:) !< X COMPONENT OF DATA VARIABLE. - INTEGER(I8P), INTENT(IN) :: Y(1:,1:,1:) !< Y COMPONENT OF DATA VARIABLE. - INTEGER(I8P), INTENT(IN) :: Z(1:,1:,1:) !< Z COMPONENT OF DATA VARIABLE. - LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". - INTEGER(I4P) :: ERROR !< ERROR STATUS. - ENDFUNCTION W_DATA6_RANK3_I8P_INTERFACE - - FUNCTION W_DATA6_RANK3_I4P_INTERFACE(SELF, DATA_NAME, U, V, W, X, Y, Z, IS_TUPLES) RESULT(ERROR) - !< WRITE `<DATAARRAY... NumberOfComponents="6"...>...</DATAARRAY>` TAG (I4P). - IMPORT :: XML_WRITER_ABSTRACT, I4P - CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT) :: SELF !< WRITER. - CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. - INTEGER(I4P), INTENT(IN) :: U(1:,1:,1:) !< U COMPONENT OF DATA VARIABLE. - INTEGER(I4P), INTENT(IN) :: V(1:,1:,1:) !< V COMPONENT OF DATA VARIABLE. - INTEGER(I4P), INTENT(IN) :: W(1:,1:,1:) !< W COMPONENT OF DATA VARIABLE. - INTEGER(I4P), INTENT(IN) :: X(1:,1:,1:) !< X COMPONENT OF DATA VARIABLE. - INTEGER(I4P), INTENT(IN) :: Y(1:,1:,1:) !< Y COMPONENT OF DATA VARIABLE. - INTEGER(I4P), INTENT(IN) :: Z(1:,1:,1:) !< Z COMPONENT OF DATA VARIABLE. - LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". - INTEGER(I4P) :: ERROR !< ERROR STATUS. - ENDFUNCTION W_DATA6_RANK3_I4P_INTERFACE - - FUNCTION W_DATA6_RANK3_I2P_INTERFACE(SELF, DATA_NAME, U, V, W, X, Y, Z, IS_TUPLES) RESULT(ERROR) - !< WRITE `<DATAARRAY... NumberOfComponents="6"...>...</DATAARRAY>` TAG (I2P). - IMPORT :: XML_WRITER_ABSTRACT, I2P, I4P - CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT) :: SELF !< WRITER. - CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. - INTEGER(I2P), INTENT(IN) :: U(1:,1:,1:) !< U COMPONENT OF DATA VARIABLE. - INTEGER(I2P), INTENT(IN) :: V(1:,1:,1:) !< V COMPONENT OF DATA VARIABLE. - INTEGER(I2P), INTENT(IN) :: W(1:,1:,1:) !< W COMPONENT OF DATA VARIABLE. - INTEGER(I2P), INTENT(IN) :: X(1:,1:,1:) !< X COMPONENT OF DATA VARIABLE. - INTEGER(I2P), INTENT(IN) :: Y(1:,1:,1:) !< Y COMPONENT OF DATA VARIABLE. - INTEGER(I2P), INTENT(IN) :: Z(1:,1:,1:) !< Z COMPONENT OF DATA VARIABLE. - LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". - INTEGER(I4P) :: ERROR !< ERROR STATUS. - ENDFUNCTION W_DATA6_RANK3_I2P_INTERFACE - - FUNCTION W_DATA6_RANK3_I1P_INTERFACE(SELF, DATA_NAME, U, V, W, X, Y, Z, IS_TUPLES) RESULT(ERROR) - !< WRITE `<DATAARRAY... NumberOfComponents="6"...>...</DATAARRAY>` TAG (I1P). - IMPORT :: XML_WRITER_ABSTRACT, I1P, I4P - CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT) :: SELF !< WRITER. - CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. - INTEGER(I1P), INTENT(IN) :: U(1:,1:,1:) !< U COMPONENT OF DATA VARIABLE. - INTEGER(I1P), INTENT(IN) :: V(1:,1:,1:) !< V COMPONENT OF DATA VARIABLE. - INTEGER(I1P), INTENT(IN) :: W(1:,1:,1:) !< W COMPONENT OF DATA VARIABLE. - INTEGER(I1P), INTENT(IN) :: X(1:,1:,1:) !< X COMPONENT OF DATA VARIABLE. - INTEGER(I1P), INTENT(IN) :: Y(1:,1:,1:) !< Y COMPONENT OF DATA VARIABLE. - INTEGER(I1P), INTENT(IN) :: Z(1:,1:,1:) !< Z COMPONENT OF DATA VARIABLE. - LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". - INTEGER(I4P) :: ERROR !< ERROR STATUS. - ENDFUNCTION W_DATA6_RANK3_I1P_INTERFACE - SUBROUTINE W_DATA_APPENDED_INTERFACE(SELF) !< WRITE `<APPENDEDDATA...>...</APPENDEDDATA>` TAG. IMPORT :: XML_WRITER_ABSTRACT @@ -10721,62 +9870,14 @@ FUNCTION WRITE_GEO_RECT_DATA3_RANK1_R4P(SELF, X, Y, Z) RESULT(ERROR) ENDFUNCTION WRITE_GEO_RECT_DATA3_RANK1_R4P ! WRITE_GEO_STRG METHODS - FUNCTION WRITE_GEO_STRG_DATA1_RANK2_R8P(SELF, XYZ) RESULT(ERROR) - !< WRITE MESH WITH **STRUCTUREDGRID** TOPOLOGY (DATA 1, RANK 2, R8P). - CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT) :: SELF !< WRITER. - REAL(R8P), INTENT(IN) :: XYZ(1:,1:) !< X, Y, Z COORDINATES [1:3,1:N]. - INTEGER(I4P) :: ERROR !< ERROR STATUS. - - CALL SELF%WRITE_START_TAG(NAME='Points') - ERROR = SELF%W_DATA(DATA_NAME='Points', X=XYZ) - CALL SELF%WRITE_END_TAG(NAME='Points') - ERROR = SELF%ERROR - ENDFUNCTION WRITE_GEO_STRG_DATA1_RANK2_R8P - - FUNCTION WRITE_GEO_STRG_DATA1_RANK2_R4P(SELF, XYZ) RESULT(ERROR) - !< WRITE MESH WITH **STRUCTUREDGRID** TOPOLOGY (DATA 1, RANK 2, R4P). - CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT) :: SELF !< WRITER. - REAL(R4P), INTENT(IN) :: XYZ(1:,1:) !< X, Y, Z COORDINATES [1:3,:]. - INTEGER(I4P) :: ERROR !< ERROR STATUS. - - CALL SELF%WRITE_START_TAG(NAME='Points') - ERROR = SELF%W_DATA(DATA_NAME='Points', X=XYZ) - CALL SELF%WRITE_END_TAG(NAME='Points') - ERROR = SELF%ERROR - ENDFUNCTION WRITE_GEO_STRG_DATA1_RANK2_R4P - - FUNCTION WRITE_GEO_STRG_DATA1_RANK4_R8P(SELF, XYZ) RESULT(ERROR) - !< WRITE MESH WITH **STRUCTUREDGRID** TOPOLOGY (DATA 1, RANK 4, R8P). - CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT) :: SELF !< WRITER. - REAL(R8P), INTENT(IN) :: XYZ(1:,1:,1:,1:) !< X, Y, Z COORDINATES [1:3,:,:,:]. - INTEGER(I4P) :: ERROR !< ERROR STATUS. - - CALL SELF%WRITE_START_TAG(NAME='Points') - ERROR = SELF%W_DATA(DATA_NAME='Points', X=XYZ) - CALL SELF%WRITE_END_TAG(NAME='Points') - ERROR = SELF%ERROR - ENDFUNCTION WRITE_GEO_STRG_DATA1_RANK4_R8P - - FUNCTION WRITE_GEO_STRG_DATA1_RANK4_R4P(SELF, XYZ) RESULT(ERROR) - !< WRITE MESH WITH **STRUCTUREDGRID** TOPOLOGY (DATA 1, RANK 4, R4P). - CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT) :: SELF !< WRITER. - REAL(R4P), INTENT(IN) :: XYZ(1:,1:,1:,1:) !< X, Y, Z COORDINATES [1:3,:,:,:]. - INTEGER(I4P) :: ERROR !< ERROR STATUS. - - CALL SELF%WRITE_START_TAG(NAME='Points') - ERROR = SELF%W_DATA(DATA_NAME='Points', X=XYZ) - CALL SELF%WRITE_END_TAG(NAME='Points') - ERROR = SELF%ERROR - ENDFUNCTION WRITE_GEO_STRG_DATA1_RANK4_R4P - - FUNCTION WRITE_GEO_STRG_DATA3_RANK1_R8P(SELF, N, X, Y, Z) RESULT(ERROR) - !< WRITE MESH WITH **STRUCTUREDGRID** TOPOLOGY (DATA 3, RANK 1, R8P). - CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT) :: SELF !< WRITER. - INTEGER(I4P), INTENT(IN) :: N !< NUMBER OF NODES. - REAL(R8P), INTENT(IN) :: X(1:) !< X COORDINATES. - REAL(R8P), INTENT(IN) :: Y(1:) !< Y COORDINATES. - REAL(R8P), INTENT(IN) :: Z(1:) !< Z COORDINATES. - INTEGER(I4P) :: ERROR !< ERROR STATUS. + FUNCTION WRITE_GEO_STRG_DATA3_RANK1_R8P(SELF, N, X, Y, Z) RESULT(ERROR) + !< WRITE MESH WITH **STRUCTUREDGRID** TOPOLOGY (DATA 3, RANK 1, R8P). + CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT) :: SELF !< WRITER. + INTEGER(I4P), INTENT(IN) :: N !< NUMBER OF NODES. + REAL(R8P), INTENT(IN) :: X(1:) !< X COORDINATES. + REAL(R8P), INTENT(IN) :: Y(1:) !< Y COORDINATES. + REAL(R8P), INTENT(IN) :: Z(1:) !< Z COORDINATES. + INTEGER(I4P) :: ERROR !< ERROR STATUS. IF ((N/=SIZE(X, DIM=1)).OR.(N/=SIZE(Y, DIM=1)).OR.(N/=SIZE(Z, DIM=1))) THEN SELF%ERROR = 1 @@ -10807,85 +9908,7 @@ FUNCTION WRITE_GEO_STRG_DATA3_RANK1_R4P(SELF, N, X, Y, Z) RESULT(ERROR) ERROR = SELF%ERROR ENDFUNCTION WRITE_GEO_STRG_DATA3_RANK1_R4P - FUNCTION WRITE_GEO_STRG_DATA3_RANK3_R8P(SELF, N, X, Y, Z) RESULT(ERROR) - !< WRITE MESH WITH **STRUCTUREDGRID** TOPOLOGY (DATA 3, RANK 3, R8P). - CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT) :: SELF !< WRITER. - INTEGER(I4P), INTENT(IN) :: N !< NUMBER OF NODES. - REAL(R8P), INTENT(IN) :: X(1:,1:,1:) !< X COORDINATES. - REAL(R8P), INTENT(IN) :: Y(1:,1:,1:) !< Y COORDINATES. - REAL(R8P), INTENT(IN) :: Z(1:,1:,1:) !< Z COORDINATES. - INTEGER(I4P) :: ERROR !< ERROR STATUS. - - IF ((N/=SIZE(X, DIM=1)*SIZE(X, DIM=2)*SIZE(X, DIM=3)).OR.& - (N/=SIZE(Y, DIM=1)*SIZE(Y, DIM=2)*SIZE(Y, DIM=3)).OR.& - (N/=SIZE(Z, DIM=1)*SIZE(Z, DIM=2)*SIZE(Z, DIM=3))) THEN - SELF%ERROR = 1 - RETURN - ENDIF - CALL SELF%WRITE_START_TAG(NAME='Points') - ERROR = SELF%W_DATA(DATA_NAME='Points', X=X, Y=Y, Z=Z) - CALL SELF%WRITE_END_TAG(NAME='Points') - ERROR = SELF%ERROR - ENDFUNCTION WRITE_GEO_STRG_DATA3_RANK3_R8P - - FUNCTION WRITE_GEO_STRG_DATA3_RANK3_R4P(SELF, N, X, Y, Z) RESULT(ERROR) - !< WRITE MESH WITH **STRUCTUREDGRID** TOPOLOGY (DATA 3, RANK 3, R4P). - CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT) :: SELF !< WRITER. - INTEGER(I4P), INTENT(IN) :: N !< NUMBER OF NODES. - REAL(R4P), INTENT(IN) :: X(1:,1:,1:) !< X COORDINATES. - REAL(R4P), INTENT(IN) :: Y(1:,1:,1:) !< Y COORDINATES. - REAL(R4P), INTENT(IN) :: Z(1:,1:,1:) !< Z COORDINATES. - INTEGER(I4P) :: ERROR !< ERROR STATUS. - - IF ((N/=SIZE(X, DIM=1)*SIZE(X, DIM=2)*SIZE(X, DIM=3)).OR.& - (N/=SIZE(Y, DIM=1)*SIZE(Y, DIM=2)*SIZE(Y, DIM=3)).OR.& - (N/=SIZE(Z, DIM=1)*SIZE(Z, DIM=2)*SIZE(Z, DIM=3))) THEN - SELF%ERROR = 1 - RETURN - ENDIF - CALL SELF%WRITE_START_TAG(NAME='Points') - ERROR = SELF%W_DATA(DATA_NAME='Points', X=X, Y=Y, Z=Z) - CALL SELF%WRITE_END_TAG(NAME='Points') - ERROR = SELF%ERROR - ENDFUNCTION WRITE_GEO_STRG_DATA3_RANK3_R4P - ! WRITE_GEO_UNST METHODS - FUNCTION WRITE_GEO_UNST_DATA1_RANK2_R8P(SELF, NP, NC, XYZ) RESULT(ERROR) - !< WRITE MESH WITH **UNSTRUCTUREDGRID** TOPOLOGY (DATA 1, RANK 2, R8P). - CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT) :: SELF !< WRITER. - INTEGER(I4P), INTENT(IN) :: NP !< NUMBER OF POINTS. - INTEGER(I4P), INTENT(IN) :: NC !< NUMBER OF CELLS. - REAL(R8P), INTENT(IN) :: XYZ(1:,1:) !< X, Y, Z COORDINATES [1:3,:]. - INTEGER(I4P) :: ERROR !< ERROR STATUS. - - IF (NP/=SIZE(XYZ, DIM=2)) THEN - SELF%ERROR = 1 - RETURN - ENDIF - CALL SELF%WRITE_START_TAG(NAME='Points') - ERROR = SELF%W_DATA(DATA_NAME='Points', X=XYZ) - CALL SELF%WRITE_END_TAG(NAME='Points') - ERROR = SELF%ERROR - ENDFUNCTION WRITE_GEO_UNST_DATA1_RANK2_R8P - - FUNCTION WRITE_GEO_UNST_DATA1_RANK2_R4P(SELF, NP, NC, XYZ) RESULT(ERROR) - !< WRITE MESH WITH **UNSTRUCTUREDGRID** TOPOLOGY (DATA 1, RANK 2, R4P). - CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT) :: SELF !< WRITER. - INTEGER(I4P), INTENT(IN) :: NP !< NUMBER OF POINTS. - INTEGER(I4P), INTENT(IN) :: NC !< NUMBER OF CELLS. - REAL(R4P), INTENT(IN) :: XYZ(1:,1:) !< X, Y, Z COORDINATES [1:3,:]. - INTEGER(I4P) :: ERROR !< ERROR STATUS. - - IF (NP/=SIZE(XYZ, DIM=2)) THEN - SELF%ERROR = 1 - RETURN - ENDIF - CALL SELF%WRITE_START_TAG(NAME='Points') - ERROR = SELF%W_DATA(DATA_NAME='Points', X=XYZ) - CALL SELF%WRITE_END_TAG(NAME='Points') - ERROR = SELF%ERROR - ENDFUNCTION WRITE_GEO_UNST_DATA1_RANK2_R4P - FUNCTION WRITE_GEO_UNST_DATA3_RANK1_R8P(SELF, NP, NC, X, Y, Z) RESULT(ERROR) !< WRITE MESH WITH **UNSTRUCTUREDGRID** TOPOLOGY (DATA 3, RANK 1, R8P). CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT) :: SELF !< WRITER. @@ -10927,42 +9950,6 @@ FUNCTION WRITE_GEO_UNST_DATA3_RANK1_R4P(SELF, NP, NC, X, Y, Z) RESULT(ERROR) ENDFUNCTION WRITE_GEO_UNST_DATA3_RANK1_R4P ! WRITE_GEO_POLY METHODS - FUNCTION WRITE_GEO_POLY_DATA1_RANK2_R8P(SELF, NP, NC, XYZ) RESULT(ERROR) - !< WRITE MESH WITH **POLYDATA** TOPOLOGY (DATA 1, RANK 2, R8P). - CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT) :: SELF !< WRITER. - INTEGER(I4P), INTENT(IN) :: NP !< NUMBER OF POINTS. - INTEGER(I4P), INTENT(IN) :: NC !< NUMBER OF CELLS. - REAL(R8P), INTENT(IN) :: XYZ(1:,1:) !< X, Y, Z COORDINATES [1:3,:]. - INTEGER(I4P) :: ERROR !< ERROR STATUS. - - IF (NP/=SIZE(XYZ, DIM=2)) THEN - SELF%ERROR = 1 - RETURN - ENDIF - CALL SELF%WRITE_START_TAG(NAME='Points') - ERROR = SELF%W_DATA(DATA_NAME='Points', X=XYZ) - CALL SELF%WRITE_END_TAG(NAME='Points') - ERROR = SELF%ERROR - ENDFUNCTION WRITE_GEO_POLY_DATA1_RANK2_R8P - - FUNCTION WRITE_GEO_POLY_DATA1_RANK2_R4P(SELF, NP, NC, XYZ) RESULT(ERROR) - !< WRITE MESH WITH **POLYDATA** TOPOLOGY (DATA 1, RANK 2, R4P). - CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT) :: SELF !< WRITER. - INTEGER(I4P), INTENT(IN) :: NP !< NUMBER OF POINTS. - INTEGER(I4P), INTENT(IN) :: NC !< NUMBER OF CELLS. - REAL(R4P), INTENT(IN) :: XYZ(1:,1:) !< X, Y, Z COORDINATES [1:3,:]. - INTEGER(I4P) :: ERROR !< ERROR STATUS. - - IF (NP/=SIZE(XYZ, DIM=2)) THEN - SELF%ERROR = 1 - RETURN - ENDIF - CALL SELF%WRITE_START_TAG(NAME='Points') - ERROR = SELF%W_DATA(DATA_NAME='Points', X=XYZ) - CALL SELF%WRITE_END_TAG(NAME='Points') - ERROR = SELF%ERROR - ENDFUNCTION WRITE_GEO_POLY_DATA1_RANK2_R4P - FUNCTION WRITE_GEO_POLY_DATA3_RANK1_R8P(SELF, NP, NC, X, Y, Z) RESULT(ERROR) !< WRITE MESH WITH **POLYDATA** TOPOLOGY (DATA 3, RANK 1, R8P). CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT) :: SELF !< WRITER. @@ -11280,48 +10267,12 @@ MODULE VTK_FORTRAN_DATAARRAY_ENCODER ENCODE_ASCII_DATAARRAY1_RANK1_I4P, & ENCODE_ASCII_DATAARRAY1_RANK1_I2P, & ENCODE_ASCII_DATAARRAY1_RANK1_I1P, & - ENCODE_ASCII_DATAARRAY1_RANK2_R8P, & - ENCODE_ASCII_DATAARRAY1_RANK2_R4P, & - ENCODE_ASCII_DATAARRAY1_RANK2_I8P, & - ENCODE_ASCII_DATAARRAY1_RANK2_I4P, & - ENCODE_ASCII_DATAARRAY1_RANK2_I2P, & - ENCODE_ASCII_DATAARRAY1_RANK2_I1P, & - ENCODE_ASCII_DATAARRAY1_RANK3_R8P, & - ENCODE_ASCII_DATAARRAY1_RANK3_R4P, & - ENCODE_ASCII_DATAARRAY1_RANK3_I8P, & - ENCODE_ASCII_DATAARRAY1_RANK3_I4P, & - ENCODE_ASCII_DATAARRAY1_RANK3_I2P, & - ENCODE_ASCII_DATAARRAY1_RANK3_I1P, & - ENCODE_ASCII_DATAARRAY1_RANK4_R8P, & - ENCODE_ASCII_DATAARRAY1_RANK4_R4P, & - ENCODE_ASCII_DATAARRAY1_RANK4_I8P, & - ENCODE_ASCII_DATAARRAY1_RANK4_I4P, & - ENCODE_ASCII_DATAARRAY1_RANK4_I2P, & - ENCODE_ASCII_DATAARRAY1_RANK4_I1P, & ENCODE_ASCII_DATAARRAY3_RANK1_R8P, & ENCODE_ASCII_DATAARRAY3_RANK1_R4P, & ENCODE_ASCII_DATAARRAY3_RANK1_I8P, & ENCODE_ASCII_DATAARRAY3_RANK1_I4P, & ENCODE_ASCII_DATAARRAY3_RANK1_I2P, & - ENCODE_ASCII_DATAARRAY3_RANK1_I1P, & - ENCODE_ASCII_DATAARRAY3_RANK3_R8P, & - ENCODE_ASCII_DATAARRAY3_RANK3_R4P, & - ENCODE_ASCII_DATAARRAY3_RANK3_I8P, & - ENCODE_ASCII_DATAARRAY3_RANK3_I4P, & - ENCODE_ASCII_DATAARRAY3_RANK3_I2P, & - ENCODE_ASCII_DATAARRAY3_RANK3_I1P, & - ENCODE_ASCII_DATAARRAY6_RANK1_R8P, & - ENCODE_ASCII_DATAARRAY6_RANK1_R4P, & - ENCODE_ASCII_DATAARRAY6_RANK1_I8P, & - ENCODE_ASCII_DATAARRAY6_RANK1_I4P, & - ENCODE_ASCII_DATAARRAY6_RANK1_I2P, & - ENCODE_ASCII_DATAARRAY6_RANK1_I1P, & - ENCODE_ASCII_DATAARRAY6_RANK3_R8P, & - ENCODE_ASCII_DATAARRAY6_RANK3_R4P, & - ENCODE_ASCII_DATAARRAY6_RANK3_I8P, & - ENCODE_ASCII_DATAARRAY6_RANK3_I4P, & - ENCODE_ASCII_DATAARRAY6_RANK3_I2P, & - ENCODE_ASCII_DATAARRAY6_RANK3_I1P + ENCODE_ASCII_DATAARRAY3_RANK1_I1P ENDINTERFACE ENCODE_ASCII_DATAARRAY INTERFACE ENCODE_BINARY_DATAARRAY !< BINARY (BASE64) DATAARRAY ENCODER. @@ -11331,48 +10282,12 @@ MODULE VTK_FORTRAN_DATAARRAY_ENCODER ENCODE_BINARY_DATAARRAY1_RANK1_I4P, & ENCODE_BINARY_DATAARRAY1_RANK1_I2P, & ENCODE_BINARY_DATAARRAY1_RANK1_I1P, & - ENCODE_BINARY_DATAARRAY1_RANK2_R8P, & - ENCODE_BINARY_DATAARRAY1_RANK2_R4P, & - ENCODE_BINARY_DATAARRAY1_RANK2_I8P, & - ENCODE_BINARY_DATAARRAY1_RANK2_I4P, & - ENCODE_BINARY_DATAARRAY1_RANK2_I2P, & - ENCODE_BINARY_DATAARRAY1_RANK2_I1P, & - ENCODE_BINARY_DATAARRAY1_RANK3_R8P, & - ENCODE_BINARY_DATAARRAY1_RANK3_R4P, & - ENCODE_BINARY_DATAARRAY1_RANK3_I8P, & - ENCODE_BINARY_DATAARRAY1_RANK3_I4P, & - ENCODE_BINARY_DATAARRAY1_RANK3_I2P, & - ENCODE_BINARY_DATAARRAY1_RANK3_I1P, & - ENCODE_BINARY_DATAARRAY1_RANK4_R8P, & - ENCODE_BINARY_DATAARRAY1_RANK4_R4P, & - ENCODE_BINARY_DATAARRAY1_RANK4_I8P, & - ENCODE_BINARY_DATAARRAY1_RANK4_I4P, & - ENCODE_BINARY_DATAARRAY1_RANK4_I2P, & - ENCODE_BINARY_DATAARRAY1_RANK4_I1P, & ENCODE_BINARY_DATAARRAY3_RANK1_R8P, & ENCODE_BINARY_DATAARRAY3_RANK1_R4P, & ENCODE_BINARY_DATAARRAY3_RANK1_I8P, & ENCODE_BINARY_DATAARRAY3_RANK1_I4P, & ENCODE_BINARY_DATAARRAY3_RANK1_I2P, & - ENCODE_BINARY_DATAARRAY3_RANK1_I1P, & - ENCODE_BINARY_DATAARRAY3_RANK3_R8P, & - ENCODE_BINARY_DATAARRAY3_RANK3_R4P, & - ENCODE_BINARY_DATAARRAY3_RANK3_I8P, & - ENCODE_BINARY_DATAARRAY3_RANK3_I4P, & - ENCODE_BINARY_DATAARRAY3_RANK3_I2P, & - ENCODE_BINARY_DATAARRAY3_RANK3_I1P, & - ENCODE_BINARY_DATAARRAY6_RANK1_R8P, & - ENCODE_BINARY_DATAARRAY6_RANK1_R4P, & - ENCODE_BINARY_DATAARRAY6_RANK1_I8P, & - ENCODE_BINARY_DATAARRAY6_RANK1_I4P, & - ENCODE_BINARY_DATAARRAY6_RANK1_I2P, & - ENCODE_BINARY_DATAARRAY6_RANK1_I1P, & - ENCODE_BINARY_DATAARRAY6_RANK3_R8P, & - ENCODE_BINARY_DATAARRAY6_RANK3_R4P, & - ENCODE_BINARY_DATAARRAY6_RANK3_I8P, & - ENCODE_BINARY_DATAARRAY6_RANK3_I4P, & - ENCODE_BINARY_DATAARRAY6_RANK3_I2P, & - ENCODE_BINARY_DATAARRAY6_RANK3_I1P + ENCODE_BINARY_DATAARRAY3_RANK1_I1P ENDINTERFACE ENCODE_BINARY_DATAARRAY CONTAINS !< ASCII ENCODER @@ -11509,656 +10424,6 @@ FUNCTION ENCODE_ASCII_DATAARRAY1_RANK1_I1P(X) RESULT(CODE) ENDDO ENDFUNCTION ENCODE_ASCII_DATAARRAY1_RANK1_I1P - FUNCTION ENCODE_ASCII_DATAARRAY1_RANK2_R16P(X) RESULT(CODE) - !< ENCODE (BASE64) A DATAARRAY WITH 1 COMPONENTS OF RANK 2 (R16P). - REAL(R16P), INTENT(IN) :: X(1:,1:) !< DATA VARIABLE - CHARACTER(LEN=:), ALLOCATABLE :: CODE !< ENCODED BASE64 DATAARRAY. - INTEGER(I4P) :: N1 !< COUNTER. - INTEGER(I4P) :: N2 !< COUNTER. - INTEGER(I4P) :: L !< LENGTH - INTEGER(I4P) :: SP !< STRING POINTER - INTEGER(I4P) :: SIZE_N1 !< DIMENSION 1 SIZE - INTEGER(I4P) :: SIZE_N2 !< DIMENSION 2 SIZE - - SIZE_N1 = SIZE(X, DIM=1) - SIZE_N2 = SIZE(X, DIM=2) - L = DR16P + 1 - SP = 0 - CODE = REPEAT(' ',L*SIZE_N1*SIZE_N2) - DO N2=1, SIZE(X, DIM=2) - DO N1=1, SIZE(X, DIM=1)-1 - CODE(SP+1:SP+L) = STR(N=X(N1, N2))//' ' - SP = SP + L - ENDDO - CODE(SP+1:SP+L) = ' '//STR(N=X(SIZE(X, DIM=1), N2)) - SP = SP + L - ENDDO - ENDFUNCTION ENCODE_ASCII_DATAARRAY1_RANK2_R16P - - FUNCTION ENCODE_ASCII_DATAARRAY1_RANK2_R8P(X) RESULT(CODE) - !< ENCODE (BASE64) A DATAARRAY WITH 1 COMPONENTS OF RANK 2 (R8P). - REAL(R8P), INTENT(IN) :: X(1:,1:) !< DATA VARIABLE - CHARACTER(LEN=:), ALLOCATABLE :: CODE !< ENCODED BASE64 DATAARRAY. - INTEGER(I4P) :: N1 !< COUNTER. - INTEGER(I4P) :: N2 !< COUNTER. - INTEGER(I4P) :: L !< LENGTH - INTEGER(I4P) :: SP !< STRING POINTER - INTEGER(I4P) :: SIZE_N1 !< DIMENSION 1 SIZE - INTEGER(I4P) :: SIZE_N2 !< DIMENSION 2 SIZE - - SIZE_N1 = SIZE(X, DIM=1) - SIZE_N2 = SIZE(X, DIM=2) - L = DR8P + 1 - SP = 0 - CODE = REPEAT(' ',L*SIZE_N1*SIZE_N2) - DO N2=1, SIZE(X, DIM=2) - DO N1=1, SIZE(X, DIM=1)-1 - CODE(SP+1:SP+L) = STR(N=X(N1, N2))//' ' - SP = SP + L - ENDDO - CODE(SP+1:SP+L) = ' '//STR(N=X(SIZE(X, DIM=1), N2)) - SP = SP + L - ENDDO - ENDFUNCTION ENCODE_ASCII_DATAARRAY1_RANK2_R8P - - FUNCTION ENCODE_ASCII_DATAARRAY1_RANK2_R4P(X) RESULT(CODE) - !< ENCODE (BASE64) A DATAARRAY WITH 1 COMPONENTS OF RANK 2 (R4P). - REAL(R4P), INTENT(IN) :: X(1:,1:) !< DATA VARIABLE - CHARACTER(LEN=:), ALLOCATABLE :: CODE !< ENCODED BASE64 DATAARRAY. - INTEGER(I4P) :: N1 !< COUNTER. - INTEGER(I4P) :: N2 !< COUNTER. - INTEGER(I4P) :: L !< LENGTH - INTEGER(I4P) :: SP !< STRING POINTER - INTEGER(I4P) :: SIZE_N1 !< DIMENSION 1 SIZE - INTEGER(I4P) :: SIZE_N2 !< DIMENSION 2 SIZE - - SIZE_N1 = SIZE(X, DIM=1) - SIZE_N2 = SIZE(X, DIM=2) - L = DR4P + 1 - SP = 0 - CODE = REPEAT(' ',L*SIZE_N1*SIZE_N2) - DO N2=1, SIZE(X, DIM=2) - DO N1=1, SIZE(X, DIM=1)-1 - CODE(SP+1:SP+L) = STR(N=X(N1, N2))//' ' - SP = SP + L - ENDDO - CODE(SP+1:SP+L) = ' '//STR(N=X(SIZE(X, DIM=1), N2)) - SP = SP + L - ENDDO - ENDFUNCTION ENCODE_ASCII_DATAARRAY1_RANK2_R4P - - FUNCTION ENCODE_ASCII_DATAARRAY1_RANK2_I8P(X) RESULT(CODE) - !< ENCODE (BASE64) A DATAARRAY WITH 1 COMPONENTS OF RANK 2 (I8P). - INTEGER(I8P), INTENT(IN) :: X(1:,1:) !< DATA VARIABLE - CHARACTER(LEN=:), ALLOCATABLE :: CODE !< ENCODED BASE64 DATAARRAY. - INTEGER(I4P) :: N1 !< COUNTER. - INTEGER(I4P) :: N2 !< COUNTER. - INTEGER(I4P) :: L !< LENGTH - INTEGER(I4P) :: SP !< STRING POINTER - INTEGER(I4P) :: SIZE_N1 !< DIMENSION 1 SIZE - INTEGER(I4P) :: SIZE_N2 !< DIMENSION 2 SIZE - - SIZE_N1 = SIZE(X, DIM=1) - SIZE_N2 = SIZE(X, DIM=2) - L = DI8P + 1 - SP = 0 - CODE = REPEAT(' ',L*SIZE_N1*SIZE_N2) - DO N2=1, SIZE(X, DIM=2) - DO N1=1, SIZE(X, DIM=1)-1 - CODE(SP+1:SP+L) = STR(N=X(N1, N2))//' ' - SP = SP + L - ENDDO - CODE(SP+1:SP+L) = ' '//STR(N=X(SIZE(X, DIM=1), N2)) - SP = SP + L - ENDDO - ENDFUNCTION ENCODE_ASCII_DATAARRAY1_RANK2_I8P - - FUNCTION ENCODE_ASCII_DATAARRAY1_RANK2_I4P(X) RESULT(CODE) - !< ENCODE (BASE64) A DATAARRAY WITH 1 COMPONENTS OF RANK 2 (I4P). - INTEGER(I4P), INTENT(IN) :: X(1:,1:) !< DATA VARIABLE - CHARACTER(LEN=:), ALLOCATABLE :: CODE !< ENCODED BASE64 DATAARRAY. - INTEGER(I4P) :: N1 !< COUNTER. - INTEGER(I4P) :: N2 !< COUNTER. - INTEGER(I4P) :: L !< LENGTH - INTEGER(I4P) :: SP !< STRING POINTER - INTEGER(I4P) :: SIZE_N1 !< DIMENSION 1 SIZE - INTEGER(I4P) :: SIZE_N2 !< DIMENSION 2 SIZE - - SIZE_N1 = SIZE(X, DIM=1) - SIZE_N2 = SIZE(X, DIM=2) - L = DI4P + 1 - SP = 0 - CODE = REPEAT(' ',L*SIZE_N1*SIZE_N2) - DO N2=1, SIZE(X, DIM=2) - DO N1=1, SIZE(X, DIM=1)-1 - CODE(SP+1:SP+L) = STR(N=X(N1, N2))//' ' - SP = SP + L - ENDDO - CODE(SP+1:SP+L) = ' '//STR(N=X(SIZE(X, DIM=1), N2)) - SP = SP + L - ENDDO - ENDFUNCTION ENCODE_ASCII_DATAARRAY1_RANK2_I4P - - FUNCTION ENCODE_ASCII_DATAARRAY1_RANK2_I2P(X) RESULT(CODE) - !< ENCODE (BASE64) A DATAARRAY WITH 1 COMPONENTS OF RANK 2 (I2P). - INTEGER(I2P), INTENT(IN) :: X(1:,1:) !< DATA VARIABLE - CHARACTER(LEN=:), ALLOCATABLE :: CODE !< ENCODED BASE64 DATAARRAY. - INTEGER(I4P) :: N1 !< COUNTER. - INTEGER(I4P) :: N2 !< COUNTER. - INTEGER(I4P) :: L !< LENGTH - INTEGER(I4P) :: SP !< STRING POINTER - INTEGER(I4P) :: SIZE_N1 !< DIMENSION 1 SIZE - INTEGER(I4P) :: SIZE_N2 !< DIMENSION 2 SIZE - - SIZE_N1 = SIZE(X, DIM=1) - SIZE_N2 = SIZE(X, DIM=2) - L = DI4P + 1 - SP = 0 - CODE = REPEAT(' ',L*SIZE_N1*SIZE_N2) - DO N2=1, SIZE(X, DIM=2) - DO N1=1, SIZE(X, DIM=1)-1 - CODE(SP+1:SP+L) = STR(N=X(N1, N2))//' ' - SP = SP + L - ENDDO - CODE(SP+1:SP+L) = ' '//STR(N=X(SIZE(X, DIM=1), N2)) - SP = SP + L - ENDDO - ENDFUNCTION ENCODE_ASCII_DATAARRAY1_RANK2_I2P - - FUNCTION ENCODE_ASCII_DATAARRAY1_RANK2_I1P(X) RESULT(CODE) - !< ENCODE (BASE64) A DATAARRAY WITH 1 COMPONENTS OF RANK 2 (I2P). - INTEGER(I1P), INTENT(IN) :: X(1:,1:) !< DATA VARIABLE - CHARACTER(LEN=:), ALLOCATABLE :: CODE !< ENCODED BASE64 DATAARRAY. - INTEGER(I4P) :: N1 !< COUNTER. - INTEGER(I4P) :: N2 !< COUNTER. - INTEGER(I4P) :: L !< LENGTH - INTEGER(I4P) :: SP !< STRING POINTER - INTEGER(I4P) :: SIZE_N1 !< DIMENSION 1 SIZE - INTEGER(I4P) :: SIZE_N2 !< DIMENSION 2 SIZE - - SIZE_N1 = SIZE(X, DIM=1) - SIZE_N2 = SIZE(X, DIM=2) - L = DI1P + 1 - SP = 0 - CODE = REPEAT(' ',L*SIZE_N1*SIZE_N2) - DO N2=1, SIZE(X, DIM=2) - DO N1=1, SIZE(X, DIM=1)-1 - CODE(SP+1:SP+L) = STR(N=X(N1, N2))//' ' - SP = SP + L - ENDDO - CODE(SP+1:SP+L) = ' '//STR(N=X(SIZE(X, DIM=1), N2)) - SP = SP + L - ENDDO - ENDFUNCTION ENCODE_ASCII_DATAARRAY1_RANK2_I1P - - FUNCTION ENCODE_ASCII_DATAARRAY1_RANK3_R16P(X) RESULT(CODE) - !< ENCODE (BASE64) A DATAARRAY WITH 1 COMPONENTS OF RANK 3 (R16P). - REAL(R16P), INTENT(IN) :: X(1:,1:,1:) !< DATA VARIABLE - CHARACTER(LEN=:), ALLOCATABLE :: CODE !< ENCODED BASE64 DATAARRAY. - INTEGER(I4P) :: N1 !< COUNTER. - INTEGER(I4P) :: N2 !< COUNTER. - INTEGER(I4P) :: N3 !< COUNTER. - INTEGER(I4P) :: L !< LENGTH - INTEGER(I4P) :: SP !< STRING POINTER - INTEGER(I4P) :: SIZE_N1 !< DIMENSION 1 SIZE - INTEGER(I4P) :: SIZE_N2 !< DIMENSION 2 SIZE - INTEGER(I4P) :: SIZE_N3 !< DIMENSION 3 SIZE - - SIZE_N1 = SIZE(X, DIM=1) - SIZE_N2 = SIZE(X, DIM=2) - SIZE_N3 = SIZE(X, DIM=3) - - L = DR16P + 1 - SP = 0 - CODE = REPEAT(' ',L*SIZE_N1*SIZE_N2*SIZE_N3) - DO N3=1, SIZE(X, DIM=3) - DO N2=1, SIZE(X, DIM=2) - DO N1=1, SIZE(X, DIM=1)-1 - CODE(SP+1:SP+L) = STR(N=X(N1, N2, N3))//' ' - SP = SP + 1 - ENDDO - CODE(SP+1:SP+L) = ' '//STR(N=X(SIZE(X, DIM=1), N2, N3)) - ENDDO - ENDDO - ENDFUNCTION ENCODE_ASCII_DATAARRAY1_RANK3_R16P - - FUNCTION ENCODE_ASCII_DATAARRAY1_RANK3_R8P(X) RESULT(CODE) - !< ENCODE (BASE64) A DATAARRAY WITH 1 COMPONENTS OF RANK 3 (R8P). - REAL(R8P), INTENT(IN) :: X(1:,1:,1:) !< DATA VARIABLE - CHARACTER(LEN=:), ALLOCATABLE :: CODE !< ENCODED BASE64 DATAARRAY. - INTEGER(I4P) :: N1 !< COUNTER. - INTEGER(I4P) :: N2 !< COUNTER. - INTEGER(I4P) :: N3 !< COUNTER. - INTEGER(I4P) :: L !< LENGTH - INTEGER(I4P) :: SP !< STRING POINTER - INTEGER(I4P) :: SIZE_N1 !< DIMENSION 1 SIZE - INTEGER(I4P) :: SIZE_N2 !< DIMENSION 2 SIZE - INTEGER(I4P) :: SIZE_N3 !< DIMENSION 3 SIZE - - SIZE_N1 = SIZE(X, DIM=1) - SIZE_N2 = SIZE(X, DIM=2) - SIZE_N3 = SIZE(X, DIM=3) - - L = DR8P + 1 - SP = 0 - CODE = REPEAT(' ',L*SIZE_N1*SIZE_N2*SIZE_N3) - DO N3=1, SIZE(X, DIM=3) - DO N2=1, SIZE(X, DIM=2) - DO N1=1, SIZE(X, DIM=1)-1 - CODE(SP+1:SP+L) = STR(N=X(N1, N2, N3))//' ' - SP = SP + L - ENDDO - CODE(SP+1:SP+L) = ' '//STR(N=X(SIZE(X, DIM=1), N2, N3)) - SP = SP + L - ENDDO - ENDDO - ENDFUNCTION ENCODE_ASCII_DATAARRAY1_RANK3_R8P - - FUNCTION ENCODE_ASCII_DATAARRAY1_RANK3_R4P(X) RESULT(CODE) - !< ENCODE (BASE64) A DATAARRAY WITH 1 COMPONENTS OF RANK 3 (R4P). - REAL(R4P), INTENT(IN) :: X(1:,1:,1:) !< DATA VARIABLE - CHARACTER(LEN=:), ALLOCATABLE :: CODE !< ENCODED BASE64 DATAARRAY. - INTEGER(I4P) :: N1 !< COUNTER. - INTEGER(I4P) :: N2 !< COUNTER. - INTEGER(I4P) :: N3 !< COUNTER. - INTEGER(I4P) :: L !< LENGTH - INTEGER(I4P) :: SP !< STRING POINTER - INTEGER(I4P) :: SIZE_N1 !< DIMENSION 1 SIZE - INTEGER(I4P) :: SIZE_N2 !< DIMENSION 2 SIZE - INTEGER(I4P) :: SIZE_N3 !< DIMENSION 3 SIZE - - SIZE_N1 = SIZE(X, DIM=1) - SIZE_N2 = SIZE(X, DIM=2) - SIZE_N3 = SIZE(X, DIM=3) - - L = DR4P + 1 - SP = 0 - CODE = REPEAT(' ',L*SIZE_N1*SIZE_N2*SIZE_N3) - DO N3=1, SIZE(X, DIM=3) - DO N2=1, SIZE(X, DIM=2) - DO N1=1, SIZE(X, DIM=1)-1 - CODE(SP+1:SP+L) = STR(N=X(N1, N2, N3))//' ' - SP = SP + L - ENDDO - CODE(SP+1:SP+L) = ' '//STR(N=X(SIZE(X, DIM=1), N2, N3)) - SP = SP + L - ENDDO - ENDDO - ENDFUNCTION ENCODE_ASCII_DATAARRAY1_RANK3_R4P - - FUNCTION ENCODE_ASCII_DATAARRAY1_RANK3_I8P(X) RESULT(CODE) - !< ENCODE (BASE64) A DATAARRAY WITH 1 COMPONENTS OF RANK 3 (I8P). - INTEGER(I8P), INTENT(IN) :: X(1:,1:,1:) !< DATA VARIABLE - CHARACTER(LEN=:), ALLOCATABLE :: CODE !< ENCODED BASE64 DATAARRAY. - INTEGER(I4P) :: N1 !< COUNTER. - INTEGER(I4P) :: N2 !< COUNTER. - INTEGER(I4P) :: N3 !< COUNTER. - INTEGER(I4P) :: L !< LENGTH - INTEGER(I4P) :: SP !< STRING POINTER - INTEGER(I4P) :: SIZE_N1 !< DIMENSION 1 SIZE - INTEGER(I4P) :: SIZE_N2 !< DIMENSION 2 SIZE - INTEGER(I4P) :: SIZE_N3 !< DIMENSION 3 SIZE - - SIZE_N1 = SIZE(X, DIM=1) - SIZE_N2 = SIZE(X, DIM=2) - SIZE_N3 = SIZE(X, DIM=3) - - L = DI8P + 1 - SP = 0 - CODE = REPEAT(' ',L*SIZE_N1*SIZE_N2*SIZE_N3) - DO N3=1, SIZE(X, DIM=3) - DO N2=1, SIZE(X, DIM=2) - DO N1=1, SIZE(X, DIM=1)-1 - CODE(SP+1:SP+L) = STR(N=X(N1, N2, N3))//' ' - SP = SP + L - ENDDO - CODE(SP+1:SP+L) = ' '//STR(N=X(SIZE(X, DIM=1), N2, N3)) - SP = SP + L - ENDDO - ENDDO - ENDFUNCTION ENCODE_ASCII_DATAARRAY1_RANK3_I8P - - FUNCTION ENCODE_ASCII_DATAARRAY1_RANK3_I4P(X) RESULT(CODE) - !< ENCODE (BASE64) A DATAARRAY WITH 1 COMPONENTS OF RANK 3 (I4P). - INTEGER(I4P), INTENT(IN) :: X(1:,1:,1:) !< DATA VARIABLE - CHARACTER(LEN=:), ALLOCATABLE :: CODE !< ENCODED BASE64 DATAARRAY. - INTEGER(I4P) :: N1 !< COUNTER. - INTEGER(I4P) :: N2 !< COUNTER. - INTEGER(I4P) :: N3 !< COUNTER. - INTEGER(I4P) :: L !< LENGTH - INTEGER(I4P) :: SP !< STRING POINTER - INTEGER(I4P) :: SIZE_N1 !< DIMENSION 1 SIZE - INTEGER(I4P) :: SIZE_N2 !< DIMENSION 2 SIZE - INTEGER(I4P) :: SIZE_N3 !< DIMENSION 3 SIZE - - SIZE_N1 = SIZE(X, DIM=1) - SIZE_N2 = SIZE(X, DIM=2) - SIZE_N3 = SIZE(X, DIM=3) - - L = DI4P + 1 - SP = 0 - CODE = REPEAT(' ',L*SIZE_N1*SIZE_N2*SIZE_N3) - DO N3=1, SIZE(X, DIM=3) - DO N2=1, SIZE(X, DIM=2) - DO N1=1, SIZE(X, DIM=1)-1 - CODE(SP+1:SP+L) = STR(N=X(N1, N2, N3))//' ' - SP = SP + L - ENDDO - CODE(SP+1:SP+L) = ' '//STR(N=X(SIZE(X, DIM=1), N2, N3)) - SP = SP + L - ENDDO - ENDDO - ENDFUNCTION ENCODE_ASCII_DATAARRAY1_RANK3_I4P - - FUNCTION ENCODE_ASCII_DATAARRAY1_RANK3_I2P(X) RESULT(CODE) - !< ENCODE (BASE64) A DATAARRAY WITH 1 COMPONENTS OF RANK 3 (I2P). - INTEGER(I2P), INTENT(IN) :: X(1:,1:,1:) !< DATA VARIABLE - CHARACTER(LEN=:), ALLOCATABLE :: CODE !< ENCODED BASE64 DATAARRAY. - INTEGER(I4P) :: N1 !< COUNTER. - INTEGER(I4P) :: N2 !< COUNTER. - INTEGER(I4P) :: N3 !< COUNTER. - INTEGER(I4P) :: L !< LENGTH - INTEGER(I4P) :: SP !< STRING POINTER - INTEGER(I4P) :: SIZE_N1 !< DIMENSION 1 SIZE - INTEGER(I4P) :: SIZE_N2 !< DIMENSION 2 SIZE - INTEGER(I4P) :: SIZE_N3 !< DIMENSION 3 SIZE - - SIZE_N1 = SIZE(X, DIM=1) - SIZE_N2 = SIZE(X, DIM=2) - SIZE_N3 = SIZE(X, DIM=3) - - L = DI2P + 1 - SP = 0 - CODE = REPEAT(' ',L*SIZE_N1*SIZE_N2*SIZE_N3) - DO N3=1, SIZE(X, DIM=3) - DO N2=1, SIZE(X, DIM=2) - DO N1=1, SIZE(X, DIM=1)-1 - CODE(SP+1:SP+L) = STR(N=X(N1, N2, N3))//' ' - SP = SP + L - ENDDO - CODE(SP+1:SP+L) = ' '//STR(N=X(SIZE(X, DIM=1), N2, N3)) - SP = SP + L - ENDDO - ENDDO - ENDFUNCTION ENCODE_ASCII_DATAARRAY1_RANK3_I2P - - FUNCTION ENCODE_ASCII_DATAARRAY1_RANK3_I1P(X) RESULT(CODE) - !< ENCODE (BASE64) A DATAARRAY WITH 1 COMPONENTS OF RANK 3 (I1P). - INTEGER(I1P), INTENT(IN) :: X(1:,1:,1:) !< DATA VARIABLE - CHARACTER(LEN=:), ALLOCATABLE :: CODE !< ENCODED BASE64 DATAARRAY. - INTEGER(I4P) :: N1 !< COUNTER. - INTEGER(I4P) :: N2 !< COUNTER. - INTEGER(I4P) :: N3 !< COUNTER. - INTEGER(I4P) :: L !< LENGTH - INTEGER(I4P) :: SP !< STRING POINTER - INTEGER(I4P) :: SIZE_N1 !< DIMENSION 1 SIZE - INTEGER(I4P) :: SIZE_N2 !< DIMENSION 2 SIZE - INTEGER(I4P) :: SIZE_N3 !< DIMENSION 3 SIZE - - SIZE_N1 = SIZE(X, DIM=1) - SIZE_N2 = SIZE(X, DIM=2) - SIZE_N3 = SIZE(X, DIM=3) - - L = DI1P + 1 - SP = 0 - CODE = REPEAT(' ',L*SIZE_N1*SIZE_N2*SIZE_N3) - DO N3=1, SIZE(X, DIM=3) - DO N2=1, SIZE(X, DIM=2) - DO N1=1, SIZE(X, DIM=1)-1 - CODE(SP+1:SP+L) = STR(N=X(N1, N2, N3))//' ' - SP = SP + L - ENDDO - CODE(SP+1:SP+L) = ' '//STR(N=X(SIZE(X, DIM=1), N2, N3)) - SP = SP + L - ENDDO - ENDDO - ENDFUNCTION ENCODE_ASCII_DATAARRAY1_RANK3_I1P - - FUNCTION ENCODE_ASCII_DATAARRAY1_RANK4_R16P(X) RESULT(CODE) - !< ENCODE (BASE64) A DATAARRAY WITH 1 COMPONENTS OF RANK 4 (R16P). - REAL(R16P), INTENT(IN) :: X(1:,1:,1:,1:) !< DATA VARIABLE. - CHARACTER(LEN=:), ALLOCATABLE :: CODE !< ENCODED BASE64 DATAARRAY. - INTEGER(I4P) :: N1 !< COUNTER. - INTEGER(I4P) :: N2 !< COUNTER. - INTEGER(I4P) :: N3 !< COUNTER. - INTEGER(I4P) :: N4 !< COUNTER. - INTEGER(I4P) :: L !< LENGTH - INTEGER(I4P) :: SP !< STRING POINTER - INTEGER(I4P) :: SIZE_N1 !< DIMENSION 1 SIZE - INTEGER(I4P) :: SIZE_N2 !< DIMENSION 2 SIZE - INTEGER(I4P) :: SIZE_N3 !< DIMENSION 3 SIZE - INTEGER(I4P) :: SIZE_N4 !< DIMENSION 4 SIZE - - SIZE_N1 = SIZE(X, DIM=1) - SIZE_N2 = SIZE(X, DIM=2) - SIZE_N3 = SIZE(X, DIM=3) - SIZE_N3 = SIZE(X, DIM=4) - - L = DR16P + 1 - SP = 0 - CODE = REPEAT(' ',L*SIZE_N1*SIZE_N2*SIZE_N3*SIZE_N4) - DO N4=1, SIZE(X, DIM=4) - DO N3=1, SIZE(X, DIM=3) - DO N2=1, SIZE(X, DIM=2) - DO N1=1, SIZE(X, DIM=1) - CODE(SP+1:SP+L) = STR(N=X(N1, N2, N3, N4))//' ' - SP = SP + L - ENDDO - ENDDO - ENDDO - ENDDO - ENDFUNCTION ENCODE_ASCII_DATAARRAY1_RANK4_R16P - - FUNCTION ENCODE_ASCII_DATAARRAY1_RANK4_R8P(X) RESULT(CODE) - !< ENCODE (BASE64) A DATAARRAY WITH 1 COMPONENTS OF RANK 4 (R8P). - REAL(R8P), INTENT(IN) :: X(1:,1:,1:,1:) !< DATA VARIABLE. - CHARACTER(LEN=:), ALLOCATABLE :: CODE !< ENCODED BASE64 DATAARRAY. - INTEGER(I4P) :: N1 !< COUNTER. - INTEGER(I4P) :: N2 !< COUNTER. - INTEGER(I4P) :: N3 !< COUNTER. - INTEGER(I4P) :: N4 !< COUNTER. - INTEGER(I4P) :: L !< LENGTH - INTEGER(I4P) :: SP !< STRING POINTER - INTEGER(I4P) :: SIZE_N1 !< DIMENSION 1 SIZE - INTEGER(I4P) :: SIZE_N2 !< DIMENSION 2 SIZE - INTEGER(I4P) :: SIZE_N3 !< DIMENSION 3 SIZE - INTEGER(I4P) :: SIZE_N4 !< DIMENSION 4 SIZE - - SIZE_N1 = SIZE(X, DIM=1) - SIZE_N2 = SIZE(X, DIM=2) - SIZE_N3 = SIZE(X, DIM=3) - SIZE_N3 = SIZE(X, DIM=4) - - L = DR8P + 1 - SP = 0 - CODE = REPEAT(' ',L*SIZE_N1*SIZE_N2*SIZE_N3*SIZE_N4) - DO N4=1, SIZE(X, DIM=4) - DO N3=1, SIZE(X, DIM=3) - DO N2=1, SIZE(X, DIM=2) - DO N1=1, SIZE(X, DIM=1) - CODE(SP+1:SP+L) = STR(N=X(N1, N2, N3, N4))//' ' - SP = SP + L - ENDDO - ENDDO - ENDDO - ENDDO - ENDFUNCTION ENCODE_ASCII_DATAARRAY1_RANK4_R8P - - FUNCTION ENCODE_ASCII_DATAARRAY1_RANK4_R4P(X) RESULT(CODE) - !< ENCODE (BASE64) A DATAARRAY WITH 1 COMPONENTS OF RANK 4 (R4P). - REAL(R4P), INTENT(IN) :: X(1:,1:,1:,1:) !< DATA VARIABLE. - CHARACTER(LEN=:), ALLOCATABLE :: CODE !< ENCODED BASE64 DATAARRAY. - INTEGER(I4P) :: N1 !< COUNTER. - INTEGER(I4P) :: N2 !< COUNTER. - INTEGER(I4P) :: N3 !< COUNTER. - INTEGER(I4P) :: N4 !< COUNTER. - INTEGER(I4P) :: L !< LENGTH - INTEGER(I4P) :: SP !< STRING POINTER - INTEGER(I4P) :: SIZE_N1 !< DIMENSION 1 SIZE - INTEGER(I4P) :: SIZE_N2 !< DIMENSION 2 SIZE - INTEGER(I4P) :: SIZE_N3 !< DIMENSION 3 SIZE - INTEGER(I4P) :: SIZE_N4 !< DIMENSION 4 SIZE - - SIZE_N1 = SIZE(X, DIM=1) - SIZE_N2 = SIZE(X, DIM=2) - SIZE_N3 = SIZE(X, DIM=3) - SIZE_N3 = SIZE(X, DIM=4) - - L = DR4P + 1 - SP = 0 - CODE = REPEAT(' ',L*SIZE_N1*SIZE_N2*SIZE_N3*SIZE_N4) - DO N4=1, SIZE(X, DIM=4) - DO N3=1, SIZE(X, DIM=3) - DO N2=1, SIZE(X, DIM=2) - DO N1=1, SIZE(X, DIM=1) - CODE(SP+1:SP+L) = STR(N=X(N1, N2, N3, N4))//' ' - SP = SP + L - ENDDO - ENDDO - ENDDO - ENDDO - ENDFUNCTION ENCODE_ASCII_DATAARRAY1_RANK4_R4P - - FUNCTION ENCODE_ASCII_DATAARRAY1_RANK4_I8P(X) RESULT(CODE) - !< ENCODE (BASE64) A DATAARRAY WITH 1 COMPONENTS OF RANK 4 (I8P). - INTEGER(I8P), INTENT(IN) :: X(1:,1:,1:,1:) !< DATA VARIABLE. - CHARACTER(LEN=:), ALLOCATABLE :: CODE !< ENCODED BASE64 DATAARRAY. - INTEGER(I4P) :: N1 !< COUNTER. - INTEGER(I4P) :: N2 !< COUNTER. - INTEGER(I4P) :: N3 !< COUNTER. - INTEGER(I4P) :: N4 !< COUNTER. - INTEGER(I4P) :: L !< LENGTH - INTEGER(I4P) :: SP !< STRING POINTER - INTEGER(I4P) :: SIZE_N1 !< DIMENSION 1 SIZE - INTEGER(I4P) :: SIZE_N2 !< DIMENSION 2 SIZE - INTEGER(I4P) :: SIZE_N3 !< DIMENSION 3 SIZE - INTEGER(I4P) :: SIZE_N4 !< DIMENSION 4 SIZE - - SIZE_N1 = SIZE(X, DIM=1) - SIZE_N2 = SIZE(X, DIM=2) - SIZE_N3 = SIZE(X, DIM=3) - SIZE_N3 = SIZE(X, DIM=4) - - L = DI8P + 1 - SP = 0 - CODE = REPEAT(' ',L*SIZE_N1*SIZE_N2*SIZE_N3*SIZE_N4) - DO N4=1, SIZE(X, DIM=4) - DO N3=1, SIZE(X, DIM=3) - DO N2=1, SIZE(X, DIM=2) - DO N1=1, SIZE(X, DIM=1) - CODE(SP+1:SP+L) = STR(N=X(N1, N2, N3, N4))//' ' - SP = SP + L - ENDDO - ENDDO - ENDDO - ENDDO - ENDFUNCTION ENCODE_ASCII_DATAARRAY1_RANK4_I8P - - FUNCTION ENCODE_ASCII_DATAARRAY1_RANK4_I4P(X) RESULT(CODE) - !< ENCODE (BASE64) A DATAARRAY WITH 1 COMPONENTS OF RANK 4 (I4P). - INTEGER(I4P), INTENT(IN) :: X(1:,1:,1:,1:) !< DATA VARIABLE. - CHARACTER(LEN=:), ALLOCATABLE :: CODE !< ENCODED BASE64 DATAARRAY. - INTEGER(I4P) :: N1 !< COUNTER. - INTEGER(I4P) :: N2 !< COUNTER. - INTEGER(I4P) :: N3 !< COUNTER. - INTEGER(I4P) :: N4 !< COUNTER. - INTEGER(I4P) :: L !< LENGTH - INTEGER(I4P) :: SP !< STRING POINTER - INTEGER(I4P) :: SIZE_N1 !< DIMENSION 1 SIZE - INTEGER(I4P) :: SIZE_N2 !< DIMENSION 2 SIZE - INTEGER(I4P) :: SIZE_N3 !< DIMENSION 3 SIZE - INTEGER(I4P) :: SIZE_N4 !< DIMENSION 4 SIZE - - SIZE_N1 = SIZE(X, DIM=1) - SIZE_N2 = SIZE(X, DIM=2) - SIZE_N3 = SIZE(X, DIM=3) - SIZE_N3 = SIZE(X, DIM=4) - - L = DI4P + 1 - SP = 0 - CODE = REPEAT(' ',L*SIZE_N1*SIZE_N2*SIZE_N3*SIZE_N4) - DO N4=1, SIZE(X, DIM=4) - DO N3=1, SIZE(X, DIM=3) - DO N2=1, SIZE(X, DIM=2) - DO N1=1, SIZE(X, DIM=1) - CODE(SP+1:SP+L) = STR(N=X(N1, N2, N3, N4))//' ' - SP = SP + L - ENDDO - ENDDO - ENDDO - ENDDO - ENDFUNCTION ENCODE_ASCII_DATAARRAY1_RANK4_I4P - - FUNCTION ENCODE_ASCII_DATAARRAY1_RANK4_I2P(X) RESULT(CODE) - !< ENCODE (BASE64) A DATAARRAY WITH 1 COMPONENTS OF RANK 4 (I2P). - INTEGER(I2P), INTENT(IN) :: X(1:,1:,1:,1:) !< DATA VARIABLE. - CHARACTER(LEN=:), ALLOCATABLE :: CODE !< ENCODED BASE64 DATAARRAY. - INTEGER(I4P) :: N1 !< COUNTER. - INTEGER(I4P) :: N2 !< COUNTER. - INTEGER(I4P) :: N3 !< COUNTER. - INTEGER(I4P) :: N4 !< COUNTER. - INTEGER(I4P) :: L !< LENGTH - INTEGER(I4P) :: SP !< STRING POINTER - INTEGER(I4P) :: SIZE_N1 !< DIMENSION 1 SIZE - INTEGER(I4P) :: SIZE_N2 !< DIMENSION 2 SIZE - INTEGER(I4P) :: SIZE_N3 !< DIMENSION 3 SIZE - INTEGER(I4P) :: SIZE_N4 !< DIMENSION 4 SIZE - - SIZE_N1 = SIZE(X, DIM=1) - SIZE_N2 = SIZE(X, DIM=2) - SIZE_N3 = SIZE(X, DIM=3) - SIZE_N3 = SIZE(X, DIM=4) - - L = DI2P + 1 - SP = 0 - CODE = REPEAT(' ',L*SIZE_N1*SIZE_N2*SIZE_N3*SIZE_N4) - DO N4=1, SIZE(X, DIM=4) - DO N3=1, SIZE(X, DIM=3) - DO N2=1, SIZE(X, DIM=2) - DO N1=1, SIZE(X, DIM=1) - CODE(SP+1:SP+L) = STR(N=X(N1, N2, N3, N4))//' ' - SP = SP + L - ENDDO - ENDDO - ENDDO - ENDDO - ENDFUNCTION ENCODE_ASCII_DATAARRAY1_RANK4_I2P - - FUNCTION ENCODE_ASCII_DATAARRAY1_RANK4_I1P(X) RESULT(CODE) - !< ENCODE (BASE64) A DATAARRAY WITH 1 COMPONENTS OF RANK 4 (I1P). - INTEGER(I1P), INTENT(IN) :: X(1:,1:,1:,1:) !< DATA VARIABLE. - CHARACTER(LEN=:), ALLOCATABLE :: CODE !< ENCODED BASE64 DATAARRAY. - INTEGER(I4P) :: N1 !< COUNTER. - INTEGER(I4P) :: N2 !< COUNTER. - INTEGER(I4P) :: N3 !< COUNTER. - INTEGER(I4P) :: N4 !< COUNTER. - INTEGER(I4P) :: L !< LENGTH - INTEGER(I4P) :: SP !< STRING POINTER - INTEGER(I4P) :: SIZE_N1 !< DIMENSION 1 SIZE - INTEGER(I4P) :: SIZE_N2 !< DIMENSION 2 SIZE - INTEGER(I4P) :: SIZE_N3 !< DIMENSION 3 SIZE - INTEGER(I4P) :: SIZE_N4 !< DIMENSION 4 SIZE - - SIZE_N1 = SIZE(X, DIM=1) - SIZE_N2 = SIZE(X, DIM=2) - SIZE_N3 = SIZE(X, DIM=3) - SIZE_N3 = SIZE(X, DIM=4) - - L = DI1P + 1 - SP = 0 - CODE = REPEAT(' ',L*SIZE_N1*SIZE_N2*SIZE_N3*SIZE_N4) - DO N4=1, SIZE(X, DIM=4) - DO N3=1, SIZE(X, DIM=3) - DO N2=1, SIZE(X, DIM=2) - DO N1=1, SIZE(X, DIM=1) - CODE(SP+1:SP+L) = STR(N=X(N1, N2, N3, N4))//' ' - SP = SP + L - ENDDO - ENDDO - ENDDO - ENDDO - ENDFUNCTION ENCODE_ASCII_DATAARRAY1_RANK4_I1P - FUNCTION ENCODE_ASCII_DATAARRAY3_RANK1_R16P(X, Y, Z) RESULT(CODE) !< ENCODE (BASE64) A DATAARRAY WITH 3 COMPONENTS OF RANK 1 (R16P). REAL(R16P), INTENT(IN) :: X(1:) !< X COMPONENT. @@ -12306,657 +10571,6 @@ FUNCTION ENCODE_ASCII_DATAARRAY3_RANK1_I1P(X, Y, Z) RESULT(CODE) ENDDO ENDFUNCTION ENCODE_ASCII_DATAARRAY3_RANK1_I1P - FUNCTION ENCODE_ASCII_DATAARRAY3_RANK3_R16P(X, Y, Z) RESULT(CODE) - !< ENCODE (BASE64) A DATAARRAY WITH 3 COMPONENTS OF RANK 3 (R8P). - REAL(R16P), INTENT(IN) :: X(1:,1:,1:) !< X COMPONENT. - REAL(R16P), INTENT(IN) :: Y(1:,1:,1:) !< Y COMPONENT. - REAL(R16P), INTENT(IN) :: Z(1:,1:,1:) !< Z COMPONENT. - CHARACTER(LEN=:), ALLOCATABLE :: CODE !< ENCODED BASE64 DATAARRAY. - INTEGER(I4P) :: N1 !< COUNTER. - INTEGER(I4P) :: N2 !< COUNTER. - INTEGER(I4P) :: N3 !< COUNTER. - INTEGER(I4P) :: L !< LENGTH - INTEGER(I4P) :: SP !< STRING POINTER - INTEGER(I4P) :: SIZE_N1 !< DIMENSION 1 SIZE - INTEGER(I4P) :: SIZE_N2 !< DIMENSION 2 SIZE - INTEGER(I4P) :: SIZE_N3 !< DIMENSION 3 SIZE - - SIZE_N1 = SIZE(X, DIM=1) - SIZE_N2 = SIZE(X, DIM=2) - SIZE_N3 = SIZE(X, DIM=3) - - L = DR16P*3 + 2 - SP = 0 - CODE = REPEAT(' ',L*SIZE_N1*SIZE_N2*SIZE_N3) - DO N3=1, SIZE(X, DIM=3) - DO N2=1, SIZE(X, DIM=2) - DO N1=1, SIZE(X, DIM=1) - CODE(SP+1:SP+L) = STR(N=X(N1, N2, N3))//' '//STR(N=Y(N1, N2, N3))//' '//STR(N=Z(N1, N2, N3)) - SP = SP + L - ENDDO - ENDDO - ENDDO - ENDFUNCTION ENCODE_ASCII_DATAARRAY3_RANK3_R16P - - FUNCTION ENCODE_ASCII_DATAARRAY3_RANK3_R8P(X, Y, Z) RESULT(CODE) - !< ENCODE (BASE64) A DATAARRAY WITH 3 COMPONENTS OF RANK 3 (R8P). - REAL(R8P), INTENT(IN) :: X(1:,1:,1:) !< X COMPONENT. - REAL(R8P), INTENT(IN) :: Y(1:,1:,1:) !< Y COMPONENT. - REAL(R8P), INTENT(IN) :: Z(1:,1:,1:) !< Z COMPONENT. - CHARACTER(LEN=:), ALLOCATABLE :: CODE !< ENCODED BASE64 DATAARRAY. - INTEGER(I4P) :: N1 !< COUNTER. - INTEGER(I4P) :: N2 !< COUNTER. - INTEGER(I4P) :: N3 !< COUNTER. - INTEGER(I4P) :: L !< LENGTH - INTEGER(I4P) :: SP !< STRING POINTER - INTEGER(I4P) :: SIZE_N1 !< DIMENSION 1 SIZE - INTEGER(I4P) :: SIZE_N2 !< DIMENSION 2 SIZE - INTEGER(I4P) :: SIZE_N3 !< DIMENSION 3 SIZE - - SIZE_N1 = SIZE(X, DIM=1) - SIZE_N2 = SIZE(X, DIM=2) - SIZE_N3 = SIZE(X, DIM=3) - - L = DR8P*3 + 2 - SP = 0 - CODE = REPEAT(' ',L*SIZE_N1*SIZE_N2*SIZE_N3) - DO N3=1, SIZE(X, DIM=3) - DO N2=1, SIZE(X, DIM=2) - DO N1=1, SIZE(X, DIM=1) - CODE(SP+1:SP+L) = STR(N=X(N1, N2, N3))//' '//STR(N=Y(N1, N2, N3))//' '//STR(N=Z(N1, N2, N3)) - SP = SP + L - ENDDO - ENDDO - ENDDO - ENDFUNCTION ENCODE_ASCII_DATAARRAY3_RANK3_R8P - - FUNCTION ENCODE_ASCII_DATAARRAY3_RANK3_R4P(X, Y, Z) RESULT(CODE) - !< ENCODE (BASE64) A DATAARRAY WITH 3 COMPONENTS OF RANK 3 (R4P). - REAL(R4P), INTENT(IN) :: X(1:,1:,1:) !< X COMPONENT. - REAL(R4P), INTENT(IN) :: Y(1:,1:,1:) !< Y COMPONENT. - REAL(R4P), INTENT(IN) :: Z(1:,1:,1:) !< Z COMPONENT. - CHARACTER(LEN=:), ALLOCATABLE :: CODE !< ENCODED BASE64 DATAARRAY. - INTEGER(I4P) :: N1 !< COUNTER. - INTEGER(I4P) :: N2 !< COUNTER. - INTEGER(I4P) :: N3 !< COUNTER. - INTEGER(I4P) :: L !< LENGTH - INTEGER(I4P) :: SP !< STRING POINTER - INTEGER(I4P) :: SIZE_N1 !< DIMENSION 1 SIZE - INTEGER(I4P) :: SIZE_N2 !< DIMENSION 2 SIZE - INTEGER(I4P) :: SIZE_N3 !< DIMENSION 3 SIZE - - SIZE_N1 = SIZE(X, DIM=1) - SIZE_N2 = SIZE(X, DIM=2) - SIZE_N3 = SIZE(X, DIM=3) - - L = DR4P*3 + 2 - SP = 0 - CODE = REPEAT(' ',L*SIZE_N1*SIZE_N2*SIZE_N3) - DO N3=1, SIZE(X, DIM=3) - DO N2=1, SIZE(X, DIM=2) - DO N1=1, SIZE(X, DIM=1) - CODE(SP+1:SP+L) = STR(N=X(N1, N2, N3))//' '//STR(N=Y(N1, N2, N3))//' '//STR(N=Z(N1, N2, N3)) - SP = SP + L - ENDDO - ENDDO - ENDDO - ENDFUNCTION ENCODE_ASCII_DATAARRAY3_RANK3_R4P - - FUNCTION ENCODE_ASCII_DATAARRAY3_RANK3_I8P(X, Y, Z) RESULT(CODE) - !< ENCODE (BASE64) A DATAARRAY WITH 3 COMPONENTS OF RANK 3 (I8P). - INTEGER(I8P), INTENT(IN) :: X(1:,1:,1:) !< X COMPONENT. - INTEGER(I8P), INTENT(IN) :: Y(1:,1:,1:) !< Y COMPONENT. - INTEGER(I8P), INTENT(IN) :: Z(1:,1:,1:) !< Z COMPONENT. - CHARACTER(LEN=:), ALLOCATABLE :: CODE !< ENCODED BASE64 DATAARRAY. - INTEGER(I4P) :: N1 !< COUNTER. - INTEGER(I4P) :: N2 !< COUNTER. - INTEGER(I4P) :: N3 !< COUNTER. - INTEGER(I4P) :: L !< LENGTH - INTEGER(I4P) :: SP !< STRING POINTER - INTEGER(I4P) :: SIZE_N1 !< DIMENSION 1 SIZE - INTEGER(I4P) :: SIZE_N2 !< DIMENSION 2 SIZE - INTEGER(I4P) :: SIZE_N3 !< DIMENSION 3 SIZE - - SIZE_N1 = SIZE(X, DIM=1) - SIZE_N2 = SIZE(X, DIM=2) - SIZE_N3 = SIZE(X, DIM=3) - - L = DI8P*3 + 2 - SP = 0 - CODE = REPEAT(' ',L*SIZE_N1*SIZE_N2*SIZE_N3) - DO N3=1, SIZE(X, DIM=3) - DO N2=1, SIZE(X, DIM=2) - DO N1=1, SIZE(X, DIM=1) - CODE(SP+1:SP+L) = STR(N=X(N1, N2, N3))//' '//STR(N=Y(N1, N2, N3))//' '//STR(N=Z(N1, N2, N3)) - SP = SP + L - ENDDO - ENDDO - ENDDO - ENDFUNCTION ENCODE_ASCII_DATAARRAY3_RANK3_I8P - - FUNCTION ENCODE_ASCII_DATAARRAY3_RANK3_I4P(X, Y, Z) RESULT(CODE) - !< ENCODE (BASE64) A DATAARRAY WITH 3 COMPONENTS OF RANK 3 (I4P). - INTEGER(I4P), INTENT(IN) :: X(1:,1:,1:) !< X COMPONENT. - INTEGER(I4P), INTENT(IN) :: Y(1:,1:,1:) !< Y COMPONENT. - INTEGER(I4P), INTENT(IN) :: Z(1:,1:,1:) !< Z COMPONENT. - CHARACTER(LEN=:), ALLOCATABLE :: CODE !< ENCODED BASE64 DATAARRAY. - INTEGER(I4P) :: N1 !< COUNTER. - INTEGER(I4P) :: N2 !< COUNTER. - INTEGER(I4P) :: N3 !< COUNTER. - INTEGER(I4P) :: L !< LENGTH - INTEGER(I4P) :: SP !< STRING POINTER - INTEGER(I4P) :: SIZE_N1 !< DIMENSION 1 SIZE - INTEGER(I4P) :: SIZE_N2 !< DIMENSION 2 SIZE - INTEGER(I4P) :: SIZE_N3 !< DIMENSION 3 SIZE - - SIZE_N1 = SIZE(X, DIM=1) - SIZE_N2 = SIZE(X, DIM=2) - SIZE_N3 = SIZE(X, DIM=3) - - L = DI4P*3 + 2 - SP = 0 - CODE = REPEAT(' ',L*SIZE_N1*SIZE_N2*SIZE_N3) - DO N3=1, SIZE(X, DIM=3) - DO N2=1, SIZE(X, DIM=2) - DO N1=1, SIZE(X, DIM=1) - CODE(SP+1:SP+L) = STR(N=X(N1, N2, N3))//' '//STR(N=Y(N1, N2, N3))//' '//STR(N=Z(N1, N2, N3)) - SP = SP + L - ENDDO - ENDDO - ENDDO - ENDFUNCTION ENCODE_ASCII_DATAARRAY3_RANK3_I4P - - FUNCTION ENCODE_ASCII_DATAARRAY3_RANK3_I2P(X, Y, Z) RESULT(CODE) - !< ENCODE (BASE64) A DATAARRAY WITH 3 COMPONENTS OF RANK 3 (I2P). - INTEGER(I2P), INTENT(IN) :: X(1:,1:,1:) !< X COMPONENT. - INTEGER(I2P), INTENT(IN) :: Y(1:,1:,1:) !< Y COMPONENT. - INTEGER(I2P), INTENT(IN) :: Z(1:,1:,1:) !< Z COMPONENT. - CHARACTER(LEN=:), ALLOCATABLE :: CODE !< ENCODED BASE64 DATAARRAY. - INTEGER(I4P) :: N1 !< COUNTER. - INTEGER(I4P) :: N2 !< COUNTER. - INTEGER(I4P) :: N3 !< COUNTER. - INTEGER(I4P) :: L !< LENGTH - INTEGER(I4P) :: SP !< STRING POINTER - INTEGER(I4P) :: SIZE_N1 !< DIMENSION 1 SIZE - INTEGER(I4P) :: SIZE_N2 !< DIMENSION 2 SIZE - INTEGER(I4P) :: SIZE_N3 !< DIMENSION 3 SIZE - - SIZE_N1 = SIZE(X, DIM=1) - SIZE_N2 = SIZE(X, DIM=2) - SIZE_N3 = SIZE(X, DIM=3) - - L = DI2P*3 + 2 - SP = 0 - CODE = REPEAT(' ',L*SIZE_N1*SIZE_N2*SIZE_N3) - DO N3=1, SIZE(X, DIM=3) - DO N2=1, SIZE(X, DIM=2) - DO N1=1, SIZE(X, DIM=1) - CODE(SP+1:SP+L) = STR(N=X(N1, N2, N3))//' '//STR(N=Y(N1, N2, N3))//' '//STR(N=Z(N1, N2, N3)) - SP = SP + L - ENDDO - ENDDO - ENDDO - ENDFUNCTION ENCODE_ASCII_DATAARRAY3_RANK3_I2P - - FUNCTION ENCODE_ASCII_DATAARRAY3_RANK3_I1P(X, Y, Z) RESULT(CODE) - !< ENCODE (BASE64) A DATAARRAY WITH 3 COMPONENTS OF RANK 3 (I1P). - INTEGER(I1P), INTENT(IN) :: X(1:,1:,1:) !< X COMPONENT. - INTEGER(I1P), INTENT(IN) :: Y(1:,1:,1:) !< Y COMPONENT. - INTEGER(I1P), INTENT(IN) :: Z(1:,1:,1:) !< Z COMPONENT. - CHARACTER(LEN=:), ALLOCATABLE :: CODE !< ENCODED BASE64 DATAARRAY. - INTEGER(I4P) :: N1 !< COUNTER. - INTEGER(I4P) :: N2 !< COUNTER. - INTEGER(I4P) :: N3 !< COUNTER. - INTEGER(I4P) :: L !< LENGTH - INTEGER(I4P) :: SP !< STRING POINTER - INTEGER(I4P) :: SIZE_N1 !< DIMENSION 1 SIZE - INTEGER(I4P) :: SIZE_N2 !< DIMENSION 2 SIZE - INTEGER(I4P) :: SIZE_N3 !< DIMENSION 3 SIZE - - SIZE_N1 = SIZE(X, DIM=1) - SIZE_N2 = SIZE(X, DIM=2) - SIZE_N3 = SIZE(X, DIM=3) - - L = DI1P*3 + 2 - SP = 0 - CODE = REPEAT(' ',L*SIZE_N1*SIZE_N2*SIZE_N3) - DO N3=1, SIZE(X, DIM=3) - DO N2=1, SIZE(X, DIM=2) - DO N1=1, SIZE(X, DIM=1) - CODE(SP+1:SP+L) = STR(N=X(N1, N2, N3))//' '//STR(N=Y(N1, N2, N3))//' '//STR(N=Z(N1, N2, N3)) - SP = SP + L - ENDDO - ENDDO - ENDDO - ENDFUNCTION ENCODE_ASCII_DATAARRAY3_RANK3_I1P - - FUNCTION ENCODE_ASCII_DATAARRAY6_RANK1_R16P(U, V, W, X, Y, Z) RESULT(CODE) - !< ENCODE (BASE64) A DATAARRAY WITH 6 COMPONENTS OF RANK 1 (R16P). - REAL(R16P), INTENT(IN) :: U(1:) !< U COMPONENT. - REAL(R16P), INTENT(IN) :: V(1:) !< V COMPONENT. - REAL(R16P), INTENT(IN) :: W(1:) !< W COMPONENT. - REAL(R16P), INTENT(IN) :: X(1:) !< X COMPONENT. - REAL(R16P), INTENT(IN) :: Y(1:) !< Y COMPONENT. - REAL(R16P), INTENT(IN) :: Z(1:) !< Z COMPONENT. - CHARACTER(LEN=:), ALLOCATABLE :: CODE !< ENCODED BASE64 DATAARRAY. - INTEGER(I4P) :: N !< COUNTER. - INTEGER(I4P) :: L !< LENGTH - INTEGER(I4P) :: SP !< STRING POINTER - INTEGER(I4P) :: SIZE_N!< DIMENSION 1 SIZE - - SIZE_N = SIZE(X, DIM=1) - L = DR16P*6 + 5 - SP = 0 - CODE = REPEAT(' ',L*SIZE_N) - DO N=1, SIZE_N - CODE(SP+1:SP+L) = STR(N=U(N))//' '//STR(N=V(N))//' '//STR(N=W(N))// & - STR(N=X(N))//' '//STR(N=Y(N))//' '//STR(N=Z(N)) - SP = SP + L - ENDDO - ENDFUNCTION ENCODE_ASCII_DATAARRAY6_RANK1_R16P - - FUNCTION ENCODE_ASCII_DATAARRAY6_RANK1_R8P(U, V, W, X, Y, Z) RESULT(CODE) - !< ENCODE (BASE64) A DATAARRAY WITH 6 COMPONENTS OF RANK 1 (R8P). - REAL(R8P), INTENT(IN) :: U(1:) !< U COMPONENT. - REAL(R8P), INTENT(IN) :: V(1:) !< V COMPONENT. - REAL(R8P), INTENT(IN) :: W(1:) !< W COMPONENT. - REAL(R8P), INTENT(IN) :: X(1:) !< X COMPONENT. - REAL(R8P), INTENT(IN) :: Y(1:) !< Y COMPONENT. - REAL(R8P), INTENT(IN) :: Z(1:) !< Z COMPONENT. - CHARACTER(LEN=:), ALLOCATABLE :: CODE !< ENCODED BASE64 DATAARRAY. - INTEGER(I4P) :: N !< COUNTER. - INTEGER(I4P) :: L !< LENGTH - INTEGER(I4P) :: SP !< STRING POINTER - INTEGER(I4P) :: SIZE_N!< DIMENSION 1 SIZE - - SIZE_N = SIZE(X, DIM=1) - L = DR8P*6 + 5 - SP = 0 - CODE = REPEAT(' ',L*SIZE_N) - DO N=1, SIZE_N - CODE(SP+1:SP+L) = STR(N=U(N))//' '//STR(N=V(N))//' '//STR(N=W(N))// & - STR(N=X(N))//' '//STR(N=Y(N))//' '//STR(N=Z(N)) - SP = SP + L - ENDDO - ENDFUNCTION ENCODE_ASCII_DATAARRAY6_RANK1_R8P - - FUNCTION ENCODE_ASCII_DATAARRAY6_RANK1_R4P(U, V, W, X, Y, Z) RESULT(CODE) - !< ENCODE (BASE64) A DATAARRAY WITH 6 COMPONENTS OF RANK 1 (R4P). - REAL(R4P), INTENT(IN) :: U(1:) !< U COMPONENT. - REAL(R4P), INTENT(IN) :: V(1:) !< V COMPONENT. - REAL(R4P), INTENT(IN) :: W(1:) !< W COMPONENT. - REAL(R4P), INTENT(IN) :: X(1:) !< X COMPONENT. - REAL(R4P), INTENT(IN) :: Y(1:) !< Y COMPONENT. - REAL(R4P), INTENT(IN) :: Z(1:) !< Z COMPONENT. - CHARACTER(LEN=:), ALLOCATABLE :: CODE !< ENCODED BASE64 DATAARRAY. - INTEGER(I4P) :: N !< COUNTER. - INTEGER(I4P) :: L !< LENGTH - INTEGER(I4P) :: SP !< STRING POINTER - INTEGER(I4P) :: SIZE_N!< DIMENSION 1 SIZE - - SIZE_N = SIZE(X, DIM=1) - L = DR4P*6 + 5 - SP = 0 - CODE = REPEAT(' ',L*SIZE_N) - DO N=1, SIZE_N - CODE(SP+1:SP+L) = STR(N=U(N))//' '//STR(N=V(N))//' '//STR(N=W(N))// & - STR(N=X(N))//' '//STR(N=Y(N))//' '//STR(N=Z(N)) - SP = SP + L - ENDDO - ENDFUNCTION ENCODE_ASCII_DATAARRAY6_RANK1_R4P - - FUNCTION ENCODE_ASCII_DATAARRAY6_RANK1_I8P(U, V, W, X, Y, Z) RESULT(CODE) - !< ENCODE (BASE64) A DATAARRAY WITH 6 COMPONENTS OF RANK 1 (I8P). - INTEGER(I8P), INTENT(IN) :: U(1:) !< U COMPONENT. - INTEGER(I8P), INTENT(IN) :: V(1:) !< V COMPONENT. - INTEGER(I8P), INTENT(IN) :: W(1:) !< W COMPONENT. - INTEGER(I8P), INTENT(IN) :: X(1:) !< X COMPONENT. - INTEGER(I8P), INTENT(IN) :: Y(1:) !< Y COMPONENT. - INTEGER(I8P), INTENT(IN) :: Z(1:) !< Z COMPONENT. - CHARACTER(LEN=:), ALLOCATABLE :: CODE !< ENCODED BASE64 DATAARRAY. - INTEGER(I4P) :: N !< COUNTER. - INTEGER(I4P) :: L !< LENGTH - INTEGER(I4P) :: SP !< STRING POINTER - INTEGER(I4P) :: SIZE_N!< DIMENSION 1 SIZE - - SIZE_N = SIZE(X, DIM=1) - L = DI8P*6 + 5 - SP = 0 - CODE = REPEAT(' ',L*SIZE_N) - DO N=1, SIZE_N - CODE(SP+1:SP+L) = STR(N=U(N))//' '//STR(N=V(N))//' '//STR(N=W(N))// & - STR(N=X(N))//' '//STR(N=Y(N))//' '//STR(N=Z(N)) - SP = SP + L - ENDDO - ENDFUNCTION ENCODE_ASCII_DATAARRAY6_RANK1_I8P - - FUNCTION ENCODE_ASCII_DATAARRAY6_RANK1_I4P(U, V, W, X, Y, Z) RESULT(CODE) - !< ENCODE (BASE64) A DATAARRAY WITH 6 COMPONENTS OF RANK 1 (I4P). - INTEGER(I4P), INTENT(IN) :: U(1:) !< U COMPONENT. - INTEGER(I4P), INTENT(IN) :: V(1:) !< V COMPONENT. - INTEGER(I4P), INTENT(IN) :: W(1:) !< W COMPONENT. - INTEGER(I4P), INTENT(IN) :: X(1:) !< X COMPONENT. - INTEGER(I4P), INTENT(IN) :: Y(1:) !< Y COMPONENT. - INTEGER(I4P), INTENT(IN) :: Z(1:) !< Z COMPONENT. - CHARACTER(LEN=:), ALLOCATABLE :: CODE !< ENCODED BASE64 DATAARRAY. - INTEGER(I4P) :: N !< COUNTER. - INTEGER(I4P) :: L !< LENGTH - INTEGER(I4P) :: SP !< STRING POINTER - INTEGER(I4P) :: SIZE_N!< DIMENSION 1 SIZE - - SIZE_N = SIZE(X, DIM=1) - L = DI4P*6 + 5 - SP = 0 - CODE = REPEAT(' ',L*SIZE_N) - DO N=1, SIZE_N - CODE(SP+1:SP+L) = STR(N=U(N))//' '//STR(N=V(N))//' '//STR(N=W(N))// & - STR(N=X(N))//' '//STR(N=Y(N))//' '//STR(N=Z(N)) - SP = SP + L - ENDDO - ENDFUNCTION ENCODE_ASCII_DATAARRAY6_RANK1_I4P - - FUNCTION ENCODE_ASCII_DATAARRAY6_RANK1_I2P(U, V, W, X, Y, Z) RESULT(CODE) - !< ENCODE (BASE64) A DATAARRAY WITH 6 COMPONENTS OF RANK 1 (I2P). - INTEGER(I2P), INTENT(IN) :: U(1:) !< U COMPONENT. - INTEGER(I2P), INTENT(IN) :: V(1:) !< V COMPONENT. - INTEGER(I2P), INTENT(IN) :: W(1:) !< W COMPONENT. - INTEGER(I2P), INTENT(IN) :: X(1:) !< X COMPONENT. - INTEGER(I2P), INTENT(IN) :: Y(1:) !< Y COMPONENT. - INTEGER(I2P), INTENT(IN) :: Z(1:) !< Z COMPONENT. - CHARACTER(LEN=:), ALLOCATABLE :: CODE !< ENCODED BASE64 DATAARRAY. - INTEGER(I4P) :: N !< COUNTER. - INTEGER(I4P) :: L !< LENGTH - INTEGER(I4P) :: SP !< STRING POINTER - INTEGER(I4P) :: SIZE_N!< DIMENSION 1 SIZE - - SIZE_N = SIZE(X, DIM=1) - L = DI2P*6 + 5 - SP = 0 - CODE = REPEAT(' ',L*SIZE_N) - DO N=1, SIZE_N - CODE(SP+1:SP+L) = STR(N=U(N))//' '//STR(N=V(N))//' '//STR(N=W(N))// & - STR(N=X(N))//' '//STR(N=Y(N))//' '//STR(N=Z(N)) - SP = SP + L - ENDDO - ENDFUNCTION ENCODE_ASCII_DATAARRAY6_RANK1_I2P - - FUNCTION ENCODE_ASCII_DATAARRAY6_RANK1_I1P(U, V, W, X, Y, Z) RESULT(CODE) - !< ENCODE (BASE64) A DATAARRAY WITH 6 COMPONENTS OF RANK 1 (I1P). - INTEGER(I1P), INTENT(IN) :: U(1:) !< U COMPONENT. - INTEGER(I1P), INTENT(IN) :: V(1:) !< V COMPONENT. - INTEGER(I1P), INTENT(IN) :: W(1:) !< W COMPONENT. - INTEGER(I1P), INTENT(IN) :: X(1:) !< X COMPONENT. - INTEGER(I1P), INTENT(IN) :: Y(1:) !< Y COMPONENT. - INTEGER(I1P), INTENT(IN) :: Z(1:) !< Z COMPONENT. - CHARACTER(LEN=:), ALLOCATABLE :: CODE !< ENCODED BASE64 DATAARRAY. - INTEGER(I4P) :: N !< COUNTER. - INTEGER(I4P) :: L !< LENGTH - INTEGER(I4P) :: SP !< STRING POINTER - INTEGER(I4P) :: SIZE_N!< DIMENSION 1 SIZE - - SIZE_N = SIZE(X, DIM=1) - L = DI1P*6 + 5 - SP = 0 - CODE = REPEAT(' ',L*SIZE_N) - DO N=1, SIZE_N - CODE(SP+1:SP+L) = STR(N=U(N))//' '//STR(N=V(N))//' '//STR(N=W(N))// & - STR(N=X(N))//' '//STR(N=Y(N))//' '//STR(N=Z(N)) - SP = SP + L - ENDDO - ENDFUNCTION ENCODE_ASCII_DATAARRAY6_RANK1_I1P - - FUNCTION ENCODE_ASCII_DATAARRAY6_RANK3_R16P(U, V, W, X, Y, Z) RESULT(CODE) - !< ENCODE (BASE64) A DATAARRAY WITH 6 COMPONENTS OF RANK 3 (R8P). - REAL(R16P), INTENT(IN) :: U(1:,1:,1:) !< U COMPONENT. - REAL(R16P), INTENT(IN) :: V(1:,1:,1:) !< V COMPONENT. - REAL(R16P), INTENT(IN) :: W(1:,1:,1:) !< W COMPONENT. - REAL(R16P), INTENT(IN) :: X(1:,1:,1:) !< X COMPONENT. - REAL(R16P), INTENT(IN) :: Y(1:,1:,1:) !< Y COMPONENT. - REAL(R16P), INTENT(IN) :: Z(1:,1:,1:) !< Z COMPONENT. - CHARACTER(LEN=:), ALLOCATABLE :: CODE !< ENCODED BASE64 DATAARRAY. - INTEGER(I4P) :: N1 !< COUNTER. - INTEGER(I4P) :: N2 !< COUNTER. - INTEGER(I4P) :: N3 !< COUNTER. - INTEGER(I4P) :: L !< LENGTH - INTEGER(I4P) :: SP !< STRING POINTER - INTEGER(I4P) :: SIZE_N1 !< DIMENSION 1 SIZE - INTEGER(I4P) :: SIZE_N2 !< DIMENSION 2 SIZE - INTEGER(I4P) :: SIZE_N3 !< DIMENSION 3 SIZE - - SIZE_N1 = SIZE(X, DIM=1) - SIZE_N2 = SIZE(X, DIM=2) - SIZE_N3 = SIZE(X, DIM=3) - - L = DR16P*6 + 5 - SP = 0 - CODE = REPEAT(' ',L*SIZE_N1*SIZE_N2*SIZE_N3) - DO N3=1, SIZE_N3 - DO N2=1, SIZE_N2 - DO N1=1, SIZE_N1 - CODE(SP+1:SP+L) = STR(N=U(N1, N2, N3))//' '//STR(N=V(N1, N2, N3))//' '//STR(N=W(N1, N2, N3))// & - STR(N=X(N1, N2, N3))//' '//STR(N=Y(N1, N2, N3))//' '//STR(N=Z(N1, N2, N3)) - SP = SP + L - ENDDO - ENDDO - ENDDO - ENDFUNCTION ENCODE_ASCII_DATAARRAY6_RANK3_R16P - - FUNCTION ENCODE_ASCII_DATAARRAY6_RANK3_R8P(U, V, W, X, Y, Z) RESULT(CODE) - !< ENCODE (BASE64) A DATAARRAY WITH 6 COMPONENTS OF RANK 3 (R8P). - REAL(R8P), INTENT(IN) :: U(1:,1:,1:) !< U COMPONENT. - REAL(R8P), INTENT(IN) :: V(1:,1:,1:) !< V COMPONENT. - REAL(R8P), INTENT(IN) :: W(1:,1:,1:) !< W COMPONENT. - REAL(R8P), INTENT(IN) :: X(1:,1:,1:) !< X COMPONENT. - REAL(R8P), INTENT(IN) :: Y(1:,1:,1:) !< Y COMPONENT. - REAL(R8P), INTENT(IN) :: Z(1:,1:,1:) !< Z COMPONENT. - CHARACTER(LEN=:), ALLOCATABLE :: CODE !< ENCODED BASE64 DATAARRAY. - INTEGER(I4P) :: N1 !< COUNTER. - INTEGER(I4P) :: N2 !< COUNTER. - INTEGER(I4P) :: N3 !< COUNTER. - INTEGER(I4P) :: L !< LENGTH - INTEGER(I4P) :: SP !< STRING POINTER - INTEGER(I4P) :: SIZE_N1 !< DIMENSION 1 SIZE - INTEGER(I4P) :: SIZE_N2 !< DIMENSION 2 SIZE - INTEGER(I4P) :: SIZE_N3 !< DIMENSION 3 SIZE - - SIZE_N1 = SIZE(X, DIM=1) - SIZE_N2 = SIZE(X, DIM=2) - SIZE_N3 = SIZE(X, DIM=3) - - L = DR8P*6 + 5 - SP = 0 - CODE = REPEAT(' ',L*SIZE_N1*SIZE_N2*SIZE_N3) - DO N3=1, SIZE_N3 - DO N2=1, SIZE_N2 - DO N1=1, SIZE_N1 - CODE(SP+1:SP+L) = STR(N=U(N1, N2, N3))//' '//STR(N=V(N1, N2, N3))//' '//STR(N=W(N1, N2, N3))// & - STR(N=X(N1, N2, N3))//' '//STR(N=Y(N1, N2, N3))//' '//STR(N=Z(N1, N2, N3)) - SP = SP + L - ENDDO - ENDDO - ENDDO - ENDFUNCTION ENCODE_ASCII_DATAARRAY6_RANK3_R8P - - FUNCTION ENCODE_ASCII_DATAARRAY6_RANK3_R4P(U, V, W, X, Y, Z) RESULT(CODE) - !< ENCODE (BASE64) A DATAARRAY WITH 3 COMPONENTS OF RANK 3 (R4P). - REAL(R4P), INTENT(IN) :: U(1:,1:,1:) !< U COMPONENT. - REAL(R4P), INTENT(IN) :: V(1:,1:,1:) !< V COMPONENT. - REAL(R4P), INTENT(IN) :: W(1:,1:,1:) !< W COMPONENT. - REAL(R4P), INTENT(IN) :: X(1:,1:,1:) !< X COMPONENT. - REAL(R4P), INTENT(IN) :: Y(1:,1:,1:) !< Y COMPONENT. - REAL(R4P), INTENT(IN) :: Z(1:,1:,1:) !< Z COMPONENT. - CHARACTER(LEN=:), ALLOCATABLE :: CODE !< ENCODED BASE64 DATAARRAY. - INTEGER(I4P) :: N1 !< COUNTER. - INTEGER(I4P) :: N2 !< COUNTER. - INTEGER(I4P) :: N3 !< COUNTER. - INTEGER(I4P) :: L !< LENGTH - INTEGER(I4P) :: SP !< STRING POINTER - INTEGER(I4P) :: SIZE_N1 !< DIMENSION 1 SIZE - INTEGER(I4P) :: SIZE_N2 !< DIMENSION 2 SIZE - INTEGER(I4P) :: SIZE_N3 !< DIMENSION 3 SIZE - - SIZE_N1 = SIZE(X, DIM=1) - SIZE_N2 = SIZE(X, DIM=2) - SIZE_N3 = SIZE(X, DIM=3) - - L = DR4P*6 + 5 - SP = 0 - CODE = REPEAT(' ',L*SIZE_N1*SIZE_N2*SIZE_N3) - DO N3=1, SIZE_N3 - DO N2=1, SIZE_N2 - DO N1=1, SIZE_N1 - CODE(SP+1:SP+L) = STR(N=U(N1, N2, N3))//' '//STR(N=V(N1, N2, N3))//' '//STR(N=W(N1, N2, N3))// & - STR(N=X(N1, N2, N3))//' '//STR(N=Y(N1, N2, N3))//' '//STR(N=Z(N1, N2, N3)) - SP = SP + L - ENDDO - ENDDO - ENDDO - ENDFUNCTION ENCODE_ASCII_DATAARRAY6_RANK3_R4P - - FUNCTION ENCODE_ASCII_DATAARRAY6_RANK3_I8P(U, V, W, X, Y, Z) RESULT(CODE) - !< ENCODE (BASE64) A DATAARRAY WITH 6 COMPONENTS OF RANK 3 (I8P). - INTEGER(I8P), INTENT(IN) :: U(1:,1:,1:) !< U COMPONENT. - INTEGER(I8P), INTENT(IN) :: V(1:,1:,1:) !< V COMPONENT. - INTEGER(I8P), INTENT(IN) :: W(1:,1:,1:) !< W COMPONENT. - INTEGER(I8P), INTENT(IN) :: X(1:,1:,1:) !< X COMPONENT. - INTEGER(I8P), INTENT(IN) :: Y(1:,1:,1:) !< Y COMPONENT. - INTEGER(I8P), INTENT(IN) :: Z(1:,1:,1:) !< Z COMPONENT. - CHARACTER(LEN=:), ALLOCATABLE :: CODE !< ENCODED BASE64 DATAARRAY. - INTEGER(I4P) :: N1 !< COUNTER. - INTEGER(I4P) :: N2 !< COUNTER. - INTEGER(I4P) :: N3 !< COUNTER. - INTEGER(I4P) :: L !< LENGTH - INTEGER(I4P) :: SP !< STRING POINTER - INTEGER(I4P) :: SIZE_N1 !< DIMENSION 1 SIZE - INTEGER(I4P) :: SIZE_N2 !< DIMENSION 2 SIZE - INTEGER(I4P) :: SIZE_N3 !< DIMENSION 3 SIZE - - SIZE_N1 = SIZE(X, DIM=1) - SIZE_N2 = SIZE(X, DIM=2) - SIZE_N3 = SIZE(X, DIM=3) - - L = DI8P*6 + 5 - SP = 0 - CODE = REPEAT(' ',L*SIZE_N1*SIZE_N2*SIZE_N3) - DO N3=1, SIZE_N3 - DO N2=1, SIZE_N2 - DO N1=1, SIZE_N1 - CODE(SP+1:SP+L) = STR(N=U(N1, N2, N3))//' '//STR(N=V(N1, N2, N3))//' '//STR(N=W(N1, N2, N3))// & - STR(N=X(N1, N2, N3))//' '//STR(N=Y(N1, N2, N3))//' '//STR(N=Z(N1, N2, N3)) - SP = SP + L - ENDDO - ENDDO - ENDDO - ENDFUNCTION ENCODE_ASCII_DATAARRAY6_RANK3_I8P - - FUNCTION ENCODE_ASCII_DATAARRAY6_RANK3_I4P(U, V, W, X, Y, Z) RESULT(CODE) - !< ENCODE (BASE64) A DATAARRAY WITH 6 COMPONENTS OF RANK 3 (I4P). - INTEGER(I4P), INTENT(IN) :: U(1:,1:,1:) !< U COMPONENT. - INTEGER(I4P), INTENT(IN) :: V(1:,1:,1:) !< V COMPONENT. - INTEGER(I4P), INTENT(IN) :: W(1:,1:,1:) !< W COMPONENT. - INTEGER(I4P), INTENT(IN) :: X(1:,1:,1:) !< X COMPONENT. - INTEGER(I4P), INTENT(IN) :: Y(1:,1:,1:) !< Y COMPONENT. - INTEGER(I4P), INTENT(IN) :: Z(1:,1:,1:) !< Z COMPONENT. - CHARACTER(LEN=:), ALLOCATABLE :: CODE !< ENCODED BASE64 DATAARRAY. - INTEGER(I4P) :: N1 !< COUNTER. - INTEGER(I4P) :: N2 !< COUNTER. - INTEGER(I4P) :: N3 !< COUNTER. - INTEGER(I4P) :: L !< LENGTH - INTEGER(I4P) :: SP !< STRING POINTER - INTEGER(I4P) :: SIZE_N1 !< DIMENSION 1 SIZE - INTEGER(I4P) :: SIZE_N2 !< DIMENSION 2 SIZE - INTEGER(I4P) :: SIZE_N3 !< DIMENSION 3 SIZE - - SIZE_N1 = SIZE(X, DIM=1) - SIZE_N2 = SIZE(X, DIM=2) - SIZE_N3 = SIZE(X, DIM=3) - - L = DI4P*6 + 5 - SP = 0 - CODE = REPEAT(' ',L*SIZE_N1*SIZE_N2*SIZE_N3) - DO N3=1, SIZE_N3 - DO N2=1, SIZE_N2 - DO N1=1, SIZE_N1 - CODE(SP+1:SP+L) = STR(N=U(N1, N2, N3))//' '//STR(N=V(N1, N2, N3))//' '//STR(N=W(N1, N2, N3))// & - STR(N=X(N1, N2, N3))//' '//STR(N=Y(N1, N2, N3))//' '//STR(N=Z(N1, N2, N3)) - SP = SP + L - ENDDO - ENDDO - ENDDO - ENDFUNCTION ENCODE_ASCII_DATAARRAY6_RANK3_I4P - - FUNCTION ENCODE_ASCII_DATAARRAY6_RANK3_I2P(U, V, W, X, Y, Z) RESULT(CODE) - !< ENCODE (BASE64) A DATAARRAY WITH 6 COMPONENTS OF RANK 3 (I2P). - INTEGER(I2P), INTENT(IN) :: U(1:,1:,1:) !< U COMPONENT. - INTEGER(I2P), INTENT(IN) :: V(1:,1:,1:) !< V COMPONENT. - INTEGER(I2P), INTENT(IN) :: W(1:,1:,1:) !< W COMPONENT. - INTEGER(I2P), INTENT(IN) :: X(1:,1:,1:) !< X COMPONENT. - INTEGER(I2P), INTENT(IN) :: Y(1:,1:,1:) !< Y COMPONENT. - INTEGER(I2P), INTENT(IN) :: Z(1:,1:,1:) !< Z COMPONENT. - CHARACTER(LEN=:), ALLOCATABLE :: CODE !< ENCODED BASE64 DATAARRAY. - INTEGER(I4P) :: N1 !< COUNTER. - INTEGER(I4P) :: N2 !< COUNTER. - INTEGER(I4P) :: N3 !< COUNTER. - INTEGER(I4P) :: L !< LENGTH - INTEGER(I4P) :: SP !< STRING POINTER - INTEGER(I4P) :: SIZE_N1 !< DIMENSION 1 SIZE - INTEGER(I4P) :: SIZE_N2 !< DIMENSION 2 SIZE - INTEGER(I4P) :: SIZE_N3 !< DIMENSION 3 SIZE - - SIZE_N1 = SIZE(X, DIM=1) - SIZE_N2 = SIZE(X, DIM=2) - SIZE_N3 = SIZE(X, DIM=3) - - L = DI2P*6 + 5 - SP = 0 - CODE = REPEAT(' ',L*SIZE_N1*SIZE_N2*SIZE_N3) - DO N3=1, SIZE_N3 - DO N2=1, SIZE_N2 - DO N1=1, SIZE_N1 - CODE(SP+1:SP+L) = STR(N=U(N1, N2, N3))//' '//STR(N=V(N1, N2, N3))//' '//STR(N=W(N1, N2, N3))// & - STR(N=X(N1, N2, N3))//' '//STR(N=Y(N1, N2, N3))//' '//STR(N=Z(N1, N2, N3)) - SP = SP + L - ENDDO - ENDDO - ENDDO - ENDFUNCTION ENCODE_ASCII_DATAARRAY6_RANK3_I2P - - FUNCTION ENCODE_ASCII_DATAARRAY6_RANK3_I1P(U, V, W, X, Y, Z) RESULT(CODE) - !< ENCODE (BASE64) A DATAARRAY WITH 6 COMPONENTS OF RANK 3 (I1P). - INTEGER(I1P), INTENT(IN) :: U(1:,1:,1:) !< U COMPONENT. - INTEGER(I1P), INTENT(IN) :: V(1:,1:,1:) !< V COMPONENT. - INTEGER(I1P), INTENT(IN) :: W(1:,1:,1:) !< W COMPONENT. - INTEGER(I1P), INTENT(IN) :: X(1:,1:,1:) !< X COMPONENT. - INTEGER(I1P), INTENT(IN) :: Y(1:,1:,1:) !< Y COMPONENT. - INTEGER(I1P), INTENT(IN) :: Z(1:,1:,1:) !< Z COMPONENT. - CHARACTER(LEN=:), ALLOCATABLE :: CODE !< ENCODED BASE64 DATAARRAY. - INTEGER(I4P) :: N1 !< COUNTER. - INTEGER(I4P) :: N2 !< COUNTER. - INTEGER(I4P) :: N3 !< COUNTER. - INTEGER(I4P) :: L !< LENGTH - INTEGER(I4P) :: SP !< STRING POINTER - INTEGER(I4P) :: SIZE_N1 !< DIMENSION 1 SIZE - INTEGER(I4P) :: SIZE_N2 !< DIMENSION 2 SIZE - INTEGER(I4P) :: SIZE_N3 !< DIMENSION 3 SIZE - - SIZE_N1 = SIZE(X, DIM=1) - SIZE_N2 = SIZE(X, DIM=2) - SIZE_N3 = SIZE(X, DIM=3) - - L = DI1P*6 + 5 - SP = 0 - CODE = REPEAT(' ',L*SIZE_N1*SIZE_N2*SIZE_N3) - DO N3=1, SIZE_N3 - DO N2=1, SIZE_N2 - DO N1=1, SIZE_N1 - CODE(SP+1:SP+L) = STR(N=U(N1, N2, N3))//' '//STR(N=V(N1, N2, N3))//' '//STR(N=W(N1, N2, N3))// & - STR(N=X(N1, N2, N3))//' '//STR(N=Y(N1, N2, N3))//' '//STR(N=Z(N1, N2, N3)) - SP = SP + L - ENDDO - ENDDO - ENDDO - ENDFUNCTION ENCODE_ASCII_DATAARRAY6_RANK3_I1P - !< BINARY ENCODER FUNCTION ENCODE_BINARY_DATAARRAY1_RANK1_R8P(X) RESULT(CODE) !< ENCODE (BASE64) A DATAARRAY WITH 1 COMPONENTS OF RANK 1 (R8P). @@ -13030,222 +10644,6 @@ FUNCTION ENCODE_BINARY_DATAARRAY1_RANK1_I1P(X) RESULT(CODE) CALL B64_ENCODE(N=XP, CODE=CODE) ENDFUNCTION ENCODE_BINARY_DATAARRAY1_RANK1_I1P - FUNCTION ENCODE_BINARY_DATAARRAY1_RANK2_R8P(X) RESULT(CODE) - !< ENCODE (BASE64) A DATAARRAY WITH 1 COMPONENTS OF RANK 2 (R8P). - REAL(R8P), INTENT(IN) :: X(1:,1:) !< DATA VARIABLE - CHARACTER(LEN=:), ALLOCATABLE :: CODE !< ENCODED BASE64 DATAARRAY. - INTEGER(I1P), ALLOCATABLE :: XP(:) !< PACKED DATA. - INTEGER(I4P) :: NN !< NUMBER OF ELEMENTS. - - NN = SIZE(X, DIM=1)*SIZE(X, DIM=2) - CALL PACK_DATA(A1=[INT(NN*BYR8P, I4P)], A2=RESHAPE(X, [NN]), PACKED=XP) - CALL B64_ENCODE(N=XP, CODE=CODE) - ENDFUNCTION ENCODE_BINARY_DATAARRAY1_RANK2_R8P - - FUNCTION ENCODE_BINARY_DATAARRAY1_RANK2_R4P(X) RESULT(CODE) - !< ENCODE (BASE64) A DATAARRAY WITH 1 COMPONENTS OF RANK 2 (R4P). - REAL(R4P), INTENT(IN) :: X(1:,1:) !< DATA VARIABLE - CHARACTER(LEN=:), ALLOCATABLE :: CODE !< ENCODED BASE64 DATAARRAY. - INTEGER(I1P), ALLOCATABLE :: XP(:) !< PACKED DATA. - INTEGER(I4P) :: NN !< NUMBER OF ELEMENTS. - - NN = SIZE(X, DIM=1)*SIZE(X, DIM=2) - CALL PACK_DATA(A1=[INT(NN*BYR4P, I4P)], A2=RESHAPE(X, [NN]), PACKED=XP) - CALL B64_ENCODE(N=XP, CODE=CODE) - ENDFUNCTION ENCODE_BINARY_DATAARRAY1_RANK2_R4P - - FUNCTION ENCODE_BINARY_DATAARRAY1_RANK2_I8P(X) RESULT(CODE) - !< ENCODE (BASE64) A DATAARRAY WITH 1 COMPONENTS OF RANK 2 (I8P). - INTEGER(I8P), INTENT(IN) :: X(1:,1:) !< DATA VARIABLE - CHARACTER(LEN=:), ALLOCATABLE :: CODE !< ENCODED BASE64 DATAARRAY. - INTEGER(I1P), ALLOCATABLE :: XP(:) !< PACKED DATA. - INTEGER(I4P) :: NN !< NUMBER OF ELEMENTS. - - NN = SIZE(X, DIM=1)*SIZE(X, DIM=2) - CALL PACK_DATA(A1=[INT(NN*BYI8P, I4P)], A2=RESHAPE(X, [NN]), PACKED=XP) - CALL B64_ENCODE(N=XP, CODE=CODE) - ENDFUNCTION ENCODE_BINARY_DATAARRAY1_RANK2_I8P - - FUNCTION ENCODE_BINARY_DATAARRAY1_RANK2_I4P(X) RESULT(CODE) - !< ENCODE (BASE64) A DATAARRAY WITH 1 COMPONENTS OF RANK 2 (I4P). - INTEGER(I4P), INTENT(IN) :: X(1:,1:) !< DATA VARIABLE - CHARACTER(LEN=:), ALLOCATABLE :: CODE !< ENCODED BASE64 DATAARRAY. - INTEGER(I1P), ALLOCATABLE :: XP(:) !< PACKED DATA. - INTEGER(I4P) :: NN !< NUMBER OF ELEMENTS. - - NN = SIZE(X, DIM=1)*SIZE(X, DIM=2) - XP = TRANSFER([INT(NN*BYI4P, I4P), RESHAPE(X, [NN])], XP) - CALL B64_ENCODE(N=XP, CODE=CODE) - ENDFUNCTION ENCODE_BINARY_DATAARRAY1_RANK2_I4P - - FUNCTION ENCODE_BINARY_DATAARRAY1_RANK2_I2P(X) RESULT(CODE) - !< ENCODE (BASE64) A DATAARRAY WITH 1 COMPONENTS OF RANK 2 (I2P). - INTEGER(I2P), INTENT(IN) :: X(1:,1:) !< DATA VARIABLE - CHARACTER(LEN=:), ALLOCATABLE :: CODE !< ENCODED BASE64 DATAARRAY. - INTEGER(I1P), ALLOCATABLE :: XP(:) !< PACKED DATA. - INTEGER(I4P) :: NN !< NUMBER OF ELEMENTS. - - NN = SIZE(X, DIM=1)*SIZE(X, DIM=2) - CALL PACK_DATA(A1=[INT(NN*BYI2P, I4P)], A2=RESHAPE(X, [NN]), PACKED=XP) - CALL B64_ENCODE(N=XP, CODE=CODE) - ENDFUNCTION ENCODE_BINARY_DATAARRAY1_RANK2_I2P - - FUNCTION ENCODE_BINARY_DATAARRAY1_RANK2_I1P(X) RESULT(CODE) - !< ENCODE (BASE64) A DATAARRAY WITH 1 COMPONENTS OF RANK 2 (I1P). - INTEGER(I1P), INTENT(IN) :: X(1:,1:) !< DATA VARIABLE - CHARACTER(LEN=:), ALLOCATABLE :: CODE !< ENCODED BASE64 DATAARRAY. - INTEGER(I1P), ALLOCATABLE :: XP(:) !< PACKED DATA. - INTEGER(I4P) :: NN !< NUMBER OF ELEMENTS. - - NN = SIZE(X, DIM=1)*SIZE(X, DIM=2) - CALL PACK_DATA(A1=[INT(NN*BYI1P, I4P)], A2=RESHAPE(X, [NN]), PACKED=XP) - CALL B64_ENCODE(N=XP, CODE=CODE) - ENDFUNCTION ENCODE_BINARY_DATAARRAY1_RANK2_I1P - - FUNCTION ENCODE_BINARY_DATAARRAY1_RANK3_R8P(X) RESULT(CODE) - !< ENCODE (BASE64) A DATAARRAY WITH 1 COMPONENTS OF RANK 3 (R8P). - REAL(R8P), INTENT(IN) :: X(1:,1:,1:) !< DATA VARIABLE - CHARACTER(LEN=:), ALLOCATABLE :: CODE !< ENCODED BASE64 DATAARRAY. - INTEGER(I1P), ALLOCATABLE :: XP(:) !< PACKED DATA. - INTEGER(I4P) :: NN !< NUMBER OF ELEMENTS. - - NN = SIZE(X, DIM=1)*SIZE(X, DIM=2)*SIZE(X, DIM=3) - CALL PACK_DATA(A1=[INT(NN*BYR8P, I4P)], A2=RESHAPE(X, [NN]), PACKED=XP) - CALL B64_ENCODE(N=XP, CODE=CODE) - ENDFUNCTION ENCODE_BINARY_DATAARRAY1_RANK3_R8P - - FUNCTION ENCODE_BINARY_DATAARRAY1_RANK3_R4P(X) RESULT(CODE) - !< ENCODE (BASE64) A DATAARRAY WITH 1 COMPONENTS OF RANK 3 (R4P). - REAL(R4P), INTENT(IN) :: X(1:,1:,1:) !< DATA VARIABLE - CHARACTER(LEN=:), ALLOCATABLE :: CODE !< ENCODED BASE64 DATAARRAY. - INTEGER(I1P), ALLOCATABLE :: XP(:) !< PACKED DATA. - INTEGER(I4P) :: NN !< NUMBER OF ELEMENTS. - - NN = SIZE(X, DIM=1)*SIZE(X, DIM=2)*SIZE(X, DIM=3) - CALL PACK_DATA(A1=[INT(NN*BYR4P, I4P)], A2=RESHAPE(X, [NN]), PACKED=XP) - CALL B64_ENCODE(N=XP, CODE=CODE) - ENDFUNCTION ENCODE_BINARY_DATAARRAY1_RANK3_R4P - - FUNCTION ENCODE_BINARY_DATAARRAY1_RANK3_I8P(X) RESULT(CODE) - !< ENCODE (BASE64) A DATAARRAY WITH 1 COMPONENTS OF RANK 3 (I8P). - INTEGER(I8P), INTENT(IN) :: X(1:,1:,1:) !< DATA VARIABLE - CHARACTER(LEN=:), ALLOCATABLE :: CODE !< ENCODED BASE64 DATAARRAY. - INTEGER(I1P), ALLOCATABLE :: XP(:) !< PACKED DATA. - INTEGER(I4P) :: NN !< NUMBER OF ELEMENTS. - - NN = SIZE(X, DIM=1)*SIZE(X, DIM=2)*SIZE(X, DIM=3) - CALL PACK_DATA(A1=[INT(NN*BYI8P, I4P)], A2=RESHAPE(X, [NN]), PACKED=XP) - CALL B64_ENCODE(N=XP, CODE=CODE) - ENDFUNCTION ENCODE_BINARY_DATAARRAY1_RANK3_I8P - - FUNCTION ENCODE_BINARY_DATAARRAY1_RANK3_I4P(X) RESULT(CODE) - !< ENCODE (BASE64) A DATAARRAY WITH 1 COMPONENTS OF RANK 3 (I4P). - INTEGER(I4P), INTENT(IN) :: X(1:,1:,1:) !< DATA VARIABLE - CHARACTER(LEN=:), ALLOCATABLE :: CODE !< ENCODED BASE64 DATAARRAY. - INTEGER(I1P), ALLOCATABLE :: XP(:) !< PACKED DATA. - INTEGER(I4P) :: NN !< NUMBER OF ELEMENTS. - - NN = SIZE(X, DIM=1)*SIZE(X, DIM=2)*SIZE(X, DIM=3) - XP = TRANSFER([INT(NN*BYI4P, I4P), RESHAPE(X, [NN])], XP) - CALL B64_ENCODE(N=XP, CODE=CODE) - ENDFUNCTION ENCODE_BINARY_DATAARRAY1_RANK3_I4P - - FUNCTION ENCODE_BINARY_DATAARRAY1_RANK3_I2P(X) RESULT(CODE) - !< ENCODE (BASE64) A DATAARRAY WITH 1 COMPONENTS OF RANK 3 (I2P). - INTEGER(I2P), INTENT(IN) :: X(1:,1:,1:) !< DATA VARIABLE - CHARACTER(LEN=:), ALLOCATABLE :: CODE !< ENCODED BASE64 DATAARRAY. - INTEGER(I1P), ALLOCATABLE :: XP(:) !< PACKED DATA. - INTEGER(I4P) :: NN !< NUMBER OF ELEMENTS. - - NN = SIZE(X, DIM=1)*SIZE(X, DIM=2)*SIZE(X, DIM=3) - CALL PACK_DATA(A1=[INT(NN*BYI2P, I4P)], A2=RESHAPE(X, [NN]), PACKED=XP) - CALL B64_ENCODE(N=XP, CODE=CODE) - ENDFUNCTION ENCODE_BINARY_DATAARRAY1_RANK3_I2P - - FUNCTION ENCODE_BINARY_DATAARRAY1_RANK3_I1P(X) RESULT(CODE) - !< ENCODE (BASE64) A DATAARRAY WITH 1 COMPONENTS OF RANK 3 (I1P). - INTEGER(I1P), INTENT(IN) :: X(1:,1:,1:) !< DATA VARIABLE - CHARACTER(LEN=:), ALLOCATABLE :: CODE !< ENCODED BASE64 DATAARRAY. - INTEGER(I1P), ALLOCATABLE :: XP(:) !< PACKED DATA. - INTEGER(I4P) :: NN !< NUMBER OF ELEMENTS. - - NN = SIZE(X, DIM=1)*SIZE(X, DIM=2)*SIZE(X, DIM=3) - CALL PACK_DATA(A1=[INT(NN*BYI1P, I4P)], A2=RESHAPE(X, [NN]), PACKED=XP) - CALL B64_ENCODE(N=XP, CODE=CODE) - ENDFUNCTION ENCODE_BINARY_DATAARRAY1_RANK3_I1P - - FUNCTION ENCODE_BINARY_DATAARRAY1_RANK4_R8P(X) RESULT(CODE) - !< ENCODE (BASE64) A DATAARRAY WITH 1 COMPONENTS OF RANK 4 (R8P). - REAL(R8P), INTENT(IN) :: X(1:,1:,1:,1:) !< DATA VARIABLE. - CHARACTER(LEN=:), ALLOCATABLE :: CODE !< ENCODED BASE64 DATAARRAY. - INTEGER(I1P), ALLOCATABLE :: XP(:) !< PACKED DATA. - INTEGER(I4P) :: NN !< NUMBER OF ELEMENTS. - - NN = SIZE(X, DIM=1)*SIZE(X, DIM=2)*SIZE(X, DIM=3)*SIZE(X, DIM=4) - CALL PACK_DATA(A1=[INT(NN*BYR8P, I4P)], A2=RESHAPE(X, [NN]), PACKED=XP) - CALL B64_ENCODE(N=XP, CODE=CODE) - ENDFUNCTION ENCODE_BINARY_DATAARRAY1_RANK4_R8P - - FUNCTION ENCODE_BINARY_DATAARRAY1_RANK4_R4P(X) RESULT(CODE) - !< ENCODE (BASE64) A DATAARRAY WITH 1 COMPONENTS OF RANK 4 (R4P). - REAL(R4P), INTENT(IN) :: X(1:,1:,1:,1:) !< DATA VARIABLE. - CHARACTER(LEN=:), ALLOCATABLE :: CODE !< ENCODED BASE64 DATAARRAY. - INTEGER(I1P), ALLOCATABLE :: XP(:) !< PACKED DATA. - INTEGER(I4P) :: NN !< NUMBER OF ELEMENTS. - - NN = SIZE(X, DIM=1)*SIZE(X, DIM=2)*SIZE(X, DIM=3)*SIZE(X, DIM=4) - CALL PACK_DATA(A1=[INT(NN*BYR4P, I4P)], A2=RESHAPE(X, [NN]), PACKED=XP) - CALL B64_ENCODE(N=XP, CODE=CODE) - ENDFUNCTION ENCODE_BINARY_DATAARRAY1_RANK4_R4P - - FUNCTION ENCODE_BINARY_DATAARRAY1_RANK4_I8P(X) RESULT(CODE) - !< ENCODE (BASE64) A DATAARRAY WITH 1 COMPONENTS OF RANK 4 (I8P). - INTEGER(I8P), INTENT(IN) :: X(1:,1:,1:,1:) !< DATA VARIABLE. - CHARACTER(LEN=:), ALLOCATABLE :: CODE !< ENCODED BASE64 DATAARRAY. - INTEGER(I1P), ALLOCATABLE :: XP(:) !< PACKED DATA. - INTEGER(I4P) :: NN !< NUMBER OF ELEMENTS. - - NN = SIZE(X, DIM=1)*SIZE(X, DIM=2)*SIZE(X, DIM=3)*SIZE(X, DIM=4) - CALL PACK_DATA(A1=[INT(NN*BYI8P, I4P)], A2=RESHAPE(X, [NN]), PACKED=XP) - CALL B64_ENCODE(N=XP, CODE=CODE) - ENDFUNCTION ENCODE_BINARY_DATAARRAY1_RANK4_I8P - - FUNCTION ENCODE_BINARY_DATAARRAY1_RANK4_I4P(X) RESULT(CODE) - !< ENCODE (BASE64) A DATAARRAY WITH 1 COMPONENTS OF RANK 4 (I4P). - INTEGER(I4P), INTENT(IN) :: X(1:,1:,1:,1:) !< DATA VARIABLE. - CHARACTER(LEN=:), ALLOCATABLE :: CODE !< ENCODED BASE64 DATAARRAY. - INTEGER(I1P), ALLOCATABLE :: XP(:) !< PACKED DATA. - INTEGER(I4P) :: NN !< NUMBER OF ELEMENTS. - - NN = SIZE(X, DIM=1)*SIZE(X, DIM=2)*SIZE(X, DIM=3)*SIZE(X, DIM=4) - XP = TRANSFER([INT(NN*BYI4P, I4P), RESHAPE(X, [NN])], XP) - CALL B64_ENCODE(N=XP, CODE=CODE) - ENDFUNCTION ENCODE_BINARY_DATAARRAY1_RANK4_I4P - - FUNCTION ENCODE_BINARY_DATAARRAY1_RANK4_I2P(X) RESULT(CODE) - !< ENCODE (BASE64) A DATAARRAY WITH 1 COMPONENTS OF RANK 4 (I2P). - INTEGER(I2P), INTENT(IN) :: X(1:,1:,1:,1:) !< DATA VARIABLE. - CHARACTER(LEN=:), ALLOCATABLE :: CODE !< ENCODED BASE64 DATAARRAY. - INTEGER(I1P), ALLOCATABLE :: XP(:) !< PACKED DATA. - INTEGER(I4P) :: NN !< NUMBER OF ELEMENTS. - - NN = SIZE(X, DIM=1)*SIZE(X, DIM=2)*SIZE(X, DIM=3)*SIZE(X, DIM=4) - CALL PACK_DATA(A1=[INT(NN*BYI2P, I4P)], A2=RESHAPE(X, [NN]), PACKED=XP) - CALL B64_ENCODE(N=XP, CODE=CODE) - ENDFUNCTION ENCODE_BINARY_DATAARRAY1_RANK4_I2P - - FUNCTION ENCODE_BINARY_DATAARRAY1_RANK4_I1P(X) RESULT(CODE) - !< ENCODE (BASE64) A DATAARRAY WITH 1 COMPONENTS OF RANK 4 (I1P). - INTEGER(I1P), INTENT(IN) :: X(1:,1:,1:,1:) !< DATA VARIABLE. - CHARACTER(LEN=:), ALLOCATABLE :: CODE !< ENCODED BASE64 DATAARRAY. - INTEGER(I1P), ALLOCATABLE :: XP(:) !< PACKED DATA. - INTEGER(I4P) :: NN !< NUMBER OF ELEMENTS. - - NN = SIZE(X, DIM=1)*SIZE(X, DIM=2)*SIZE(X, DIM=3)*SIZE(X, DIM=4) - CALL PACK_DATA(A1=[INT(NN*BYI1P, I4P)], A2=RESHAPE(X, [NN]), PACKED=XP) - CALL B64_ENCODE(N=XP, CODE=CODE) - ENDFUNCTION ENCODE_BINARY_DATAARRAY1_RANK4_I1P - FUNCTION ENCODE_BINARY_DATAARRAY3_RANK1_R8P(X, Y, Z) RESULT(CODE) !< ENCODE (BASE64) A DATAARRAY WITH 3 COMPONENTS OF RANK 1 (R8P). REAL(R8P), INTENT(IN) :: X(1:) !< X COMPONENT. @@ -13335,463 +10733,22 @@ FUNCTION ENCODE_BINARY_DATAARRAY3_RANK1_I1P(X, Y, Z) RESULT(CODE) CALL PACK_DATA(A1=[INT(3*NN*BYI1P, I4P)], A2=[(X(N), Y(N), Z(N), N=1, NN)], PACKED=XYZ) CALL B64_ENCODE(N=XYZ, CODE=CODE) ENDFUNCTION ENCODE_BINARY_DATAARRAY3_RANK1_I1P - - FUNCTION ENCODE_BINARY_DATAARRAY3_RANK3_R8P(X, Y, Z) RESULT(CODE) - !< ENCODE (BASE64) A DATAARRAY WITH 3 COMPONENTS OF RANK 3 (R8P). - REAL(R8P), INTENT(IN) :: X(1:,1:,1:) !< X COMPONENT. - REAL(R8P), INTENT(IN) :: Y(1:,1:,1:) !< Y COMPONENT. - REAL(R8P), INTENT(IN) :: Z(1:,1:,1:) !< Z COMPONENT. - CHARACTER(LEN=:), ALLOCATABLE :: CODE !< ENCODED BASE64 DATAARRAY. - INTEGER(I1P), ALLOCATABLE :: XYZ(:) !< PACKED DATA. - INTEGER(I4P) :: NN1 !< NUMBER OF ELEMENTS ALONG DIM 1. - INTEGER(I4P) :: NN2 !< NUMBER OF ELEMENTS ALONG DIM 2. - INTEGER(I4P) :: NN3 !< NUMBER OF ELEMENTS ALONG DIM 3. - INTEGER(I4P) :: NN !< NUMBER OF ELEMENTS. - INTEGER(I4P) :: N1 !< COUNTER. - INTEGER(I4P) :: N2 !< COUNTER. - INTEGER(I4P) :: N3 !< COUNTER. - - NN1 = SIZE(X, DIM=1) - NN2 = SIZE(X, DIM=2) - NN3 = SIZE(X, DIM=3) - NN = NN1*NN2*NN3 - CALL PACK_DATA(A1=[INT(3*NN*BYR8P, I4P)], A2=[(((X(N1, N2, N3), Y(N1, N2, N3), Z(N1, N2, N3), N1=1, NN1), & - N2=1, NN2), & - N3=1, NN3)], & - PACKED=XYZ) - CALL B64_ENCODE(N=XYZ,CODE=CODE) - ENDFUNCTION ENCODE_BINARY_DATAARRAY3_RANK3_R8P - - FUNCTION ENCODE_BINARY_DATAARRAY3_RANK3_R4P(X, Y, Z) RESULT(CODE) - !< ENCODE (BASE64) A DATAARRAY WITH 3 COMPONENTS OF RANK 3 (R4P). - REAL(R4P), INTENT(IN) :: X(1:,1:,1:) !< X COMPONENT. - REAL(R4P), INTENT(IN) :: Y(1:,1:,1:) !< Y COMPONENT. - REAL(R4P), INTENT(IN) :: Z(1:,1:,1:) !< Z COMPONENT. - CHARACTER(LEN=:), ALLOCATABLE :: CODE !< ENCODED BASE64 DATAARRAY. - INTEGER(I1P), ALLOCATABLE :: XYZ(:) !< PACKED DATA. - INTEGER(I4P) :: NN1 !< NUMBER OF ELEMENTS ALONG DIM 1. - INTEGER(I4P) :: NN2 !< NUMBER OF ELEMENTS ALONG DIM 2. - INTEGER(I4P) :: NN3 !< NUMBER OF ELEMENTS ALONG DIM 3. - INTEGER(I4P) :: NN !< NUMBER OF ELEMENTS. - INTEGER(I4P) :: N1 !< COUNTER. - INTEGER(I4P) :: N2 !< COUNTER. - INTEGER(I4P) :: N3 !< COUNTER. - - NN1 = SIZE(X, DIM=1) - NN2 = SIZE(X, DIM=2) - NN3 = SIZE(X, DIM=3) - NN = NN1*NN2*NN3 - CALL PACK_DATA(A1=[INT(3*NN*BYR4P, I4P)], A2=[(((X(N1, N2, N3), Y(N1, N2, N3), Z(N1, N2, N3), N1=1, NN1), & - N2=1, NN2), & - N3=1, NN3)], & - PACKED=XYZ) - CALL B64_ENCODE(N=XYZ,CODE=CODE) - ENDFUNCTION ENCODE_BINARY_DATAARRAY3_RANK3_R4P - - FUNCTION ENCODE_BINARY_DATAARRAY3_RANK3_I8P(X, Y, Z) RESULT(CODE) - !< ENCODE (BASE64) A DATAARRAY WITH 3 COMPONENTS OF RANK 3 (I8P). - INTEGER(I8P), INTENT(IN) :: X(1:,1:,1:) !< X COMPONENT. - INTEGER(I8P), INTENT(IN) :: Y(1:,1:,1:) !< Y COMPONENT. - INTEGER(I8P), INTENT(IN) :: Z(1:,1:,1:) !< Z COMPONENT. - CHARACTER(LEN=:), ALLOCATABLE :: CODE !< ENCODED BASE64 DATAARRAY. - INTEGER(I1P), ALLOCATABLE :: XYZ(:) !< PACKED DATA. - INTEGER(I4P) :: NN1 !< NUMBER OF ELEMENTS ALONG DIM 1. - INTEGER(I4P) :: NN2 !< NUMBER OF ELEMENTS ALONG DIM 2. - INTEGER(I4P) :: NN3 !< NUMBER OF ELEMENTS ALONG DIM 3. - INTEGER(I4P) :: NN !< NUMBER OF ELEMENTS. - INTEGER(I4P) :: N1 !< COUNTER. - INTEGER(I4P) :: N2 !< COUNTER. - INTEGER(I4P) :: N3 !< COUNTER. - - NN1 = SIZE(X, DIM=1) - NN2 = SIZE(X, DIM=2) - NN3 = SIZE(X, DIM=3) - NN = NN1*NN2*NN3 - CALL PACK_DATA(A1=[INT(3*NN*BYI8P, I4P)], A2=[(((X(N1, N2, N3), Y(N1, N2, N3), Z(N1, N2, N3), N1=1, NN1), & - N2=1, NN2), & - N3=1, NN3)], & - PACKED=XYZ) - CALL B64_ENCODE(N=XYZ,CODE=CODE) - ENDFUNCTION ENCODE_BINARY_DATAARRAY3_RANK3_I8P - - FUNCTION ENCODE_BINARY_DATAARRAY3_RANK3_I4P(X, Y, Z) RESULT(CODE) - !< ENCODE (BASE64) A DATAARRAY WITH 3 COMPONENTS OF RANK 3 (I4P). - INTEGER(I4P), INTENT(IN) :: X(1:,1:,1:) !< X COMPONENT. - INTEGER(I4P), INTENT(IN) :: Y(1:,1:,1:) !< Y COMPONENT. - INTEGER(I4P), INTENT(IN) :: Z(1:,1:,1:) !< Z COMPONENT. - CHARACTER(LEN=:), ALLOCATABLE :: CODE !< ENCODED BASE64 DATAARRAY. - INTEGER(I1P), ALLOCATABLE :: XYZ(:) !< PACKED DATA. - INTEGER(I4P) :: NN1 !< NUMBER OF ELEMENTS ALONG DIM 1. - INTEGER(I4P) :: NN2 !< NUMBER OF ELEMENTS ALONG DIM 2. - INTEGER(I4P) :: NN3 !< NUMBER OF ELEMENTS ALONG DIM 3. - INTEGER(I4P) :: NN !< NUMBER OF ELEMENTS. - INTEGER(I4P) :: N1 !< COUNTER. - INTEGER(I4P) :: N2 !< COUNTER. - INTEGER(I4P) :: N3 !< COUNTER. - - NN1 = SIZE(X, DIM=1) - NN2 = SIZE(X, DIM=2) - NN3 = SIZE(X, DIM=3) - NN = NN1*NN2*NN3 - XYZ = TRANSFER([INT(3*NN*BYI4P, I4P), [(((X(N1, N2, N3), Y(N1, N2, N3), Z(N1, N2, N3), N1=1, NN1), & - N2=1, NN2), & - N3=1, NN3)]], XYZ) - CALL B64_ENCODE(N=XYZ,CODE=CODE) - ENDFUNCTION ENCODE_BINARY_DATAARRAY3_RANK3_I4P - - FUNCTION ENCODE_BINARY_DATAARRAY3_RANK3_I2P(X, Y, Z) RESULT(CODE) - !< ENCODE (BASE64) A DATAARRAY WITH 3 COMPONENTS OF RANK 3 (I2P). - INTEGER(I2P), INTENT(IN) :: X(1:,1:,1:) !< X COMPONENT. - INTEGER(I2P), INTENT(IN) :: Y(1:,1:,1:) !< Y COMPONENT. - INTEGER(I2P), INTENT(IN) :: Z(1:,1:,1:) !< Z COMPONENT. - CHARACTER(LEN=:), ALLOCATABLE :: CODE !< ENCODED BASE64 DATAARRAY. - INTEGER(I1P), ALLOCATABLE :: XYZ(:) !< PACKED DATA. - INTEGER(I4P) :: NN1 !< NUMBER OF ELEMENTS ALONG DIM 1. - INTEGER(I4P) :: NN2 !< NUMBER OF ELEMENTS ALONG DIM 2. - INTEGER(I4P) :: NN3 !< NUMBER OF ELEMENTS ALONG DIM 3. - INTEGER(I4P) :: NN !< NUMBER OF ELEMENTS. - INTEGER(I4P) :: N1 !< COUNTER. - INTEGER(I4P) :: N2 !< COUNTER. - INTEGER(I4P) :: N3 !< COUNTER. - - NN1 = SIZE(X, DIM=1) - NN2 = SIZE(X, DIM=2) - NN3 = SIZE(X, DIM=3) - NN = NN1*NN2*NN3 - CALL PACK_DATA(A1=[INT(3*NN*BYI2P, I4P)], A2=[(((X(N1, N2, N3), Y(N1, N2, N3), Z(N1, N2, N3), N1=1, NN1), & - N2=1, NN2), & - N3=1, NN3)], & - PACKED=XYZ) - CALL B64_ENCODE(N=XYZ,CODE=CODE) - ENDFUNCTION ENCODE_BINARY_DATAARRAY3_RANK3_I2P - - FUNCTION ENCODE_BINARY_DATAARRAY3_RANK3_I1P(X, Y, Z) RESULT(CODE) - !< ENCODE (BASE64) A DATAARRAY WITH 3 COMPONENTS OF RANK 3 (I1P). - INTEGER(I1P), INTENT(IN) :: X(1:,1:,1:) !< X COMPONENT. - INTEGER(I1P), INTENT(IN) :: Y(1:,1:,1:) !< Y COMPONENT. - INTEGER(I1P), INTENT(IN) :: Z(1:,1:,1:) !< Z COMPONENT. - CHARACTER(LEN=:), ALLOCATABLE :: CODE !< ENCODED BASE64 DATAARRAY. - INTEGER(I1P), ALLOCATABLE :: XYZ(:) !< PACKED DATA. - INTEGER(I4P) :: NN1 !< NUMBER OF ELEMENTS ALONG DIM 1. - INTEGER(I4P) :: NN2 !< NUMBER OF ELEMENTS ALONG DIM 2. - INTEGER(I4P) :: NN3 !< NUMBER OF ELEMENTS ALONG DIM 3. - INTEGER(I4P) :: NN !< NUMBER OF ELEMENTS. - INTEGER(I4P) :: N1 !< COUNTER. - INTEGER(I4P) :: N2 !< COUNTER. - INTEGER(I4P) :: N3 !< COUNTER. - - NN1 = SIZE(X, DIM=1) - NN2 = SIZE(X, DIM=2) - NN3 = SIZE(X, DIM=3) - NN = NN1*NN2*NN3 - CALL PACK_DATA(A1=[INT(3*NN*BYI1P, I4P)], A2=[(((X(N1, N2, N3), Y(N1, N2, N3), Z(N1, N2, N3), N1=1, NN1), & - N2=1, NN2), & - N3=1, NN3)], & - PACKED=XYZ) - CALL B64_ENCODE(N=XYZ,CODE=CODE) - ENDFUNCTION ENCODE_BINARY_DATAARRAY3_RANK3_I1P - FUNCTION ENCODE_BINARY_DATAARRAY6_RANK1_R8P(U, V, W, X, Y, Z) RESULT(CODE) - !< ENCODE (BASE64) A DATAARRAY WITH 6 COMPONENTS OF RANK 1 (R8P). - REAL(R8P), INTENT(IN) :: U(1:) !< U COMPONENT. - REAL(R8P), INTENT(IN) :: V(1:) !< V COMPONENT. - REAL(R8P), INTENT(IN) :: W(1:) !< W COMPONENT. - REAL(R8P), INTENT(IN) :: X(1:) !< X COMPONENT. - REAL(R8P), INTENT(IN) :: Y(1:) !< Y COMPONENT. - REAL(R8P), INTENT(IN) :: Z(1:) !< Z COMPONENT. - CHARACTER(LEN=:), ALLOCATABLE :: CODE !< ENCODED BASE64 DATAARRAY. - INTEGER(I1P), ALLOCATABLE :: XYZ(:) !< PACKED DATA. - INTEGER(I4P) :: NN !< NUMBER OF ELEMENTS. - INTEGER(I4P) :: N !< COUNTER. - - NN = SIZE(X, DIM=1) - CALL PACK_DATA(A1=[INT(6*NN*BYR8P, I4P)], A2=[(U(N), V(N), W(N), X(N), Y(N), Z(N), N=1, NN)], PACKED=XYZ) - CALL B64_ENCODE(N=XYZ, CODE=CODE) - ENDFUNCTION ENCODE_BINARY_DATAARRAY6_RANK1_R8P +ENDMODULE VTK_FORTRAN_DATAARRAY_ENCODER - FUNCTION ENCODE_BINARY_DATAARRAY6_RANK1_R4P(U, V, W, X, Y, Z) RESULT(CODE) - !< ENCODE (BASE64) A DATAARRAY WITH 6 COMPONENTS OF RANK 1 (R4P). - REAL(R4P), INTENT(IN) :: U(1:) !< U COMPONENT. - REAL(R4P), INTENT(IN) :: V(1:) !< V COMPONENT. - REAL(R4P), INTENT(IN) :: W(1:) !< W COMPONENT. - REAL(R4P), INTENT(IN) :: X(1:) !< X COMPONENT. - REAL(R4P), INTENT(IN) :: Y(1:) !< Y COMPONENT. - REAL(R4P), INTENT(IN) :: Z(1:) !< Z COMPONENT. - CHARACTER(LEN=:), ALLOCATABLE :: CODE !< ENCODED BASE64 DATAARRAY. - INTEGER(I1P), ALLOCATABLE :: XYZ(:) !< PACKED DATA. - INTEGER(I4P) :: NN !< NUMBER OF ELEMENTS. - INTEGER(I4P) :: N !< COUNTER. - NN = SIZE(X, DIM=1) - CALL PACK_DATA(A1=[INT(6*NN*BYR4P, I4P)], A2=[(U(N), V(N), W(N), X(N), Y(N), Z(N), N=1, NN)], PACKED=XYZ) - CALL B64_ENCODE(N=XYZ, CODE=CODE) - ENDFUNCTION ENCODE_BINARY_DATAARRAY6_RANK1_R4P - FUNCTION ENCODE_BINARY_DATAARRAY6_RANK1_I8P(U, V, W, X, Y, Z) RESULT(CODE) - !< ENCODE (BASE64) A DATAARRAY WITH 6 COMPONENTS OF RANK 1 (I8P). - INTEGER(I8P), INTENT(IN) :: U(1:) !< U COMPONENT. - INTEGER(I8P), INTENT(IN) :: V(1:) !< V COMPONENT. - INTEGER(I8P), INTENT(IN) :: W(1:) !< W COMPONENT. - INTEGER(I8P), INTENT(IN) :: X(1:) !< X COMPONENT. - INTEGER(I8P), INTENT(IN) :: Y(1:) !< Y COMPONENT. - INTEGER(I8P), INTENT(IN) :: Z(1:) !< Z COMPONENT. - CHARACTER(LEN=:), ALLOCATABLE :: CODE !< ENCODED BASE64 DATAARRAY. - INTEGER(I1P), ALLOCATABLE :: XYZ(:) !< PACKED DATA. - INTEGER(I4P) :: NN !< NUMBER OF ELEMENTS. - INTEGER(I4P) :: N !< COUNTER. +!< VTK FILE XML WRITER, ASCII LOCAL. +MODULE VTKF_FILE_XML_WRITER_ASCII_LOCAL +!< VTK FILE XML WRITER, ASCII LOCAL. +USE PENF +USE STRINGIFOR +USE VTK_FORTRAN_DATAARRAY_ENCODER +USE VTKF_FILE_XML_WRITER_ABSTRACT - NN = SIZE(X, DIM=1) - CALL PACK_DATA(A1=[INT(6*NN*BYI8P, I4P)], A2=[(U(N), V(N), W(N), X(N), Y(N), Z(N), N=1, NN)], PACKED=XYZ) - CALL B64_ENCODE(N=XYZ, CODE=CODE) - ENDFUNCTION ENCODE_BINARY_DATAARRAY6_RANK1_I8P - - FUNCTION ENCODE_BINARY_DATAARRAY6_RANK1_I4P(U, V, W, X, Y, Z) RESULT(CODE) - !< ENCODE (BASE64) A DATAARRAY WITH 6 COMPONENTS OF RANK 1 (I4P). - INTEGER(I4P), INTENT(IN) :: U(1:) !< U COMPONENT. - INTEGER(I4P), INTENT(IN) :: V(1:) !< V COMPONENT. - INTEGER(I4P), INTENT(IN) :: W(1:) !< W COMPONENT. - INTEGER(I4P), INTENT(IN) :: X(1:) !< X COMPONENT. - INTEGER(I4P), INTENT(IN) :: Y(1:) !< Y COMPONENT. - INTEGER(I4P), INTENT(IN) :: Z(1:) !< Z COMPONENT. - CHARACTER(LEN=:), ALLOCATABLE :: CODE !< ENCODED BASE64 DATAARRAY. - INTEGER(I1P), ALLOCATABLE :: XYZ(:) !< PACKED DATA. - INTEGER(I4P) :: NN !< NUMBER OF ELEMENTS. - INTEGER(I4P) :: N !< COUNTER. - - NN = SIZE(X, DIM=1) - XYZ = TRANSFER([INT(6*NN*BYI4P, I4P), [(U(N), V(N), W(N), X(N), Y(N), Z(N), N=1, NN)]], XYZ) - CALL B64_ENCODE(N=XYZ, CODE=CODE) - ENDFUNCTION ENCODE_BINARY_DATAARRAY6_RANK1_I4P - - FUNCTION ENCODE_BINARY_DATAARRAY6_RANK1_I2P(U, V, W, X, Y, Z) RESULT(CODE) - !< ENCODE (BASE64) A DATAARRAY WITH 6 COMPONENTS OF RANK 1 (I2P). - INTEGER(I2P), INTENT(IN) :: U(1:) !< U COMPONENT. - INTEGER(I2P), INTENT(IN) :: V(1:) !< V COMPONENT. - INTEGER(I2P), INTENT(IN) :: W(1:) !< W COMPONENT. - INTEGER(I2P), INTENT(IN) :: X(1:) !< X COMPONENT. - INTEGER(I2P), INTENT(IN) :: Y(1:) !< Y COMPONENT. - INTEGER(I2P), INTENT(IN) :: Z(1:) !< Z COMPONENT. - CHARACTER(LEN=:), ALLOCATABLE :: CODE !< ENCODED BASE64 DATAARRAY. - INTEGER(I1P), ALLOCATABLE :: XYZ(:) !< PACKED DATA. - INTEGER(I4P) :: NN !< NUMBER OF ELEMENTS. - INTEGER(I4P) :: N !< COUNTER. - - NN = SIZE(X, DIM=1) - CALL PACK_DATA(A1=[INT(6*NN*BYI2P, I4P)], A2=[(U(N), V(N), W(N), X(N), Y(N), Z(N), N=1, NN)], PACKED=XYZ) - CALL B64_ENCODE(N=XYZ, CODE=CODE) - ENDFUNCTION ENCODE_BINARY_DATAARRAY6_RANK1_I2P - - FUNCTION ENCODE_BINARY_DATAARRAY6_RANK1_I1P(U, V, W, X, Y, Z) RESULT(CODE) - !< ENCODE (BASE64) A DATAARRAY WITH 6 COMPONENTS OF RANK 1 (I1P). - INTEGER(I1P), INTENT(IN) :: U(1:) !< U COMPONENT. - INTEGER(I1P), INTENT(IN) :: V(1:) !< V COMPONENT. - INTEGER(I1P), INTENT(IN) :: W(1:) !< W COMPONENT. - INTEGER(I1P), INTENT(IN) :: X(1:) !< X COMPONENT. - INTEGER(I1P), INTENT(IN) :: Y(1:) !< Y COMPONENT. - INTEGER(I1P), INTENT(IN) :: Z(1:) !< Z COMPONENT. - CHARACTER(LEN=:), ALLOCATABLE :: CODE !< ENCODED BASE64 DATAARRAY. - INTEGER(I1P), ALLOCATABLE :: XYZ(:) !< PACKED DATA. - INTEGER(I4P) :: NN !< NUMBER OF ELEMENTS. - INTEGER(I4P) :: N !< COUNTER. - - NN = SIZE(X, DIM=1) - CALL PACK_DATA(A1=[INT(6*NN*BYI1P, I4P)], A2=[(U(N), V(N), W(N), X(N), Y(N), Z(N), N=1, NN)], PACKED=XYZ) - CALL B64_ENCODE(N=XYZ, CODE=CODE) - ENDFUNCTION ENCODE_BINARY_DATAARRAY6_RANK1_I1P - - FUNCTION ENCODE_BINARY_DATAARRAY6_RANK3_R8P(U, V, W, X, Y, Z) RESULT(CODE) - !< ENCODE (BASE64) A DATAARRAY WITH 6 COMPONENTS OF RANK 3 (R8P). - REAL(R8P), INTENT(IN) :: U(1:,1:,1:) !< U COMPONENT. - REAL(R8P), INTENT(IN) :: V(1:,1:,1:) !< V COMPONENT. - REAL(R8P), INTENT(IN) :: W(1:,1:,1:) !< W COMPONENT. - REAL(R8P), INTENT(IN) :: X(1:,1:,1:) !< X COMPONENT. - REAL(R8P), INTENT(IN) :: Y(1:,1:,1:) !< Y COMPONENT. - REAL(R8P), INTENT(IN) :: Z(1:,1:,1:) !< Z COMPONENT. - CHARACTER(LEN=:), ALLOCATABLE :: CODE !< ENCODED BASE64 DATAARRAY. - INTEGER(I1P), ALLOCATABLE :: XYZ(:) !< PACKED DATA. - INTEGER(I4P) :: NN1 !< NUMBER OF ELEMENTS ALONG DIM 1. - INTEGER(I4P) :: NN2 !< NUMBER OF ELEMENTS ALONG DIM 2. - INTEGER(I4P) :: NN3 !< NUMBER OF ELEMENTS ALONG DIM 3. - INTEGER(I4P) :: NN !< NUMBER OF ELEMENTS. - INTEGER(I4P) :: N1 !< COUNTER. - INTEGER(I4P) :: N2 !< COUNTER. - INTEGER(I4P) :: N3 !< COUNTER. - - NN1 = SIZE(X, DIM=1) - NN2 = SIZE(X, DIM=2) - NN3 = SIZE(X, DIM=3) - NN = NN1*NN2*NN3 - CALL PACK_DATA(A1=[INT(6*NN*BYR8P, I4P)], A2=[(((U(N1, N2, N3), V(N1, N2, N3), W(N1, N2, N3), & - X(N1, N2, N3), Y(N1, N2, N3), Z(N1, N2, N3), N1=1, NN1), & - N2=1, NN2), & - N3=1, NN3)], & - PACKED=XYZ) - CALL B64_ENCODE(N=XYZ,CODE=CODE) - ENDFUNCTION ENCODE_BINARY_DATAARRAY6_RANK3_R8P - - FUNCTION ENCODE_BINARY_DATAARRAY6_RANK3_R4P(U, V, W, X, Y, Z) RESULT(CODE) - !< ENCODE (BASE64) A DATAARRAY WITH 6 COMPONENTS OF RANK 3 (R4P). - REAL(R4P), INTENT(IN) :: U(1:,1:,1:) !< U COMPONENT. - REAL(R4P), INTENT(IN) :: V(1:,1:,1:) !< V COMPONENT. - REAL(R4P), INTENT(IN) :: W(1:,1:,1:) !< W COMPONENT. - REAL(R4P), INTENT(IN) :: X(1:,1:,1:) !< X COMPONENT. - REAL(R4P), INTENT(IN) :: Y(1:,1:,1:) !< Y COMPONENT. - REAL(R4P), INTENT(IN) :: Z(1:,1:,1:) !< Z COMPONENT. - CHARACTER(LEN=:), ALLOCATABLE :: CODE !< ENCODED BASE64 DATAARRAY. - INTEGER(I1P), ALLOCATABLE :: XYZ(:) !< PACKED DATA. - INTEGER(I4P) :: NN1 !< NUMBER OF ELEMENTS ALONG DIM 1. - INTEGER(I4P) :: NN2 !< NUMBER OF ELEMENTS ALONG DIM 2. - INTEGER(I4P) :: NN3 !< NUMBER OF ELEMENTS ALONG DIM 3. - INTEGER(I4P) :: NN !< NUMBER OF ELEMENTS. - INTEGER(I4P) :: N1 !< COUNTER. - INTEGER(I4P) :: N2 !< COUNTER. - INTEGER(I4P) :: N3 !< COUNTER. - - NN1 = SIZE(X, DIM=1) - NN2 = SIZE(X, DIM=2) - NN3 = SIZE(X, DIM=3) - NN = NN1*NN2*NN3 - CALL PACK_DATA(A1=[INT(6*NN*BYR4P, I4P)], A2=[(((U(N1, N2, N3), V(N1, N2, N3), W(N1, N2, N3), & - X(N1, N2, N3), Y(N1, N2, N3), Z(N1, N2, N3), N1=1, NN1), & - N2=1, NN2), & - N3=1, NN3)], & - PACKED=XYZ) - CALL B64_ENCODE(N=XYZ,CODE=CODE) - ENDFUNCTION ENCODE_BINARY_DATAARRAY6_RANK3_R4P - - FUNCTION ENCODE_BINARY_DATAARRAY6_RANK3_I8P(U, V, W, X, Y, Z) RESULT(CODE) - !< ENCODE (BASE64) A DATAARRAY WITH 6 COMPONENTS OF RANK 3 (I8P). - INTEGER(I8P), INTENT(IN) :: U(1:,1:,1:) !< U COMPONENT. - INTEGER(I8P), INTENT(IN) :: V(1:,1:,1:) !< V COMPONENT. - INTEGER(I8P), INTENT(IN) :: W(1:,1:,1:) !< W COMPONENT. - INTEGER(I8P), INTENT(IN) :: X(1:,1:,1:) !< X COMPONENT. - INTEGER(I8P), INTENT(IN) :: Y(1:,1:,1:) !< Y COMPONENT. - INTEGER(I8P), INTENT(IN) :: Z(1:,1:,1:) !< Z COMPONENT. - CHARACTER(LEN=:), ALLOCATABLE :: CODE !< ENCODED BASE64 DATAARRAY. - INTEGER(I1P), ALLOCATABLE :: XYZ(:) !< PACKED DATA. - INTEGER(I4P) :: NN1 !< NUMBER OF ELEMENTS ALONG DIM 1. - INTEGER(I4P) :: NN2 !< NUMBER OF ELEMENTS ALONG DIM 2. - INTEGER(I4P) :: NN3 !< NUMBER OF ELEMENTS ALONG DIM 3. - INTEGER(I4P) :: NN !< NUMBER OF ELEMENTS. - INTEGER(I4P) :: N1 !< COUNTER. - INTEGER(I4P) :: N2 !< COUNTER. - INTEGER(I4P) :: N3 !< COUNTER. - - NN1 = SIZE(X, DIM=1) - NN2 = SIZE(X, DIM=2) - NN3 = SIZE(X, DIM=3) - NN = NN1*NN2*NN3 - CALL PACK_DATA(A1=[INT(6*NN*BYI8P, I4P)], A2=[(((U(N1, N2, N3), V(N1, N2, N3), W(N1, N2, N3), & - X(N1, N2, N3), Y(N1, N2, N3), Z(N1, N2, N3), N1=1, NN1), & - N2=1, NN2), & - N3=1, NN3)], & - PACKED=XYZ) - CALL B64_ENCODE(N=XYZ,CODE=CODE) - ENDFUNCTION ENCODE_BINARY_DATAARRAY6_RANK3_I8P - - FUNCTION ENCODE_BINARY_DATAARRAY6_RANK3_I4P(U, V, W, X, Y, Z) RESULT(CODE) - !< ENCODE (BASE64) A DATAARRAY WITH 6 COMPONENTS OF RANK 3 (I4P). - INTEGER(I4P), INTENT(IN) :: U(1:,1:,1:) !< U COMPONENT. - INTEGER(I4P), INTENT(IN) :: V(1:,1:,1:) !< V COMPONENT. - INTEGER(I4P), INTENT(IN) :: W(1:,1:,1:) !< W COMPONENT. - INTEGER(I4P), INTENT(IN) :: X(1:,1:,1:) !< X COMPONENT. - INTEGER(I4P), INTENT(IN) :: Y(1:,1:,1:) !< Y COMPONENT. - INTEGER(I4P), INTENT(IN) :: Z(1:,1:,1:) !< Z COMPONENT. - CHARACTER(LEN=:), ALLOCATABLE :: CODE !< ENCODED BASE64 DATAARRAY. - INTEGER(I1P), ALLOCATABLE :: XYZ(:) !< PACKED DATA. - INTEGER(I4P) :: NN1 !< NUMBER OF ELEMENTS ALONG DIM 1. - INTEGER(I4P) :: NN2 !< NUMBER OF ELEMENTS ALONG DIM 2. - INTEGER(I4P) :: NN3 !< NUMBER OF ELEMENTS ALONG DIM 3. - INTEGER(I4P) :: NN !< NUMBER OF ELEMENTS. - INTEGER(I4P) :: N1 !< COUNTER. - INTEGER(I4P) :: N2 !< COUNTER. - INTEGER(I4P) :: N3 !< COUNTER. - - NN1 = SIZE(X, DIM=1) - NN2 = SIZE(X, DIM=2) - NN3 = SIZE(X, DIM=3) - NN = NN1*NN2*NN3 - XYZ = TRANSFER([INT(6*NN*BYI4P, I4P), [(((U(N1, N2, N3), V(N1, N2, N3), W(N1, N2, N3), & - X(N1, N2, N3), Y(N1, N2, N3), Z(N1, N2, N3), N1=1, NN1), & - N2=1, NN2), & - N3=1, NN3)]], XYZ) - CALL B64_ENCODE(N=XYZ,CODE=CODE) - ENDFUNCTION ENCODE_BINARY_DATAARRAY6_RANK3_I4P - - FUNCTION ENCODE_BINARY_DATAARRAY6_RANK3_I2P(U, V, W, X, Y, Z) RESULT(CODE) - !< ENCODE (BASE64) A DATAARRAY WITH 6 COMPONENTS OF RANK 3 (I2P). - INTEGER(I2P), INTENT(IN) :: U(1:,1:,1:) !< U COMPONENT. - INTEGER(I2P), INTENT(IN) :: V(1:,1:,1:) !< V COMPONENT. - INTEGER(I2P), INTENT(IN) :: W(1:,1:,1:) !< W COMPONENT. - INTEGER(I2P), INTENT(IN) :: X(1:,1:,1:) !< X COMPONENT. - INTEGER(I2P), INTENT(IN) :: Y(1:,1:,1:) !< Y COMPONENT. - INTEGER(I2P), INTENT(IN) :: Z(1:,1:,1:) !< Z COMPONENT. - CHARACTER(LEN=:), ALLOCATABLE :: CODE !< ENCODED BASE64 DATAARRAY. - INTEGER(I1P), ALLOCATABLE :: XYZ(:) !< PACKED DATA. - INTEGER(I4P) :: NN1 !< NUMBER OF ELEMENTS ALONG DIM 1. - INTEGER(I4P) :: NN2 !< NUMBER OF ELEMENTS ALONG DIM 2. - INTEGER(I4P) :: NN3 !< NUMBER OF ELEMENTS ALONG DIM 3. - INTEGER(I4P) :: NN !< NUMBER OF ELEMENTS. - INTEGER(I4P) :: N1 !< COUNTER. - INTEGER(I4P) :: N2 !< COUNTER. - INTEGER(I4P) :: N3 !< COUNTER. - - NN1 = SIZE(X, DIM=1) - NN2 = SIZE(X, DIM=2) - NN3 = SIZE(X, DIM=3) - NN = NN1*NN2*NN3 - CALL PACK_DATA(A1=[INT(6*NN*BYI2P, I4P)], A2=[(((U(N1, N2, N3), V(N1, N2, N3), W(N1, N2, N3), & - X(N1, N2, N3), Y(N1, N2, N3), Z(N1, N2, N3), N1=1, NN1), & - N2=1, NN2), & - N3=1, NN3)], & - PACKED=XYZ) - CALL B64_ENCODE(N=XYZ,CODE=CODE) - ENDFUNCTION ENCODE_BINARY_DATAARRAY6_RANK3_I2P - - FUNCTION ENCODE_BINARY_DATAARRAY6_RANK3_I1P(U, V, W, X, Y, Z) RESULT(CODE) - !< ENCODE (BASE64) A DATAARRAY WITH 6 COMPONENTS OF RANK 3 (I1P). - INTEGER(I1P), INTENT(IN) :: U(1:,1:,1:) !< U COMPONENT. - INTEGER(I1P), INTENT(IN) :: V(1:,1:,1:) !< V COMPONENT. - INTEGER(I1P), INTENT(IN) :: W(1:,1:,1:) !< W COMPONENT. - INTEGER(I1P), INTENT(IN) :: X(1:,1:,1:) !< X COMPONENT. - INTEGER(I1P), INTENT(IN) :: Y(1:,1:,1:) !< Y COMPONENT. - INTEGER(I1P), INTENT(IN) :: Z(1:,1:,1:) !< Z COMPONENT. - CHARACTER(LEN=:), ALLOCATABLE :: CODE !< ENCODED BASE64 DATAARRAY. - INTEGER(I1P), ALLOCATABLE :: XYZ(:) !< PACKED DATA. - INTEGER(I4P) :: NN1 !< NUMBER OF ELEMENTS ALONG DIM 1. - INTEGER(I4P) :: NN2 !< NUMBER OF ELEMENTS ALONG DIM 2. - INTEGER(I4P) :: NN3 !< NUMBER OF ELEMENTS ALONG DIM 3. - INTEGER(I4P) :: NN !< NUMBER OF ELEMENTS. - INTEGER(I4P) :: N1 !< COUNTER. - INTEGER(I4P) :: N2 !< COUNTER. - INTEGER(I4P) :: N3 !< COUNTER. - - NN1 = SIZE(X, DIM=1) - NN2 = SIZE(X, DIM=2) - NN3 = SIZE(X, DIM=3) - NN = NN1*NN2*NN3 - CALL PACK_DATA(A1=[INT(6*NN*BYI1P, I4P)], A2=[(((U(N1, N2, N3), V(N1, N2, N3), W(N1, N2, N3), & - X(N1, N2, N3), Y(N1, N2, N3), Z(N1, N2, N3), N1=1, NN1), & - N2=1, NN2), & - N3=1, NN3)], & - PACKED=XYZ) - CALL B64_ENCODE(N=XYZ,CODE=CODE) - ENDFUNCTION ENCODE_BINARY_DATAARRAY6_RANK3_I1P -ENDMODULE VTK_FORTRAN_DATAARRAY_ENCODER - - - -!< VTK FILE XML WRITER, ASCII LOCAL. -MODULE VTKF_FILE_XML_WRITER_ASCII_LOCAL -!< VTK FILE XML WRITER, ASCII LOCAL. -USE PENF -USE STRINGIFOR -USE VTK_FORTRAN_DATAARRAY_ENCODER -USE VTKF_FILE_XML_WRITER_ABSTRACT - -IMPLICIT NONE -PRIVATE -PUBLIC :: XML_WRITER_ASCII_LOCAL +IMPLICIT NONE +PRIVATE +PUBLIC :: XML_WRITER_ASCII_LOCAL TYPE, EXTENDS(XML_WRITER_ABSTRACT) :: XML_WRITER_ASCII_LOCAL !< VTK FILE XML WRITER, ASCII LOCAL. @@ -13805,48 +10762,12 @@ MODULE VTKF_FILE_XML_WRITER_ASCII_LOCAL PROCEDURE, PASS(SELF) :: W_DATA1_RANK1_I4P !< WRITE DATAARRAY 1, RANK 1, I4P. PROCEDURE, PASS(SELF) :: W_DATA1_RANK1_I2P !< WRITE DATAARRAY 1, RANK 1, I2P. PROCEDURE, PASS(SELF) :: W_DATA1_RANK1_I1P !< WRITE DATAARRAY 1, RANK 1, I1P. - PROCEDURE, PASS(SELF) :: W_DATA1_RANK2_R8P !< WRITE DATAARRAY 1, RANK 2, R8P. - PROCEDURE, PASS(SELF) :: W_DATA1_RANK2_R4P !< WRITE DATAARRAY 1, RANK 2, R4P. - PROCEDURE, PASS(SELF) :: W_DATA1_RANK2_I8P !< WRITE DATAARRAY 1, RANK 2, I8P. - PROCEDURE, PASS(SELF) :: W_DATA1_RANK2_I4P !< WRITE DATAARRAY 1, RANK 2, I4P. - PROCEDURE, PASS(SELF) :: W_DATA1_RANK2_I2P !< WRITE DATAARRAY 1, RANK 2, I2P. - PROCEDURE, PASS(SELF) :: W_DATA1_RANK2_I1P !< WRITE DATAARRAY 1, RANK 2, I1P. - PROCEDURE, PASS(SELF) :: W_DATA1_RANK3_R8P !< WRITE DATAARRAY 1, RANK 3, R8P. - PROCEDURE, PASS(SELF) :: W_DATA1_RANK3_R4P !< WRITE DATAARRAY 1, RANK 3, R4P. - PROCEDURE, PASS(SELF) :: W_DATA1_RANK3_I8P !< WRITE DATAARRAY 1, RANK 3, I8P. - PROCEDURE, PASS(SELF) :: W_DATA1_RANK3_I4P !< WRITE DATAARRAY 1, RANK 3, I4P. - PROCEDURE, PASS(SELF) :: W_DATA1_RANK3_I2P !< WRITE DATAARRAY 1, RANK 3, I2P. - PROCEDURE, PASS(SELF) :: W_DATA1_RANK3_I1P !< WRITE DATAARRAY 1, RANK 3, I1P. - PROCEDURE, PASS(SELF) :: W_DATA1_RANK4_R8P !< WRITE DATAARRAY 1, RANK 4, R8P. - PROCEDURE, PASS(SELF) :: W_DATA1_RANK4_R4P !< WRITE DATAARRAY 1, RANK 4, R4P. - PROCEDURE, PASS(SELF) :: W_DATA1_RANK4_I8P !< WRITE DATAARRAY 1, RANK 4, I8P. - PROCEDURE, PASS(SELF) :: W_DATA1_RANK4_I4P !< WRITE DATAARRAY 1, RANK 4, I4P. - PROCEDURE, PASS(SELF) :: W_DATA1_RANK4_I2P !< WRITE DATAARRAY 1, RANK 4, I2P. - PROCEDURE, PASS(SELF) :: W_DATA1_RANK4_I1P !< WRITE DATAARRAY 1, RANK 4, I1P. PROCEDURE, PASS(SELF) :: W_DATA3_RANK1_R8P !< WRITE DATAARRAY 3, RANK 1, R8P. PROCEDURE, PASS(SELF) :: W_DATA3_RANK1_R4P !< WRITE DATAARRAY 3, RANK 1, R4P. PROCEDURE, PASS(SELF) :: W_DATA3_RANK1_I8P !< WRITE DATAARRAY 3, RANK 1, I8P. PROCEDURE, PASS(SELF) :: W_DATA3_RANK1_I4P !< WRITE DATAARRAY 3, RANK 1, I4P. PROCEDURE, PASS(SELF) :: W_DATA3_RANK1_I2P !< WRITE DATAARRAY 3, RANK 1, I2P. PROCEDURE, PASS(SELF) :: W_DATA3_RANK1_I1P !< WRITE DATAARRAY 3, RANK 1, I1P. - PROCEDURE, PASS(SELF) :: W_DATA3_RANK3_R8P !< WRITE DATAARRAY 3, RANK 3, R8P. - PROCEDURE, PASS(SELF) :: W_DATA3_RANK3_R4P !< WRITE DATAARRAY 3, RANK 3, R4P. - PROCEDURE, PASS(SELF) :: W_DATA3_RANK3_I8P !< WRITE DATAARRAY 3, RANK 3, I8P. - PROCEDURE, PASS(SELF) :: W_DATA3_RANK3_I4P !< WRITE DATAARRAY 3, RANK 3, I4P. - PROCEDURE, PASS(SELF) :: W_DATA3_RANK3_I2P !< WRITE DATAARRAY 3, RANK 3, I2P. - PROCEDURE, PASS(SELF) :: W_DATA3_RANK3_I1P !< WRITE DATAARRAY 3, RANK 3, I1P. - PROCEDURE, PASS(SELF) :: W_DATA6_RANK1_R8P !< WRITE DATAARRAY 6, RANK 1, R8P. - PROCEDURE, PASS(SELF) :: W_DATA6_RANK1_R4P !< WRITE DATAARRAY 6, RANK 1, R4P. - PROCEDURE, PASS(SELF) :: W_DATA6_RANK1_I8P !< WRITE DATAARRAY 6, RANK 1, I8P. - PROCEDURE, PASS(SELF) :: W_DATA6_RANK1_I4P !< WRITE DATAARRAY 6, RANK 1, I4P. - PROCEDURE, PASS(SELF) :: W_DATA6_RANK1_I2P !< WRITE DATAARRAY 6, RANK 1, I2P. - PROCEDURE, PASS(SELF) :: W_DATA6_RANK1_I1P !< WRITE DATAARRAY 6, RANK 1, I1P. - PROCEDURE, PASS(SELF) :: W_DATA6_RANK3_R8P !< WRITE DATAARRAY 6, RANK 3, R8P. - PROCEDURE, PASS(SELF) :: W_DATA6_RANK3_R4P !< WRITE DATAARRAY 6, RANK 3, R4P. - PROCEDURE, PASS(SELF) :: W_DATA6_RANK3_I8P !< WRITE DATAARRAY 6, RANK 3, I8P. - PROCEDURE, PASS(SELF) :: W_DATA6_RANK3_I4P !< WRITE DATAARRAY 6, RANK 3, I4P. - PROCEDURE, PASS(SELF) :: W_DATA6_RANK3_I2P !< WRITE DATAARRAY 6, RANK 3, I2P. - PROCEDURE, PASS(SELF) :: W_DATA6_RANK3_I1P !< WRITE DATAARRAY 6, RANK 3, I1P. PROCEDURE, PASS(SELF) :: W_DATA_APPENDED !< WRITE APPENDED. ENDTYPE XML_WRITER_ASCII_LOCAL CONTAINS @@ -14002,420 +10923,6 @@ FUNCTION W_DATA1_RANK1_I1P(SELF, DATA_NAME, X, IS_TUPLES) RESULT(ERROR) ERROR = SELF%ERROR ENDFUNCTION W_DATA1_RANK1_I1P - FUNCTION W_DATA1_RANK2_R8P(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR) - !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (R8P). - CLASS(XML_WRITER_ASCII_LOCAL), INTENT(INOUT) :: SELF !< WRITER. - CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. - REAL(R8P), INTENT(IN) :: X(1:,1:) !< DATA VARIABLE. - LOGICAL, INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT. - LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". - INTEGER(I4P) :: ERROR !< ERROR STATUS. - CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. - INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. - CHARACTER(LEN=:), ALLOCATABLE :: CODE !< DATA VARIABLE ENCODED, ASCII OR BASE64 CODEC. - - DATA_TYPE = 'Float64' - N_COMPONENTS = SIZE(X, DIM=1) - IF (PRESENT(ONE_COMPONENT)) THEN - IF (ONE_COMPONENT) N_COMPONENTS = 1 - ENDIF - CODE = ENCODE_ASCII_DATAARRAY(X=X) - CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, & - IS_TUPLES=IS_TUPLES) - ERROR = SELF%ERROR - ENDFUNCTION W_DATA1_RANK2_R8P - - FUNCTION W_DATA1_RANK2_R4P(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR) - !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (R4P). - CLASS(XML_WRITER_ASCII_LOCAL), INTENT(INOUT) :: SELF !< WRITER. - CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. - REAL(R4P), INTENT(IN) :: X(1:,1:) !< DATA VARIABLE. - LOGICAL, INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT. - LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". - INTEGER(I4P) :: ERROR !< ERROR STATUS. - CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. - INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. - CHARACTER(LEN=:), ALLOCATABLE :: CODE !< DATA VARIABLE ENCODED, ASCII OR BASE64 CODEC. - - DATA_TYPE = 'Float32' - N_COMPONENTS = SIZE(X, DIM=1) - IF (PRESENT(ONE_COMPONENT)) THEN - IF (ONE_COMPONENT) N_COMPONENTS = 1 - ENDIF - CODE = ENCODE_ASCII_DATAARRAY(X=X) - CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, & - IS_TUPLES=IS_TUPLES) - ERROR = SELF%ERROR - ENDFUNCTION W_DATA1_RANK2_R4P - - FUNCTION W_DATA1_RANK2_I8P(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR) - !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (I8P). - CLASS(XML_WRITER_ASCII_LOCAL), INTENT(INOUT) :: SELF !< WRITER. - CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. - INTEGER(I8P), INTENT(IN) :: X(1:,1:) !< DATA VARIABLE. - LOGICAL, INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT. - LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". - INTEGER(I4P) :: ERROR !< ERROR STATUS. - CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. - INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. - CHARACTER(LEN=:), ALLOCATABLE :: CODE !< DATA VARIABLE ENCODED, ASCII OR BASE64 CODEC. - - DATA_TYPE = 'Int64' - N_COMPONENTS = SIZE(X, DIM=1) - IF (PRESENT(ONE_COMPONENT)) THEN - IF (ONE_COMPONENT) N_COMPONENTS = 1 - ENDIF - CODE = ENCODE_ASCII_DATAARRAY(X=X) - CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, & - IS_TUPLES=IS_TUPLES) - ERROR = SELF%ERROR - ENDFUNCTION W_DATA1_RANK2_I8P - - FUNCTION W_DATA1_RANK2_I4P(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR) - !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (I4P). - CLASS(XML_WRITER_ASCII_LOCAL), INTENT(INOUT) :: SELF !< WRITER. - CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. - INTEGER(I4P), INTENT(IN) :: X(1:,1:) !< DATA VARIABLE. - LOGICAL, INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT. - LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". - INTEGER(I4P) :: ERROR !< ERROR STATUS. - CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. - INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. - CHARACTER(LEN=:), ALLOCATABLE :: CODE !< DATA VARIABLE ENCODED, ASCII OR BASE64 CODEC. - - DATA_TYPE = 'Int32' - N_COMPONENTS = SIZE(X, DIM=1) - IF (PRESENT(ONE_COMPONENT)) THEN - IF (ONE_COMPONENT) N_COMPONENTS = 1 - ENDIF - CODE = ENCODE_ASCII_DATAARRAY(X=X) - CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, & - IS_TUPLES=IS_TUPLES) - ERROR = SELF%ERROR - ENDFUNCTION W_DATA1_RANK2_I4P - - FUNCTION W_DATA1_RANK2_I2P(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR) - !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (I2P). - CLASS(XML_WRITER_ASCII_LOCAL), INTENT(INOUT) :: SELF !< WRITER. - CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. - INTEGER(I2P), INTENT(IN) :: X(1:,1:) !< DATA VARIABLE. - LOGICAL, INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT. - LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". - INTEGER(I4P) :: ERROR !< ERROR STATUS. - CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. - INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. - CHARACTER(LEN=:), ALLOCATABLE :: CODE !< DATA VARIABLE ENCODED, ASCII OR BASE64 CODEC. - - DATA_TYPE = 'Int16' - N_COMPONENTS = SIZE(X, DIM=1) - IF (PRESENT(ONE_COMPONENT)) THEN - IF (ONE_COMPONENT) N_COMPONENTS = 1 - ENDIF - CODE = ENCODE_ASCII_DATAARRAY(X=X) - CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, & - IS_TUPLES=IS_TUPLES) - ERROR = SELF%ERROR - ENDFUNCTION W_DATA1_RANK2_I2P - - FUNCTION W_DATA1_RANK2_I1P(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR) - !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (I1P). - CLASS(XML_WRITER_ASCII_LOCAL), INTENT(INOUT) :: SELF !< WRITER. - CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. - INTEGER(I1P), INTENT(IN) :: X(1:,1:) !< DATA VARIABLE. - LOGICAL, INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT. - LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". - INTEGER(I4P) :: ERROR !< ERROR STATUS. - CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. - INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. - CHARACTER(LEN=:), ALLOCATABLE :: CODE !< DATA VARIABLE ENCODED, ASCII OR BASE64 CODEC. - - DATA_TYPE = 'Int8' - N_COMPONENTS = SIZE(X, DIM=1) - IF (PRESENT(ONE_COMPONENT)) THEN - IF (ONE_COMPONENT) N_COMPONENTS = 1 - ENDIF - CODE = ENCODE_ASCII_DATAARRAY(X=X) - CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, & - IS_TUPLES=IS_TUPLES) - ERROR = SELF%ERROR - ENDFUNCTION W_DATA1_RANK2_I1P - - FUNCTION W_DATA1_RANK3_R8P(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR) - !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (R8P). - CLASS(XML_WRITER_ASCII_LOCAL), INTENT(INOUT) :: SELF !< WRITER. - CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. - REAL(R8P), INTENT(IN) :: X(1:,1:,1:) !< DATA VARIABLE. - LOGICAL, INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT. - LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". - INTEGER(I4P) :: ERROR !< ERROR STATUS. - CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. - INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. - CHARACTER(LEN=:), ALLOCATABLE :: CODE !< DATA VARIABLE ENCODED, ASCII OR BASE64 CODEC. - - DATA_TYPE = 'Float64' - N_COMPONENTS = SIZE(X, DIM=1) - IF (PRESENT(ONE_COMPONENT)) THEN - IF (ONE_COMPONENT) N_COMPONENTS = 1 - ENDIF - CODE = ENCODE_ASCII_DATAARRAY(X=X) - CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, & - IS_TUPLES=IS_TUPLES) - ERROR = SELF%ERROR - ENDFUNCTION W_DATA1_RANK3_R8P - - FUNCTION W_DATA1_RANK3_R4P(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR) - !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (R4P). - CLASS(XML_WRITER_ASCII_LOCAL), INTENT(INOUT) :: SELF !< WRITER. - CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. - REAL(R4P), INTENT(IN) :: X(1:,1:,1:) !< DATA VARIABLE. - LOGICAL, INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT. - LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". - INTEGER(I4P) :: ERROR !< ERROR STATUS. - CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. - INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. - CHARACTER(LEN=:), ALLOCATABLE :: CODE !< DATA VARIABLE ENCODED, ASCII OR BASE64 CODEC. - - DATA_TYPE = 'Float32' - N_COMPONENTS = SIZE(X, DIM=1) - IF (PRESENT(ONE_COMPONENT)) THEN - IF (ONE_COMPONENT) N_COMPONENTS = 1 - ENDIF - CODE = ENCODE_ASCII_DATAARRAY(X=X) - CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, & - IS_TUPLES=IS_TUPLES) - ERROR = SELF%ERROR - ENDFUNCTION W_DATA1_RANK3_R4P - - FUNCTION W_DATA1_RANK3_I8P(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR) - !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (I8P). - CLASS(XML_WRITER_ASCII_LOCAL), INTENT(INOUT) :: SELF !< WRITER. - CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. - INTEGER(I8P), INTENT(IN) :: X(1:,1:,1:) !< DATA VARIABLE. - LOGICAL, INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT. - LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". - INTEGER(I4P) :: ERROR !< ERROR STATUS. - CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. - INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. - CHARACTER(LEN=:), ALLOCATABLE :: CODE !< DATA VARIABLE ENCODED, ASCII OR BASE64 CODEC. - - DATA_TYPE = 'Int64' - N_COMPONENTS = SIZE(X, DIM=1) - IF (PRESENT(ONE_COMPONENT)) THEN - IF (ONE_COMPONENT) N_COMPONENTS = 1 - ENDIF - CODE = ENCODE_ASCII_DATAARRAY(X=X) - CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, & - IS_TUPLES=IS_TUPLES) - ERROR = SELF%ERROR - ENDFUNCTION W_DATA1_RANK3_I8P - - FUNCTION W_DATA1_RANK3_I4P(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR) - !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (I4P). - CLASS(XML_WRITER_ASCII_LOCAL), INTENT(INOUT) :: SELF !< WRITER. - CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. - INTEGER(I4P), INTENT(IN) :: X(1:,1:,1:) !< DATA VARIABLE. - LOGICAL, INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT. - LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". - INTEGER(I4P) :: ERROR !< ERROR STATUS. - CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. - INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. - CHARACTER(LEN=:), ALLOCATABLE :: CODE !< DATA VARIABLE ENCODED, ASCII OR BASE64 CODEC. - - DATA_TYPE = 'Int32' - N_COMPONENTS = SIZE(X, DIM=1) - IF (PRESENT(ONE_COMPONENT)) THEN - IF (ONE_COMPONENT) N_COMPONENTS = 1 - ENDIF - CODE = ENCODE_ASCII_DATAARRAY(X=X) - CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, & - IS_TUPLES=IS_TUPLES) - ERROR = SELF%ERROR - ENDFUNCTION W_DATA1_RANK3_I4P - - FUNCTION W_DATA1_RANK3_I2P(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR) - !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (I2P). - CLASS(XML_WRITER_ASCII_LOCAL), INTENT(INOUT) :: SELF !< WRITER. - CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. - INTEGER(I2P), INTENT(IN) :: X(1:,1:,1:) !< DATA VARIABLE. - LOGICAL, INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT. - LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". - INTEGER(I4P) :: ERROR !< ERROR STATUS. - CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. - INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. - CHARACTER(LEN=:), ALLOCATABLE :: CODE !< DATA VARIABLE ENCODED, ASCII OR BASE64 CODEC. - - DATA_TYPE = 'Int16' - N_COMPONENTS = SIZE(X, DIM=1) - IF (PRESENT(ONE_COMPONENT)) THEN - IF (ONE_COMPONENT) N_COMPONENTS = 1 - ENDIF - CODE = ENCODE_ASCII_DATAARRAY(X=X) - CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, & - IS_TUPLES=IS_TUPLES) - ERROR = SELF%ERROR - ENDFUNCTION W_DATA1_RANK3_I2P - - FUNCTION W_DATA1_RANK3_I1P(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR) - !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (I1P). - CLASS(XML_WRITER_ASCII_LOCAL), INTENT(INOUT) :: SELF !< WRITER. - CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. - INTEGER(I1P), INTENT(IN) :: X(1:,1:,1:) !< DATA VARIABLE. - LOGICAL, INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT. - LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". - INTEGER(I4P) :: ERROR !< ERROR STATUS. - CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. - INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. - CHARACTER(LEN=:), ALLOCATABLE :: CODE !< DATA VARIABLE ENCODED, ASCII OR BASE64 CODEC. - - DATA_TYPE = 'Int8' - N_COMPONENTS = SIZE(X, DIM=1) - IF (PRESENT(ONE_COMPONENT)) THEN - IF (ONE_COMPONENT) N_COMPONENTS = 1 - ENDIF - CODE = ENCODE_ASCII_DATAARRAY(X=X) - CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, & - IS_TUPLES=IS_TUPLES) - ERROR = SELF%ERROR - ENDFUNCTION W_DATA1_RANK3_I1P - - FUNCTION W_DATA1_RANK4_R8P(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR) - !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (R8P). - CLASS(XML_WRITER_ASCII_LOCAL), INTENT(INOUT) :: SELF !< WRITER. - CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. - REAL(R8P), INTENT(IN) :: X(1:,1:,1:,1:) !< DATA VARIABLE. - LOGICAL, INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT. - LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". - INTEGER(I4P) :: ERROR !< ERROR STATUS. - CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. - INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. - CHARACTER(LEN=:), ALLOCATABLE :: CODE !< DATA VARIABLE ENCODED, ASCII OR BASE64 CODEC. - - DATA_TYPE = 'Float64' - N_COMPONENTS = SIZE(X, DIM=1) - IF (PRESENT(ONE_COMPONENT)) THEN - IF (ONE_COMPONENT) N_COMPONENTS = 1 - ENDIF - CODE = ENCODE_ASCII_DATAARRAY(X=X) - CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, & - IS_TUPLES=IS_TUPLES) - ERROR = SELF%ERROR - ENDFUNCTION W_DATA1_RANK4_R8P - - FUNCTION W_DATA1_RANK4_R4P(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR) - !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (R4P). - CLASS(XML_WRITER_ASCII_LOCAL), INTENT(INOUT) :: SELF !< WRITER. - CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. - REAL(R4P), INTENT(IN) :: X(1:,1:,1:,1:) !< DATA VARIABLE. - LOGICAL, INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT. - LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". - INTEGER(I4P) :: ERROR !< ERROR STATUS. - CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. - INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. - CHARACTER(LEN=:), ALLOCATABLE :: CODE !< DATA VARIABLE ENCODED, ASCII OR BASE64 CODEC. - - DATA_TYPE = 'Float32' - N_COMPONENTS = SIZE(X, DIM=1) - IF (PRESENT(ONE_COMPONENT)) THEN - IF (ONE_COMPONENT) N_COMPONENTS = 1 - ENDIF - CODE = ENCODE_ASCII_DATAARRAY(X=X) - CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, & - IS_TUPLES=IS_TUPLES) - ERROR = SELF%ERROR - ENDFUNCTION W_DATA1_RANK4_R4P - - FUNCTION W_DATA1_RANK4_I8P(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR) - !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (I8P). - CLASS(XML_WRITER_ASCII_LOCAL), INTENT(INOUT) :: SELF !< WRITER. - CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. - INTEGER(I8P), INTENT(IN) :: X(1:,1:,1:,1:) !< DATA VARIABLE. - LOGICAL, INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT. - LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". - INTEGER(I4P) :: ERROR !< ERROR STATUS. - CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. - INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. - CHARACTER(LEN=:), ALLOCATABLE :: CODE !< DATA VARIABLE ENCODED, ASCII OR BASE64 CODEC. - - DATA_TYPE = 'Int64' - N_COMPONENTS = SIZE(X, DIM=1) - IF (PRESENT(ONE_COMPONENT)) THEN - IF (ONE_COMPONENT) N_COMPONENTS = 1 - ENDIF - CODE = ENCODE_ASCII_DATAARRAY(X=X) - CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, & - IS_TUPLES=IS_TUPLES) - ERROR = SELF%ERROR - ENDFUNCTION W_DATA1_RANK4_I8P - - FUNCTION W_DATA1_RANK4_I4P(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR) - !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (I4P). - CLASS(XML_WRITER_ASCII_LOCAL), INTENT(INOUT) :: SELF !< WRITER. - CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. - INTEGER(I4P), INTENT(IN) :: X(1:,1:,1:,1:) !< DATA VARIABLE. - LOGICAL, INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT. - LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". - INTEGER(I4P) :: ERROR !< ERROR STATUS. - CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. - INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. - CHARACTER(LEN=:), ALLOCATABLE :: CODE !< DATA VARIABLE ENCODED, ASCII OR BASE64 CODEC. - - DATA_TYPE = 'Int32' - N_COMPONENTS = SIZE(X, DIM=1) - IF (PRESENT(ONE_COMPONENT)) THEN - IF (ONE_COMPONENT) N_COMPONENTS = 1 - ENDIF - CODE = ENCODE_ASCII_DATAARRAY(X=X) - CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, & - IS_TUPLES=IS_TUPLES) - ERROR = SELF%ERROR - ENDFUNCTION W_DATA1_RANK4_I4P - - FUNCTION W_DATA1_RANK4_I2P(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR) - !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (I2P). - CLASS(XML_WRITER_ASCII_LOCAL), INTENT(INOUT) :: SELF !< WRITER. - CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. - INTEGER(I2P), INTENT(IN) :: X(1:,1:,1:,1:) !< DATA VARIABLE. - LOGICAL, INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT. - LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". - INTEGER(I4P) :: ERROR !< ERROR STATUS. - CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. - INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. - CHARACTER(LEN=:), ALLOCATABLE :: CODE !< DATA VARIABLE ENCODED, ASCII OR BASE64 CODEC. - - DATA_TYPE = 'Int16' - N_COMPONENTS = SIZE(X, DIM=1) - IF (PRESENT(ONE_COMPONENT)) THEN - IF (ONE_COMPONENT) N_COMPONENTS = 1 - ENDIF - CODE = ENCODE_ASCII_DATAARRAY(X=X) - CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, & - IS_TUPLES=IS_TUPLES) - ERROR = SELF%ERROR - ENDFUNCTION W_DATA1_RANK4_I2P - - FUNCTION W_DATA1_RANK4_I1P(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR) - !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (I1P). - CLASS(XML_WRITER_ASCII_LOCAL), INTENT(INOUT) :: SELF !< WRITER. - CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. - INTEGER(I1P), INTENT(IN) :: X(1:,1:,1:,1:) !< DATA VARIABLE. - LOGICAL, INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT. - LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". - INTEGER(I4P) :: ERROR !< ERROR STATUS. - CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. - INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. - CHARACTER(LEN=:), ALLOCATABLE :: CODE !< DATA VARIABLE ENCODED, ASCII OR BASE64 CODEC. - - DATA_TYPE = 'Int8' - N_COMPONENTS = SIZE(X, DIM=1) - IF (PRESENT(ONE_COMPONENT)) THEN - IF (ONE_COMPONENT) N_COMPONENTS = 1 - ENDIF - CODE = ENCODE_ASCII_DATAARRAY(X=X) - CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, & - IS_TUPLES=IS_TUPLES) - ERROR = SELF%ERROR - ENDFUNCTION W_DATA1_RANK4_I1P - FUNCTION W_DATA3_RANK1_R8P(SELF, DATA_NAME, X, Y, Z, IS_TUPLES) RESULT(ERROR) !< WRITE `<DATAARRAY... NumberOfComponents="3"...>...</DATAARRAY>` TAG (R8P). CLASS(XML_WRITER_ASCII_LOCAL), INTENT(INOUT) :: SELF !< WRITER. @@ -14541,427 +11048,12 @@ FUNCTION W_DATA3_RANK1_I1P(SELF, DATA_NAME, X, Y, Z, IS_TUPLES) RESULT(ERROR) IS_TUPLES=IS_TUPLES) ERROR = SELF%ERROR ENDFUNCTION W_DATA3_RANK1_I1P - - FUNCTION W_DATA3_RANK3_R8P(SELF, DATA_NAME, X, Y, Z, IS_TUPLES) RESULT(ERROR) - !< WRITE `<DATAARRAY... NumberOfComponents="3"...>...</DATAARRAY>` TAG (R8P). - CLASS(XML_WRITER_ASCII_LOCAL), INTENT(INOUT) :: SELF !< WRITER. - CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. - REAL(R8P), INTENT(IN) :: X(1:,1:,1:) !< X COMPONENT OF DATA VARIABLE. - REAL(R8P), INTENT(IN) :: Y(1:,1:,1:) !< Y COMPONENT OF DATA VARIABLE. - REAL(R8P), INTENT(IN) :: Z(1:,1:,1:) !< Z COMPONENT OF DATA VARIABLE. - LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". - INTEGER(I4P) :: ERROR !< ERROR STATUS. - CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. - INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. - CHARACTER(LEN=:), ALLOCATABLE :: CODE !< DATA VARIABLE ENCODED, ASCII OR BASE64 CODEC. - - DATA_TYPE = 'Float64' - N_COMPONENTS = 3 - CODE = ENCODE_ASCII_DATAARRAY(X=X, Y=Y, Z=Z) - CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, & - IS_TUPLES=IS_TUPLES) - ERROR = SELF%ERROR - ENDFUNCTION W_DATA3_RANK3_R8P - - FUNCTION W_DATA3_RANK3_R4P(SELF, DATA_NAME, X, Y, Z, IS_TUPLES) RESULT(ERROR) - !< WRITE `<DATAARRAY... NumberOfComponents="3"...>...</DATAARRAY>` TAG (R4P). - CLASS(XML_WRITER_ASCII_LOCAL), INTENT(INOUT) :: SELF !< WRITER. - CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. - REAL(R4P), INTENT(IN) :: X(1:,1:,1:) !< X COMPONENT OF DATA VARIABLE. - REAL(R4P), INTENT(IN) :: Y(1:,1:,1:) !< Y COMPONENT OF DATA VARIABLE. - REAL(R4P), INTENT(IN) :: Z(1:,1:,1:) !< Z COMPONENT OF DATA VARIABLE. - LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". - INTEGER(I4P) :: ERROR !< ERROR STATUS. - CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. - INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. - CHARACTER(LEN=:), ALLOCATABLE :: CODE !< DATA VARIABLE ENCODED, ASCII OR BASE64 CODEC. - - DATA_TYPE = 'Float32' - N_COMPONENTS = 3 - CODE = ENCODE_ASCII_DATAARRAY(X=X, Y=Y, Z=Z) - CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, & - IS_TUPLES=IS_TUPLES) - ERROR = SELF%ERROR - ENDFUNCTION W_DATA3_RANK3_R4P - - FUNCTION W_DATA3_RANK3_I8P(SELF, DATA_NAME, X, Y, Z, IS_TUPLES) RESULT(ERROR) - !< WRITE `<DATAARRAY... NumberOfComponents="3"...>...</DATAARRAY>` TAG (I8P). - CLASS(XML_WRITER_ASCII_LOCAL), INTENT(INOUT) :: SELF !< WRITER. - CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. - INTEGER(I8P), INTENT(IN) :: X(1:,1:,1:) !< X COMPONENT OF DATA VARIABLE. - INTEGER(I8P), INTENT(IN) :: Y(1:,1:,1:) !< Y COMPONENT OF DATA VARIABLE. - INTEGER(I8P), INTENT(IN) :: Z(1:,1:,1:) !< Z COMPONENT OF DATA VARIABLE. - LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". - INTEGER(I4P) :: ERROR !< ERROR STATUS. - CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. - INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. - CHARACTER(LEN=:), ALLOCATABLE :: CODE !< DATA VARIABLE ENCODED, ASCII OR BASE64 CODEC. - - DATA_TYPE = 'Int64' - N_COMPONENTS = 3 - CODE = ENCODE_ASCII_DATAARRAY(X=X, Y=Y, Z=Z) - CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, & - IS_TUPLES=IS_TUPLES) - ERROR = SELF%ERROR - ENDFUNCTION W_DATA3_RANK3_I8P - - FUNCTION W_DATA3_RANK3_I4P(SELF, DATA_NAME, X, Y, Z, IS_TUPLES) RESULT(ERROR) - !< WRITE `<DATAARRAY... NumberOfComponents="3"...>...</DATAARRAY>` TAG (I4P). - CLASS(XML_WRITER_ASCII_LOCAL), INTENT(INOUT) :: SELF !< WRITER. - CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. - INTEGER(I4P), INTENT(IN) :: X(1:,1:,1:) !< X COMPONENT OF DATA VARIABLE. - INTEGER(I4P), INTENT(IN) :: Y(1:,1:,1:) !< Y COMPONENT OF DATA VARIABLE. - INTEGER(I4P), INTENT(IN) :: Z(1:,1:,1:) !< Z COMPONENT OF DATA VARIABLE. - LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". - INTEGER(I4P) :: ERROR !< ERROR STATUS. - CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. - INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. - CHARACTER(LEN=:), ALLOCATABLE :: CODE !< DATA VARIABLE ENCODED, ASCII OR BASE64 CODEC. - - DATA_TYPE = 'Int32' - N_COMPONENTS = 3 - CODE = ENCODE_ASCII_DATAARRAY(X=X, Y=Y, Z=Z) - CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, & - IS_TUPLES=IS_TUPLES) - ERROR = SELF%ERROR - ENDFUNCTION W_DATA3_RANK3_I4P - - FUNCTION W_DATA3_RANK3_I2P(SELF, DATA_NAME, X, Y, Z, IS_TUPLES) RESULT(ERROR) - !< WRITE `<DATAARRAY... NumberOfComponents="3"...>...</DATAARRAY>` TAG (I2P). - CLASS(XML_WRITER_ASCII_LOCAL), INTENT(INOUT) :: SELF !< WRITER. - CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. - INTEGER(I2P), INTENT(IN) :: X(1:,1:,1:) !< X COMPONENT OF DATA VARIABLE. - INTEGER(I2P), INTENT(IN) :: Y(1:,1:,1:) !< Y COMPONENT OF DATA VARIABLE. - INTEGER(I2P), INTENT(IN) :: Z(1:,1:,1:) !< Z COMPONENT OF DATA VARIABLE. - LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". - INTEGER(I4P) :: ERROR !< ERROR STATUS. - CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. - INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. - CHARACTER(LEN=:), ALLOCATABLE :: CODE !< DATA VARIABLE ENCODED, ASCII OR BASE64 CODEC. - - DATA_TYPE = 'Int16' - N_COMPONENTS = 3 - CODE = ENCODE_ASCII_DATAARRAY(X=X, Y=Y, Z=Z) - CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, & - IS_TUPLES=IS_TUPLES) - ERROR = SELF%ERROR - ENDFUNCTION W_DATA3_RANK3_I2P - - FUNCTION W_DATA3_RANK3_I1P(SELF, DATA_NAME, X, Y, Z, IS_TUPLES) RESULT(ERROR) - !< WRITE `<DATAARRAY... NumberOfComponents="3"...>...</DATAARRAY>` TAG (I1P). - CLASS(XML_WRITER_ASCII_LOCAL), INTENT(INOUT) :: SELF !< WRITER. - CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. - INTEGER(I1P), INTENT(IN) :: X(1:,1:,1:) !< X COMPONENT OF DATA VARIABLE. - INTEGER(I1P), INTENT(IN) :: Y(1:,1:,1:) !< Y COMPONENT OF DATA VARIABLE. - INTEGER(I1P), INTENT(IN) :: Z(1:,1:,1:) !< Z COMPONENT OF DATA VARIABLE. - LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". - INTEGER(I4P) :: ERROR !< ERROR STATUS. - CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. - INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. - CHARACTER(LEN=:), ALLOCATABLE :: CODE !< DATA VARIABLE ENCODED, ASCII OR BASE64 CODEC. - - DATA_TYPE = 'Int8' - N_COMPONENTS = 3 - CODE = ENCODE_ASCII_DATAARRAY(X=X, Y=Y, Z=Z) - CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, & - IS_TUPLES=IS_TUPLES) - ERROR = SELF%ERROR - ENDFUNCTION W_DATA3_RANK3_I1P - - FUNCTION W_DATA6_RANK1_R8P(SELF, DATA_NAME, U, V, W, X, Y, Z, IS_TUPLES) RESULT(ERROR) - !< WRITE `<DATAARRAY... NumberOfComponents="6"...>...</DATAARRAY>` TAG (R8P). - CLASS(XML_WRITER_ASCII_LOCAL), INTENT(INOUT) :: SELF !< WRITER. - CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. - REAL(R8P), INTENT(IN) :: U(1:) !< U COMPONENT OF DATA VARIABLE. - REAL(R8P), INTENT(IN) :: V(1:) !< V COMPONENT OF DATA VARIABLE. - REAL(R8P), INTENT(IN) :: W(1:) !< W COMPONENT OF DATA VARIABLE. - REAL(R8P), INTENT(IN) :: X(1:) !< X COMPONENT OF DATA VARIABLE. - REAL(R8P), INTENT(IN) :: Y(1:) !< Y COMPONENT OF DATA VARIABLE. - REAL(R8P), INTENT(IN) :: Z(1:) !< Z COMPONENT OF DATA VARIABLE. - LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". - INTEGER(I4P) :: ERROR !< ERROR STATUS. - CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. - INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. - CHARACTER(LEN=:), ALLOCATABLE :: CODE !< DATA VARIABLE ENCODED, ASCII OR BASE64 CODEC. - - DATA_TYPE = 'Float64' - N_COMPONENTS = 6 - CODE = ENCODE_ASCII_DATAARRAY(U=U, V=V, W=W, X=X, Y=Y, Z=Z) - CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, & - IS_TUPLES=IS_TUPLES) - ERROR = SELF%ERROR - ENDFUNCTION W_DATA6_RANK1_R8P - - FUNCTION W_DATA6_RANK1_R4P(SELF, DATA_NAME, U, V, W,X, Y, Z, IS_TUPLES) RESULT(ERROR) - !< WRITE `<DATAARRAY... NumberOfComponents="6"...>...</DATAARRAY>` TAG (R4P). - CLASS(XML_WRITER_ASCII_LOCAL), INTENT(INOUT) :: SELF !< WRITER. - CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. - REAL(R4P), INTENT(IN) :: U(1:) !< U COMPONENT OF DATA VARIABLE. - REAL(R4P), INTENT(IN) :: V(1:) !< V COMPONENT OF DATA VARIABLE. - REAL(R4P), INTENT(IN) :: W(1:) !< W COMPONENT OF DATA VARIABLE. - REAL(R4P), INTENT(IN) :: X(1:) !< X COMPONENT OF DATA VARIABLE. - REAL(R4P), INTENT(IN) :: Y(1:) !< Y COMPONENT OF DATA VARIABLE. - REAL(R4P), INTENT(IN) :: Z(1:) !< Z COMPONENT OF DATA VARIABLE. - LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". - INTEGER(I4P) :: ERROR !< ERROR STATUS. - CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. - INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. - CHARACTER(LEN=:), ALLOCATABLE :: CODE !< DATA VARIABLE ENCODED, ASCII OR BASE64 CODEC. - - DATA_TYPE = 'Float32' - N_COMPONENTS = 6 - CODE = ENCODE_ASCII_DATAARRAY(U=U, V=V, W=W, X=X, Y=Y, Z=Z) - CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, & - IS_TUPLES=IS_TUPLES) - ERROR = SELF%ERROR - ENDFUNCTION W_DATA6_RANK1_R4P - - FUNCTION W_DATA6_RANK1_I8P(SELF, DATA_NAME, U, V, W, X, Y, Z, IS_TUPLES) RESULT(ERROR) - !< WRITE `<DATAARRAY... NumberOfComponents="6"...>...</DATAARRAY>` TAG (I8P). - CLASS(XML_WRITER_ASCII_LOCAL), INTENT(INOUT) :: SELF !< WRITER. - CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. - INTEGER(I8P), INTENT(IN) :: U(1:) !< U COMPONENT OF DATA VARIABLE. - INTEGER(I8P), INTENT(IN) :: V(1:) !< V COMPONENT OF DATA VARIABLE. - INTEGER(I8P), INTENT(IN) :: W(1:) !< W COMPONENT OF DATA VARIABLE. - INTEGER(I8P), INTENT(IN) :: X(1:) !< X COMPONENT OF DATA VARIABLE. - INTEGER(I8P), INTENT(IN) :: Y(1:) !< Y COMPONENT OF DATA VARIABLE. - INTEGER(I8P), INTENT(IN) :: Z(1:) !< Z COMPONENT OF DATA VARIABLE. - LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". - INTEGER(I4P) :: ERROR !< ERROR STATUS. - CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. - INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. - CHARACTER(LEN=:), ALLOCATABLE :: CODE !< DATA VARIABLE ENCODED, ASCII OR BASE64 CODEC. - - DATA_TYPE = 'Int64' - N_COMPONENTS = 6 - CODE = ENCODE_ASCII_DATAARRAY(U=U, V=V, W=W, X=X, Y=Y, Z=Z) - CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, & - IS_TUPLES=IS_TUPLES) - ERROR = SELF%ERROR - ENDFUNCTION W_DATA6_RANK1_I8P - - FUNCTION W_DATA6_RANK1_I4P(SELF, DATA_NAME, U, V, W, X, Y, Z, IS_TUPLES) RESULT(ERROR) - !< WRITE `<DATAARRAY... NumberOfComponents="6"...>...</DATAARRAY>` TAG (I4P). - CLASS(XML_WRITER_ASCII_LOCAL), INTENT(INOUT) :: SELF !< WRITER. - CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. - INTEGER(I4P), INTENT(IN) :: U(1:) !< U COMPONENT OF DATA VARIABLE. - INTEGER(I4P), INTENT(IN) :: V(1:) !< V COMPONENT OF DATA VARIABLE. - INTEGER(I4P), INTENT(IN) :: W(1:) !< W COMPONENT OF DATA VARIABLE. - INTEGER(I4P), INTENT(IN) :: X(1:) !< X COMPONENT OF DATA VARIABLE. - INTEGER(I4P), INTENT(IN) :: Y(1:) !< Y COMPONENT OF DATA VARIABLE. - INTEGER(I4P), INTENT(IN) :: Z(1:) !< Z COMPONENT OF DATA VARIABLE. - LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". - INTEGER(I4P) :: ERROR !< ERROR STATUS. - CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. - INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. - CHARACTER(LEN=:), ALLOCATABLE :: CODE !< DATA VARIABLE ENCODED, ASCII OR BASE64 CODEC. - - DATA_TYPE = 'Int32' - N_COMPONENTS = 6 - CODE = ENCODE_ASCII_DATAARRAY(U=U, V=V, W=W, X=X, Y=Y, Z=Z) - CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, & - IS_TUPLES=IS_TUPLES) - ERROR = SELF%ERROR - ENDFUNCTION W_DATA6_RANK1_I4P - - FUNCTION W_DATA6_RANK1_I2P(SELF, DATA_NAME, U, V, W, X, Y, Z, IS_TUPLES) RESULT(ERROR) - !< WRITE `<DATAARRAY... NumberOfComponents="6"...>...</DATAARRAY>` TAG (I2P). - CLASS(XML_WRITER_ASCII_LOCAL), INTENT(INOUT) :: SELF !< WRITER. - CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. - INTEGER(I2P), INTENT(IN) :: U(1:) !< U COMPONENT OF DATA VARIABLE. - INTEGER(I2P), INTENT(IN) :: V(1:) !< V COMPONENT OF DATA VARIABLE. - INTEGER(I2P), INTENT(IN) :: W(1:) !< W COMPONENT OF DATA VARIABLE. - INTEGER(I2P), INTENT(IN) :: X(1:) !< X COMPONENT OF DATA VARIABLE. - INTEGER(I2P), INTENT(IN) :: Y(1:) !< Y COMPONENT OF DATA VARIABLE. - INTEGER(I2P), INTENT(IN) :: Z(1:) !< Z COMPONENT OF DATA VARIABLE. - LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". - INTEGER(I4P) :: ERROR !< ERROR STATUS. - CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. - INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. - CHARACTER(LEN=:), ALLOCATABLE :: CODE !< DATA VARIABLE ENCODED, ASCII OR BASE64 CODEC. - - DATA_TYPE = 'Int16' - N_COMPONENTS = 6 - CODE = ENCODE_ASCII_DATAARRAY(U=U, V=V, W=W, X=X, Y=Y, Z=Z) - CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, & - IS_TUPLES=IS_TUPLES) - ERROR = SELF%ERROR - ENDFUNCTION W_DATA6_RANK1_I2P - - FUNCTION W_DATA6_RANK1_I1P(SELF, DATA_NAME, U, V, W, X, Y, Z, IS_TUPLES) RESULT(ERROR) - !< WRITE `<DATAARRAY... NumberOfComponents="6"...>...</DATAARRAY>` TAG (I1P). - CLASS(XML_WRITER_ASCII_LOCAL), INTENT(INOUT) :: SELF !< WRITER. - CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. - INTEGER(I1P), INTENT(IN) :: U(1:) !< U COMPONENT OF DATA VARIABLE. - INTEGER(I1P), INTENT(IN) :: V(1:) !< V COMPONENT OF DATA VARIABLE. - INTEGER(I1P), INTENT(IN) :: W(1:) !< W COMPONENT OF DATA VARIABLE. - INTEGER(I1P), INTENT(IN) :: X(1:) !< X COMPONENT OF DATA VARIABLE. - INTEGER(I1P), INTENT(IN) :: Y(1:) !< Y COMPONENT OF DATA VARIABLE. - INTEGER(I1P), INTENT(IN) :: Z(1:) !< Z COMPONENT OF DATA VARIABLE. - LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". - INTEGER(I4P) :: ERROR !< ERROR STATUS. - CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. - INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. - CHARACTER(LEN=:), ALLOCATABLE :: CODE !< DATA VARIABLE ENCODED, ASCII OR BASE64 CODEC. - - DATA_TYPE = 'Int8' - N_COMPONENTS = 6 - CODE = ENCODE_ASCII_DATAARRAY(U=U, V=V, W=W, X=X, Y=Y, Z=Z) - CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, & - IS_TUPLES=IS_TUPLES) - ERROR = SELF%ERROR - ENDFUNCTION W_DATA6_RANK1_I1P - - FUNCTION W_DATA6_RANK3_R8P(SELF, DATA_NAME, U, V, W, X, Y, Z, IS_TUPLES) RESULT(ERROR) - !< WRITE `<DATAARRAY... NumberOfComponents="6"...>...</DATAARRAY>` TAG (R8P). - CLASS(XML_WRITER_ASCII_LOCAL), INTENT(INOUT) :: SELF !< WRITER. - CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. - REAL(R8P), INTENT(IN) :: U(1:,1:,1:) !< U COMPONENT OF DATA VARIABLE. - REAL(R8P), INTENT(IN) :: V(1:,1:,1:) !< V COMPONENT OF DATA VARIABLE. - REAL(R8P), INTENT(IN) :: W(1:,1:,1:) !< W COMPONENT OF DATA VARIABLE. - REAL(R8P), INTENT(IN) :: X(1:,1:,1:) !< X COMPONENT OF DATA VARIABLE. - REAL(R8P), INTENT(IN) :: Y(1:,1:,1:) !< Y COMPONENT OF DATA VARIABLE. - REAL(R8P), INTENT(IN) :: Z(1:,1:,1:) !< Z COMPONENT OF DATA VARIABLE. - LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". - INTEGER(I4P) :: ERROR !< ERROR STATUS. - CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. - INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. - CHARACTER(LEN=:), ALLOCATABLE :: CODE !< DATA VARIABLE ENCODED, ASCII OR BASE64 CODEC. - - DATA_TYPE = 'Float64' - N_COMPONENTS = 6 - CODE = ENCODE_ASCII_DATAARRAY(U=U, V=V, W=W, X=X, Y=Y, Z=Z) - CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, & - IS_TUPLES=IS_TUPLES) - ERROR = SELF%ERROR - ENDFUNCTION W_DATA6_RANK3_R8P - - FUNCTION W_DATA6_RANK3_R4P(SELF, DATA_NAME, U, V, W, X, Y, Z, IS_TUPLES) RESULT(ERROR) - !< WRITE `<DATAARRAY... NumberOfComponents="6"...>...</DATAARRAY>` TAG (R4P). - CLASS(XML_WRITER_ASCII_LOCAL), INTENT(INOUT) :: SELF !< WRITER. - CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. - REAL(R4P), INTENT(IN) :: U(1:,1:,1:) !< U COMPONENT OF DATA VARIABLE. - REAL(R4P), INTENT(IN) :: V(1:,1:,1:) !< V COMPONENT OF DATA VARIABLE. - REAL(R4P), INTENT(IN) :: W(1:,1:,1:) !< W COMPONENT OF DATA VARIABLE. - REAL(R4P), INTENT(IN) :: X(1:,1:,1:) !< X COMPONENT OF DATA VARIABLE. - REAL(R4P), INTENT(IN) :: Y(1:,1:,1:) !< Y COMPONENT OF DATA VARIABLE. - REAL(R4P), INTENT(IN) :: Z(1:,1:,1:) !< Z COMPONENT OF DATA VARIABLE. - LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". - INTEGER(I4P) :: ERROR !< ERROR STATUS. - CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. - INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. - CHARACTER(LEN=:), ALLOCATABLE :: CODE !< DATA VARIABLE ENCODED, ASCII OR BASE64 CODEC. - - DATA_TYPE = 'Float32' - N_COMPONENTS = 6 - CODE = ENCODE_ASCII_DATAARRAY(U=U, V=V, W=W, X=X, Y=Y, Z=Z) - CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, & - IS_TUPLES=IS_TUPLES) - ERROR = SELF%ERROR - ENDFUNCTION W_DATA6_RANK3_R4P - - FUNCTION W_DATA6_RANK3_I8P(SELF, DATA_NAME, U, V, W, X, Y, Z, IS_TUPLES) RESULT(ERROR) - !< WRITE `<DATAARRAY... NumberOfComponents="6"...>...</DATAARRAY>` TAG (I8P). - CLASS(XML_WRITER_ASCII_LOCAL), INTENT(INOUT) :: SELF !< WRITER. - CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. - INTEGER(I8P), INTENT(IN) :: U(1:,1:,1:) !< U COMPONENT OF DATA VARIABLE. - INTEGER(I8P), INTENT(IN) :: V(1:,1:,1:) !< V COMPONENT OF DATA VARIABLE. - INTEGER(I8P), INTENT(IN) :: W(1:,1:,1:) !< W COMPONENT OF DATA VARIABLE. - INTEGER(I8P), INTENT(IN) :: X(1:,1:,1:) !< X COMPONENT OF DATA VARIABLE. - INTEGER(I8P), INTENT(IN) :: Y(1:,1:,1:) !< Y COMPONENT OF DATA VARIABLE. - INTEGER(I8P), INTENT(IN) :: Z(1:,1:,1:) !< Z COMPONENT OF DATA VARIABLE. - LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". - INTEGER(I4P) :: ERROR !< ERROR STATUS. - CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. - INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. - CHARACTER(LEN=:), ALLOCATABLE :: CODE !< DATA VARIABLE ENCODED, ASCII OR BASE64 CODEC. - - DATA_TYPE = 'Int64' - N_COMPONENTS = 6 - CODE = ENCODE_ASCII_DATAARRAY(U=U, V=V, W=W, X=X, Y=Y, Z=Z) - CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, & - IS_TUPLES=IS_TUPLES) - ERROR = SELF%ERROR - ENDFUNCTION W_DATA6_RANK3_I8P - - FUNCTION W_DATA6_RANK3_I4P(SELF, DATA_NAME, U, V, W, X, Y, Z, IS_TUPLES) RESULT(ERROR) - !< WRITE `<DATAARRAY... NumberOfComponents="6"...>...</DATAARRAY>` TAG (I4P). - CLASS(XML_WRITER_ASCII_LOCAL), INTENT(INOUT) :: SELF !< WRITER. - CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. - INTEGER(I4P), INTENT(IN) :: U(1:,1:,1:) !< U COMPONENT OF DATA VARIABLE. - INTEGER(I4P), INTENT(IN) :: V(1:,1:,1:) !< V COMPONENT OF DATA VARIABLE. - INTEGER(I4P), INTENT(IN) :: W(1:,1:,1:) !< W COMPONENT OF DATA VARIABLE. - INTEGER(I4P), INTENT(IN) :: X(1:,1:,1:) !< X COMPONENT OF DATA VARIABLE. - INTEGER(I4P), INTENT(IN) :: Y(1:,1:,1:) !< Y COMPONENT OF DATA VARIABLE. - INTEGER(I4P), INTENT(IN) :: Z(1:,1:,1:) !< Z COMPONENT OF DATA VARIABLE. - LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". - INTEGER(I4P) :: ERROR !< ERROR STATUS. - CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. - INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. - CHARACTER(LEN=:), ALLOCATABLE :: CODE !< DATA VARIABLE ENCODED, ASCII OR BASE64 CODEC. - - DATA_TYPE = 'Int32' - N_COMPONENTS = 6 - CODE = ENCODE_ASCII_DATAARRAY(U=U, V=V, W=W, X=X, Y=Y, Z=Z) - CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, & - IS_TUPLES=IS_TUPLES) - ERROR = SELF%ERROR - ENDFUNCTION W_DATA6_RANK3_I4P - - FUNCTION W_DATA6_RANK3_I2P(SELF, DATA_NAME, U, V, W, X, Y, Z, IS_TUPLES) RESULT(ERROR) - !< WRITE `<DATAARRAY... NumberOfComponents="6"...>...</DATAARRAY>` TAG (I2P). - CLASS(XML_WRITER_ASCII_LOCAL), INTENT(INOUT) :: SELF !< WRITER. - CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. - INTEGER(I2P), INTENT(IN) :: U(1:,1:,1:) !< U COMPONENT OF DATA VARIABLE. - INTEGER(I2P), INTENT(IN) :: V(1:,1:,1:) !< V COMPONENT OF DATA VARIABLE. - INTEGER(I2P), INTENT(IN) :: W(1:,1:,1:) !< W COMPONENT OF DATA VARIABLE. - INTEGER(I2P), INTENT(IN) :: X(1:,1:,1:) !< X COMPONENT OF DATA VARIABLE. - INTEGER(I2P), INTENT(IN) :: Y(1:,1:,1:) !< Y COMPONENT OF DATA VARIABLE. - INTEGER(I2P), INTENT(IN) :: Z(1:,1:,1:) !< Z COMPONENT OF DATA VARIABLE. - LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". - INTEGER(I4P) :: ERROR !< ERROR STATUS. - CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. - INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. - CHARACTER(LEN=:), ALLOCATABLE :: CODE !< DATA VARIABLE ENCODED, ASCII OR BASE64 CODEC. - - DATA_TYPE = 'Int16' - N_COMPONENTS = 6 - CODE = ENCODE_ASCII_DATAARRAY(U=U, V=V, W=W, X=X, Y=Y, Z=Z) - CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, & - IS_TUPLES=IS_TUPLES) - ERROR = SELF%ERROR - ENDFUNCTION W_DATA6_RANK3_I2P - - FUNCTION W_DATA6_RANK3_I1P(SELF, DATA_NAME, U, V, W, X, Y, Z, IS_TUPLES) RESULT(ERROR) - !< WRITE `<DATAARRAY... NumberOfComponents="6"...>...</DATAARRAY>` TAG (I1P). - CLASS(XML_WRITER_ASCII_LOCAL), INTENT(INOUT) :: SELF !< WRITER. - CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. - INTEGER(I1P), INTENT(IN) :: U(1:,1:,1:) !< U COMPONENT OF DATA VARIABLE. - INTEGER(I1P), INTENT(IN) :: V(1:,1:,1:) !< V COMPONENT OF DATA VARIABLE. - INTEGER(I1P), INTENT(IN) :: W(1:,1:,1:) !< W COMPONENT OF DATA VARIABLE. - INTEGER(I1P), INTENT(IN) :: X(1:,1:,1:) !< X COMPONENT OF DATA VARIABLE. - INTEGER(I1P), INTENT(IN) :: Y(1:,1:,1:) !< Y COMPONENT OF DATA VARIABLE. - INTEGER(I1P), INTENT(IN) :: Z(1:,1:,1:) !< Z COMPONENT OF DATA VARIABLE. - LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". - INTEGER(I4P) :: ERROR !< ERROR STATUS. - CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. - INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. - CHARACTER(LEN=:), ALLOCATABLE :: CODE !< DATA VARIABLE ENCODED, ASCII OR BASE64 CODEC. - - DATA_TYPE = 'Int8' - N_COMPONENTS = 6 - CODE = ENCODE_ASCII_DATAARRAY(U=U, V=V, W=W, X=X, Y=Y, Z=Z) - CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, & - IS_TUPLES=IS_TUPLES) - ERROR = SELF%ERROR - ENDFUNCTION W_DATA6_RANK3_I1P - - - SUBROUTINE W_DATA_APPENDED(SELF) - !< DO NOTHING, ASCII DATA CANNOT BE APPENDED. - CLASS(XML_WRITER_ASCII_LOCAL), INTENT(INOUT) :: SELF !< WRITER. - ENDSUBROUTINE W_DATA_APPENDED -ENDMODULE VTKF_FILE_XML_WRITER_ASCII_LOCAL + + SUBROUTINE W_DATA_APPENDED(SELF) + !< DO NOTHING, ASCII DATA CANNOT BE APPENDED. + CLASS(XML_WRITER_ASCII_LOCAL), INTENT(INOUT) :: SELF !< WRITER. + ENDSUBROUTINE W_DATA_APPENDED +ENDMODULE VTKF_FILE_XML_WRITER_ASCII_LOCAL @@ -14995,48 +11087,12 @@ MODULE VTKF_FILE_XML_WRITER_APPENDED PROCEDURE, PASS(SELF) :: W_DATA1_RANK1_I4P !< WRITE DATAARRAY 1, RANK 1, I4P. PROCEDURE, PASS(SELF) :: W_DATA1_RANK1_I2P !< WRITE DATAARRAY 1, RANK 1, I2P. PROCEDURE, PASS(SELF) :: W_DATA1_RANK1_I1P !< WRITE DATAARRAY 1, RANK 1, I1P. - PROCEDURE, PASS(SELF) :: W_DATA1_RANK2_R8P !< WRITE DATAARRAY 1, RANK 2, R8P. - PROCEDURE, PASS(SELF) :: W_DATA1_RANK2_R4P !< WRITE DATAARRAY 1, RANK 2, R4P. - PROCEDURE, PASS(SELF) :: W_DATA1_RANK2_I8P !< WRITE DATAARRAY 1, RANK 2, I8P. - PROCEDURE, PASS(SELF) :: W_DATA1_RANK2_I4P !< WRITE DATAARRAY 1, RANK 2, I4P. - PROCEDURE, PASS(SELF) :: W_DATA1_RANK2_I2P !< WRITE DATAARRAY 1, RANK 2, I2P. - PROCEDURE, PASS(SELF) :: W_DATA1_RANK2_I1P !< WRITE DATAARRAY 1, RANK 2, I1P. - PROCEDURE, PASS(SELF) :: W_DATA1_RANK3_R8P !< WRITE DATAARRAY 1, RANK 3, R8P. - PROCEDURE, PASS(SELF) :: W_DATA1_RANK3_R4P !< WRITE DATAARRAY 1, RANK 3, R4P. - PROCEDURE, PASS(SELF) :: W_DATA1_RANK3_I8P !< WRITE DATAARRAY 1, RANK 3, I8P. - PROCEDURE, PASS(SELF) :: W_DATA1_RANK3_I4P !< WRITE DATAARRAY 1, RANK 3, I4P. - PROCEDURE, PASS(SELF) :: W_DATA1_RANK3_I2P !< WRITE DATAARRAY 1, RANK 3, I2P. - PROCEDURE, PASS(SELF) :: W_DATA1_RANK3_I1P !< WRITE DATAARRAY 1, RANK 3, I1P. - PROCEDURE, PASS(SELF) :: W_DATA1_RANK4_R8P !< WRITE DATAARRAY 1, RANK 4, R8P. - PROCEDURE, PASS(SELF) :: W_DATA1_RANK4_R4P !< WRITE DATAARRAY 1, RANK 4, R4P. - PROCEDURE, PASS(SELF) :: W_DATA1_RANK4_I8P !< WRITE DATAARRAY 1, RANK 4, I8P. - PROCEDURE, PASS(SELF) :: W_DATA1_RANK4_I4P !< WRITE DATAARRAY 1, RANK 4, I4P. - PROCEDURE, PASS(SELF) :: W_DATA1_RANK4_I2P !< WRITE DATAARRAY 1, RANK 4, I2P. - PROCEDURE, PASS(SELF) :: W_DATA1_RANK4_I1P !< WRITE DATAARRAY 1, RANK 4, I1P. PROCEDURE, PASS(SELF) :: W_DATA3_RANK1_R8P !< WRITE DATAARRAY 3, RANK 1, R8P. PROCEDURE, PASS(SELF) :: W_DATA3_RANK1_R4P !< WRITE DATAARRAY 3, RANK 1, R4P. PROCEDURE, PASS(SELF) :: W_DATA3_RANK1_I8P !< WRITE DATAARRAY 3, RANK 1, I8P. PROCEDURE, PASS(SELF) :: W_DATA3_RANK1_I4P !< WRITE DATAARRAY 3, RANK 1, I4P. PROCEDURE, PASS(SELF) :: W_DATA3_RANK1_I2P !< WRITE DATAARRAY 3, RANK 1, I2P. PROCEDURE, PASS(SELF) :: W_DATA3_RANK1_I1P !< WRITE DATAARRAY 3, RANK 1, I1P. - PROCEDURE, PASS(SELF) :: W_DATA3_RANK3_R8P !< WRITE DATAARRAY 3, RANK 3, R8P. - PROCEDURE, PASS(SELF) :: W_DATA3_RANK3_R4P !< WRITE DATAARRAY 3, RANK 3, R4P. - PROCEDURE, PASS(SELF) :: W_DATA3_RANK3_I8P !< WRITE DATAARRAY 3, RANK 3, I8P. - PROCEDURE, PASS(SELF) :: W_DATA3_RANK3_I4P !< WRITE DATAARRAY 3, RANK 3, I4P. - PROCEDURE, PASS(SELF) :: W_DATA3_RANK3_I2P !< WRITE DATAARRAY 3, RANK 3, I2P. - PROCEDURE, PASS(SELF) :: W_DATA3_RANK3_I1P !< WRITE DATAARRAY 3, RANK 3, I1P. - PROCEDURE, PASS(SELF) :: W_DATA6_RANK1_R8P !< WRITE DATAARRAY 6, RANK 1, R8P. - PROCEDURE, PASS(SELF) :: W_DATA6_RANK1_R4P !< WRITE DATAARRAY 6, RANK 1, R4P. - PROCEDURE, PASS(SELF) :: W_DATA6_RANK1_I8P !< WRITE DATAARRAY 6, RANK 1, I8P. - PROCEDURE, PASS(SELF) :: W_DATA6_RANK1_I4P !< WRITE DATAARRAY 6, RANK 1, I4P. - PROCEDURE, PASS(SELF) :: W_DATA6_RANK1_I2P !< WRITE DATAARRAY 6, RANK 1, I2P. - PROCEDURE, PASS(SELF) :: W_DATA6_RANK1_I1P !< WRITE DATAARRAY 6, RANK 1, I1P. - PROCEDURE, PASS(SELF) :: W_DATA6_RANK3_R8P !< WRITE DATAARRAY 6, RANK 3, R8P. - PROCEDURE, PASS(SELF) :: W_DATA6_RANK3_R4P !< WRITE DATAARRAY 6, RANK 3, R4P. - PROCEDURE, PASS(SELF) :: W_DATA6_RANK3_I8P !< WRITE DATAARRAY 6, RANK 3, I8P. - PROCEDURE, PASS(SELF) :: W_DATA6_RANK3_I4P !< WRITE DATAARRAY 6, RANK 3, I4P. - PROCEDURE, PASS(SELF) :: W_DATA6_RANK3_I2P !< WRITE DATAARRAY 6, RANK 3, I2P. - PROCEDURE, PASS(SELF) :: W_DATA6_RANK3_I1P !< WRITE DATAARRAY 6, RANK 3, I1P. PROCEDURE, PASS(SELF) :: W_DATA_APPENDED !< WRITE APPENDED. ! PRIVATE METHODS PROCEDURE, PASS(SELF), PRIVATE :: IOFFSET_UPDATE !< UPDATE IOFFSET COUNT. @@ -15044,85 +11100,19 @@ MODULE VTKF_FILE_XML_WRITER_APPENDED PROCEDURE, PASS(SELF), PRIVATE :: CLOSE_SCRATCH_FILE !< CLOSE SCRATCH FILE. GENERIC, PRIVATE :: WRITE_ON_SCRATCH_DATAARRAY => & WRITE_ON_SCRATCH_DATAARRAY1_RANK1, & - WRITE_ON_SCRATCH_DATAARRAY1_RANK2, & - WRITE_ON_SCRATCH_DATAARRAY1_RANK3, & - WRITE_ON_SCRATCH_DATAARRAY1_RANK4, & WRITE_ON_SCRATCH_DATAARRAY3_RANK1_R8P, & WRITE_ON_SCRATCH_DATAARRAY3_RANK1_R4P, & WRITE_ON_SCRATCH_DATAARRAY3_RANK1_I8P, & WRITE_ON_SCRATCH_DATAARRAY3_RANK1_I4P, & WRITE_ON_SCRATCH_DATAARRAY3_RANK1_I2P, & - WRITE_ON_SCRATCH_DATAARRAY3_RANK1_I1P, & - WRITE_ON_SCRATCH_DATAARRAY3_RANK2_R8P, & - WRITE_ON_SCRATCH_DATAARRAY3_RANK2_R4P, & - WRITE_ON_SCRATCH_DATAARRAY3_RANK2_I8P, & - WRITE_ON_SCRATCH_DATAARRAY3_RANK2_I4P, & - WRITE_ON_SCRATCH_DATAARRAY3_RANK2_I2P, & - WRITE_ON_SCRATCH_DATAARRAY3_RANK2_I1P, & - WRITE_ON_SCRATCH_DATAARRAY3_RANK3_R8P, & - WRITE_ON_SCRATCH_DATAARRAY3_RANK3_R4P, & - WRITE_ON_SCRATCH_DATAARRAY3_RANK3_I8P, & - WRITE_ON_SCRATCH_DATAARRAY3_RANK3_I4P, & - WRITE_ON_SCRATCH_DATAARRAY3_RANK3_I2P, & - WRITE_ON_SCRATCH_DATAARRAY3_RANK3_I1P, & - WRITE_ON_SCRATCH_DATAARRAY6_RANK1_R8P, & - WRITE_ON_SCRATCH_DATAARRAY6_RANK1_R4P, & - WRITE_ON_SCRATCH_DATAARRAY6_RANK1_I8P, & - WRITE_ON_SCRATCH_DATAARRAY6_RANK1_I4P, & - WRITE_ON_SCRATCH_DATAARRAY6_RANK1_I2P, & - WRITE_ON_SCRATCH_DATAARRAY6_RANK1_I1P, & - WRITE_ON_SCRATCH_DATAARRAY6_RANK2_R8P, & - WRITE_ON_SCRATCH_DATAARRAY6_RANK2_R4P, & - WRITE_ON_SCRATCH_DATAARRAY6_RANK2_I8P, & - WRITE_ON_SCRATCH_DATAARRAY6_RANK2_I4P, & - WRITE_ON_SCRATCH_DATAARRAY6_RANK2_I2P, & - WRITE_ON_SCRATCH_DATAARRAY6_RANK2_I1P, & - WRITE_ON_SCRATCH_DATAARRAY6_RANK3_R8P, & - WRITE_ON_SCRATCH_DATAARRAY6_RANK3_R4P, & - WRITE_ON_SCRATCH_DATAARRAY6_RANK3_I8P, & - WRITE_ON_SCRATCH_DATAARRAY6_RANK3_I4P, & - WRITE_ON_SCRATCH_DATAARRAY6_RANK3_I2P, & - WRITE_ON_SCRATCH_DATAARRAY6_RANK3_I1P !< WRITE DATAARRAY. + WRITE_ON_SCRATCH_DATAARRAY3_RANK1_I1P PROCEDURE, PASS(SELF), PRIVATE :: WRITE_ON_SCRATCH_DATAARRAY1_RANK1 !< WRITE DATAARRAY, DATA 1 RANK 1. - PROCEDURE, PASS(SELF), PRIVATE :: WRITE_ON_SCRATCH_DATAARRAY1_RANK2 !< WRITE DATAARRAY, DATA 1 RANK 2. - PROCEDURE, PASS(SELF), PRIVATE :: WRITE_ON_SCRATCH_DATAARRAY1_RANK3 !< WRITE DATAARRAY, DATA 1 RANK 3. - PROCEDURE, PASS(SELF), PRIVATE :: WRITE_ON_SCRATCH_DATAARRAY1_RANK4 !< WRITE DATAARRAY, DATA 1 RANK 4. PROCEDURE, PASS(SELF), PRIVATE :: WRITE_ON_SCRATCH_DATAARRAY3_RANK1_R8P !< WRITE DATAARRAY, COMP 3 RANK 1, R8P. PROCEDURE, PASS(SELF), PRIVATE :: WRITE_ON_SCRATCH_DATAARRAY3_RANK1_R4P !< WRITE DATAARRAY, COMP 3 RANK 1, R4P. PROCEDURE, PASS(SELF), PRIVATE :: WRITE_ON_SCRATCH_DATAARRAY3_RANK1_I8P !< WRITE DATAARRAY, COMP 3 RANK 1, I8P. PROCEDURE, PASS(SELF), PRIVATE :: WRITE_ON_SCRATCH_DATAARRAY3_RANK1_I4P !< WRITE DATAARRAY, COMP 3 RANK 1, I4P. PROCEDURE, PASS(SELF), PRIVATE :: WRITE_ON_SCRATCH_DATAARRAY3_RANK1_I2P !< WRITE DATAARRAY, COMP 3 RANK 1, I2P. PROCEDURE, PASS(SELF), PRIVATE :: WRITE_ON_SCRATCH_DATAARRAY3_RANK1_I1P !< WRITE DATAARRAY, COMP 3 RANK 1, I1P. - PROCEDURE, PASS(SELF), PRIVATE :: WRITE_ON_SCRATCH_DATAARRAY3_RANK2_R8P !< WRITE DATAARRAY, COMP 3 RANK 2, R8P. - PROCEDURE, PASS(SELF), PRIVATE :: WRITE_ON_SCRATCH_DATAARRAY3_RANK2_R4P !< WRITE DATAARRAY, COMP 3 RANK 2, R4P. - PROCEDURE, PASS(SELF), PRIVATE :: WRITE_ON_SCRATCH_DATAARRAY3_RANK2_I8P !< WRITE DATAARRAY, COMP 3 RANK 2, I8P. - PROCEDURE, PASS(SELF), PRIVATE :: WRITE_ON_SCRATCH_DATAARRAY3_RANK2_I4P !< WRITE DATAARRAY, COMP 3 RANK 2, I4P. - PROCEDURE, PASS(SELF), PRIVATE :: WRITE_ON_SCRATCH_DATAARRAY3_RANK2_I2P !< WRITE DATAARRAY, COMP 3 RANK 2, I2P. - PROCEDURE, PASS(SELF), PRIVATE :: WRITE_ON_SCRATCH_DATAARRAY3_RANK2_I1P !< WRITE DATAARRAY, COMP 3 RANK 2, I1P. - PROCEDURE, PASS(SELF), PRIVATE :: WRITE_ON_SCRATCH_DATAARRAY3_RANK3_R8P !< WRITE DATAARRAY, COMP 3 RANK 3, R8P. - PROCEDURE, PASS(SELF), PRIVATE :: WRITE_ON_SCRATCH_DATAARRAY3_RANK3_R4P !< WRITE DATAARRAY, COMP 3 RANK 3, R4P. - PROCEDURE, PASS(SELF), PRIVATE :: WRITE_ON_SCRATCH_DATAARRAY3_RANK3_I8P !< WRITE DATAARRAY, COMP 3 RANK 3, I8P. - PROCEDURE, PASS(SELF), PRIVATE :: WRITE_ON_SCRATCH_DATAARRAY3_RANK3_I4P !< WRITE DATAARRAY, COMP 3 RANK 3, I4P. - PROCEDURE, PASS(SELF), PRIVATE :: WRITE_ON_SCRATCH_DATAARRAY3_RANK3_I2P !< WRITE DATAARRAY, COMP 3 RANK 3, I2P. - PROCEDURE, PASS(SELF), PRIVATE :: WRITE_ON_SCRATCH_DATAARRAY3_RANK3_I1P !< WRITE DATAARRAY, COMP 3 RANK 3, I1P. - PROCEDURE, PASS(SELF), PRIVATE :: WRITE_ON_SCRATCH_DATAARRAY6_RANK1_R8P !< WRITE DATAARRAY, COMP 6 RANK 1, R8P. - PROCEDURE, PASS(SELF), PRIVATE :: WRITE_ON_SCRATCH_DATAARRAY6_RANK1_R4P !< WRITE DATAARRAY, COMP 6 RANK 1, R4P. - PROCEDURE, PASS(SELF), PRIVATE :: WRITE_ON_SCRATCH_DATAARRAY6_RANK1_I8P !< WRITE DATAARRAY, COMP 6 RANK 1, I8P. - PROCEDURE, PASS(SELF), PRIVATE :: WRITE_ON_SCRATCH_DATAARRAY6_RANK1_I4P !< WRITE DATAARRAY, COMP 6 RANK 1, I4P. - PROCEDURE, PASS(SELF), PRIVATE :: WRITE_ON_SCRATCH_DATAARRAY6_RANK1_I2P !< WRITE DATAARRAY, COMP 6 RANK 1, I2P. - PROCEDURE, PASS(SELF), PRIVATE :: WRITE_ON_SCRATCH_DATAARRAY6_RANK1_I1P !< WRITE DATAARRAY, COMP 6 RANK 1, I1P. - PROCEDURE, PASS(SELF), PRIVATE :: WRITE_ON_SCRATCH_DATAARRAY6_RANK2_R8P !< WRITE DATAARRAY, COMP 6 RANK 2, R8P. - PROCEDURE, PASS(SELF), PRIVATE :: WRITE_ON_SCRATCH_DATAARRAY6_RANK2_R4P !< WRITE DATAARRAY, COMP 6 RANK 2, R4P. - PROCEDURE, PASS(SELF), PRIVATE :: WRITE_ON_SCRATCH_DATAARRAY6_RANK2_I8P !< WRITE DATAARRAY, COMP 6 RANK 2, I8P. - PROCEDURE, PASS(SELF), PRIVATE :: WRITE_ON_SCRATCH_DATAARRAY6_RANK2_I4P !< WRITE DATAARRAY, COMP 6 RANK 2, I4P. - PROCEDURE, PASS(SELF), PRIVATE :: WRITE_ON_SCRATCH_DATAARRAY6_RANK2_I2P !< WRITE DATAARRAY, COMP 6 RANK 2, I2P. - PROCEDURE, PASS(SELF), PRIVATE :: WRITE_ON_SCRATCH_DATAARRAY6_RANK2_I1P !< WRITE DATAARRAY, COMP 6 RANK 2, I1P. - PROCEDURE, PASS(SELF), PRIVATE :: WRITE_ON_SCRATCH_DATAARRAY6_RANK3_R8P !< WRITE DATAARRAY, COMP 6 RANK 3, R8P. - PROCEDURE, PASS(SELF), PRIVATE :: WRITE_ON_SCRATCH_DATAARRAY6_RANK3_R4P !< WRITE DATAARRAY, COMP 6 RANK 3, R4P. - PROCEDURE, PASS(SELF), PRIVATE :: WRITE_ON_SCRATCH_DATAARRAY6_RANK3_I8P !< WRITE DATAARRAY, COMP 6 RANK 3, I8P. - PROCEDURE, PASS(SELF), PRIVATE :: WRITE_ON_SCRATCH_DATAARRAY6_RANK3_I4P !< WRITE DATAARRAY, COMP 6 RANK 3, I4P. - PROCEDURE, PASS(SELF), PRIVATE :: WRITE_ON_SCRATCH_DATAARRAY6_RANK3_I2P !< WRITE DATAARRAY, COMP 6 RANK 3, I2P. - PROCEDURE, PASS(SELF), PRIVATE :: WRITE_ON_SCRATCH_DATAARRAY6_RANK3_I1P !< WRITE DATAARRAY, COMP 6 RANK 3, I1P. ENDTYPE XML_WRITER_APPENDED CONTAINS FUNCTION INITIALIZE(SELF, FORMAT, FILENAME, MESH_TOPOLOGY, NX1, NX2, NY1, NY2, NZ1, NZ2, & @@ -15313,421 +11303,25 @@ FUNCTION W_DATA1_RANK1_I1P(SELF, DATA_NAME, X, IS_TUPLES) RESULT(ERROR) ERROR = SELF%ERROR ENDFUNCTION W_DATA1_RANK1_I1P - FUNCTION W_DATA1_RANK2_R8P(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR) - !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (R8P). - CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF !< WRITER. - CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. - REAL(R8P), INTENT(IN) :: X(1:,1:) !< DATA VARIABLE. - LOGICAL, INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT. - LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES". - INTEGER(I4P) :: ERROR !< ERROR STATUS. - CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. - INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. + FUNCTION W_DATA3_RANK1_R8P(SELF, DATA_NAME, X, Y, Z, IS_TUPLES) RESULT(ERROR) + !< WRITE `<DATAARRAY... NumberOfComponents="3"...>...</DATAARRAY>` TAG (R8P). + CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF !< WRITER. + CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. + REAL(R8P), INTENT(IN) :: X(1:) !< X COMPONENT OF DATA VARIABLE. + REAL(R8P), INTENT(IN) :: Y(1:) !< Y COMPONENT OF DATA VARIABLE. + REAL(R8P), INTENT(IN) :: Z(1:) !< Z COMPONENT OF DATA VARIABLE. + LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD "NUMBEROFCOMPONENTS" ATTRIBUTE. + INTEGER(I4P) :: ERROR !< ERROR STATUS. + CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. + INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. DATA_TYPE = 'Float64' - N_COMPONENTS = SIZE(X, DIM=1) - IF (PRESENT(ONE_COMPONENT)) THEN - IF (ONE_COMPONENT) N_COMPONENTS = 1 - ENDIF + N_COMPONENTS = 3 CALL SELF%W_DATA_TAG_APPENDED(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, & IS_TUPLES=IS_TUPLES) - CALL SELF%IOFFSET_UPDATE(N_BYTE=SELF%WRITE_ON_SCRATCH_DATAARRAY(X=X)) + CALL SELF%IOFFSET_UPDATE(N_BYTE=SELF%WRITE_ON_SCRATCH_DATAARRAY(X=X, Y=Y, Z=Z)) ERROR = SELF%ERROR - ENDFUNCTION W_DATA1_RANK2_R8P - - FUNCTION W_DATA1_RANK2_R4P(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR) - !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (R4P). - CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF !< WRITER. - CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. - REAL(R4P), INTENT(IN) :: X(1:,1:) !< DATA VARIABLE. - LOGICAL, INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT. - LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES". - INTEGER(I4P) :: ERROR !< ERROR STATUS. - CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. - INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. - - DATA_TYPE = 'Float32' - N_COMPONENTS = SIZE(X, DIM=1) - IF (PRESENT(ONE_COMPONENT)) THEN - IF (ONE_COMPONENT) N_COMPONENTS = 1 - ENDIF - CALL SELF%W_DATA_TAG_APPENDED(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, & - IS_TUPLES=IS_TUPLES) - CALL SELF%IOFFSET_UPDATE(N_BYTE=SELF%WRITE_ON_SCRATCH_DATAARRAY(X=X)) - ERROR = SELF%ERROR - ENDFUNCTION W_DATA1_RANK2_R4P - - FUNCTION W_DATA1_RANK2_I8P(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR) - !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (I8P). - CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF !< WRITER. - CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. - INTEGER(I8P), INTENT(IN) :: X(1:,1:) !< DATA VARIABLE. - LOGICAL, INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT. - LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES". - INTEGER(I4P) :: ERROR !< ERROR STATUS. - CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. - INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. - - DATA_TYPE = 'Int64' - N_COMPONENTS = SIZE(X, DIM=1) - IF (PRESENT(ONE_COMPONENT)) THEN - IF (ONE_COMPONENT) N_COMPONENTS = 1 - ENDIF - CALL SELF%W_DATA_TAG_APPENDED(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, & - IS_TUPLES=IS_TUPLES) - CALL SELF%IOFFSET_UPDATE(N_BYTE=SELF%WRITE_ON_SCRATCH_DATAARRAY(X=X)) - ERROR = SELF%ERROR - ENDFUNCTION W_DATA1_RANK2_I8P - - FUNCTION W_DATA1_RANK2_I4P(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR) - !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (I4P). - CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF !< WRITER. - CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. - INTEGER(I4P), INTENT(IN) :: X(1:,1:) !< DATA VARIABLE. - LOGICAL, INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT. - LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES". - INTEGER(I4P) :: ERROR !< ERROR STATUS. - CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. - INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. - - DATA_TYPE = 'Int32' - N_COMPONENTS = SIZE(X, DIM=1) - IF (PRESENT(ONE_COMPONENT)) THEN - IF (ONE_COMPONENT) N_COMPONENTS = 1 - ENDIF - CALL SELF%W_DATA_TAG_APPENDED(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, & - IS_TUPLES=IS_TUPLES) - CALL SELF%IOFFSET_UPDATE(N_BYTE=SELF%WRITE_ON_SCRATCH_DATAARRAY(X=X)) - ERROR = SELF%ERROR - ENDFUNCTION W_DATA1_RANK2_I4P - - FUNCTION W_DATA1_RANK2_I2P(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR) - !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (I2P). - CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF !< WRITER. - CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. - INTEGER(I2P), INTENT(IN) :: X(1:,1:) !< DATA VARIABLE. - LOGICAL, INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT. - LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES". - INTEGER(I4P) :: ERROR !< ERROR STATUS. - CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. - INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. - - DATA_TYPE = 'Int16' - N_COMPONENTS = SIZE(X, DIM=1) - IF (PRESENT(ONE_COMPONENT)) THEN - IF (ONE_COMPONENT) N_COMPONENTS = 1 - ENDIF - CALL SELF%W_DATA_TAG_APPENDED(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, & - IS_TUPLES=IS_TUPLES) - CALL SELF%IOFFSET_UPDATE(N_BYTE=SELF%WRITE_ON_SCRATCH_DATAARRAY(X=X)) - ERROR = SELF%ERROR - ENDFUNCTION W_DATA1_RANK2_I2P - - FUNCTION W_DATA1_RANK2_I1P(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR) - !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (I1P). - CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF !< WRITER. - CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. - INTEGER(I1P), INTENT(IN) :: X(1:,1:) !< DATA VARIABLE. - LOGICAL, INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT. - LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES". - INTEGER(I4P) :: ERROR !< ERROR STATUS. - CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. - INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. - - DATA_TYPE = 'Int8' - N_COMPONENTS = SIZE(X, DIM=1) - IF (PRESENT(ONE_COMPONENT)) THEN - IF (ONE_COMPONENT) N_COMPONENTS = 1 - ENDIF - CALL SELF%W_DATA_TAG_APPENDED(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, & - IS_TUPLES=IS_TUPLES) - CALL SELF%IOFFSET_UPDATE(N_BYTE=SELF%WRITE_ON_SCRATCH_DATAARRAY(X=X)) - ERROR = SELF%ERROR - ENDFUNCTION W_DATA1_RANK2_I1P - - FUNCTION W_DATA1_RANK3_R8P(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR) - !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (R8P). - CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF !< WRITER. - CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. - REAL(R8P), INTENT(IN) :: X(1:,1:,1:) !< DATA VARIABLE. - LOGICAL, INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT. - LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES". - INTEGER(I4P) :: ERROR !< ERROR STATUS. - CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. - INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. - - DATA_TYPE = 'Float64' - N_COMPONENTS = SIZE(X, DIM=1) - IF (PRESENT(ONE_COMPONENT)) THEN - IF (ONE_COMPONENT) N_COMPONENTS = 1 - ENDIF - CALL SELF%W_DATA_TAG_APPENDED(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, & - IS_TUPLES=IS_TUPLES) - CALL SELF%IOFFSET_UPDATE(N_BYTE=SELF%WRITE_ON_SCRATCH_DATAARRAY(X=X)) - ERROR = SELF%ERROR - ENDFUNCTION W_DATA1_RANK3_R8P - - FUNCTION W_DATA1_RANK3_R4P(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR) - !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (R4P). - CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF !< WRITER. - CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. - REAL(R4P), INTENT(IN) :: X(1:,1:,1:) !< DATA VARIABLE. - LOGICAL, INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT. - LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES". - INTEGER(I4P) :: ERROR !< ERROR STATUS. - CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. - INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. - - DATA_TYPE = 'Float32' - N_COMPONENTS = SIZE(X, DIM=1) - IF (PRESENT(ONE_COMPONENT)) THEN - IF (ONE_COMPONENT) N_COMPONENTS = 1 - ENDIF - CALL SELF%W_DATA_TAG_APPENDED(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, & - IS_TUPLES=IS_TUPLES) - CALL SELF%IOFFSET_UPDATE(N_BYTE=SELF%WRITE_ON_SCRATCH_DATAARRAY(X=X)) - ERROR = SELF%ERROR - ENDFUNCTION W_DATA1_RANK3_R4P - - FUNCTION W_DATA1_RANK3_I8P(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR) - !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (I8P). - CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF !< WRITER. - CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. - INTEGER(I8P), INTENT(IN) :: X(1:,1:,1:) !< DATA VARIABLE. - LOGICAL, INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT. - LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES". - INTEGER(I4P) :: ERROR !< ERROR STATUS. - CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. - INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. - - DATA_TYPE = 'Int64' - N_COMPONENTS = SIZE(X, DIM=1) - IF (PRESENT(ONE_COMPONENT)) THEN - IF (ONE_COMPONENT) N_COMPONENTS = 1 - ENDIF - CALL SELF%W_DATA_TAG_APPENDED(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, & - IS_TUPLES=IS_TUPLES) - CALL SELF%IOFFSET_UPDATE(N_BYTE=SELF%WRITE_ON_SCRATCH_DATAARRAY(X=X)) - ERROR = SELF%ERROR - ENDFUNCTION W_DATA1_RANK3_I8P - - FUNCTION W_DATA1_RANK3_I4P(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR) - !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (I4P). - CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF !< WRITER. - CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. - INTEGER(I4P), INTENT(IN) :: X(1:,1:,1:) !< DATA VARIABLE. - LOGICAL, INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT. - LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES". - INTEGER(I4P) :: ERROR !< ERROR STATUS. - CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. - INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. - - DATA_TYPE = 'Int32' - N_COMPONENTS = SIZE(X, DIM=1) - IF (PRESENT(ONE_COMPONENT)) THEN - IF (ONE_COMPONENT) N_COMPONENTS = 1 - ENDIF - CALL SELF%W_DATA_TAG_APPENDED(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, & - IS_TUPLES=IS_TUPLES) - CALL SELF%IOFFSET_UPDATE(N_BYTE=SELF%WRITE_ON_SCRATCH_DATAARRAY(X=X)) - ERROR = SELF%ERROR - ENDFUNCTION W_DATA1_RANK3_I4P - - FUNCTION W_DATA1_RANK3_I2P(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR) - !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (I2P). - CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF !< WRITER. - CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. - INTEGER(I2P), INTENT(IN) :: X(1:,1:,1:) !< DATA VARIABLE. - LOGICAL, INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT. - LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES". - INTEGER(I4P) :: ERROR !< ERROR STATUS. - CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. - INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. - - DATA_TYPE = 'Int16' - N_COMPONENTS = SIZE(X, DIM=1) - IF (PRESENT(ONE_COMPONENT)) THEN - IF (ONE_COMPONENT) N_COMPONENTS = 1 - ENDIF - CALL SELF%W_DATA_TAG_APPENDED(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, & - IS_TUPLES=IS_TUPLES) - CALL SELF%IOFFSET_UPDATE(N_BYTE=SELF%WRITE_ON_SCRATCH_DATAARRAY(X=X)) - ERROR = SELF%ERROR - ENDFUNCTION W_DATA1_RANK3_I2P - - FUNCTION W_DATA1_RANK3_I1P(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR) - !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (I1P). - CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF !< WRITER. - CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. - INTEGER(I1P), INTENT(IN) :: X(1:,1:,1:) !< DATA VARIABLE. - LOGICAL, INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT. - LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES". - INTEGER(I4P) :: ERROR !< ERROR STATUS. - CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. - INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. - - DATA_TYPE = 'Int8' - N_COMPONENTS = SIZE(X, DIM=1) - IF (PRESENT(ONE_COMPONENT)) THEN - IF (ONE_COMPONENT) N_COMPONENTS = 1 - ENDIF - CALL SELF%W_DATA_TAG_APPENDED(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, & - IS_TUPLES=IS_TUPLES) - CALL SELF%IOFFSET_UPDATE(N_BYTE=SELF%WRITE_ON_SCRATCH_DATAARRAY(X=X)) - ERROR = SELF%ERROR - ENDFUNCTION W_DATA1_RANK3_I1P - - FUNCTION W_DATA1_RANK4_R8P(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR) - !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (R8P). - CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF !< WRITER. - CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. - REAL(R8P), INTENT(IN) :: X(1:,1:,1:,1:) !< DATA VARIABLE. - LOGICAL, INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT. - LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES". - INTEGER(I4P) :: ERROR !< ERROR STATUS. - CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. - INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. - - DATA_TYPE = 'Float64' - N_COMPONENTS = SIZE(X, DIM=1) - IF (PRESENT(ONE_COMPONENT)) THEN - IF (ONE_COMPONENT) N_COMPONENTS = 1 - ENDIF - CALL SELF%W_DATA_TAG_APPENDED(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, & - IS_TUPLES=IS_TUPLES) - CALL SELF%IOFFSET_UPDATE(N_BYTE=SELF%WRITE_ON_SCRATCH_DATAARRAY(X=X)) - ERROR = SELF%ERROR - ENDFUNCTION W_DATA1_RANK4_R8P - - FUNCTION W_DATA1_RANK4_R4P(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR) - !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (R4P). - CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF !< WRITER. - CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. - REAL(R4P), INTENT(IN) :: X(1:,1:,1:,1:) !< DATA VARIABLE. - LOGICAL, INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT. - LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES". - INTEGER(I4P) :: ERROR !< ERROR STATUS. - CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. - INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. - - DATA_TYPE = 'Float32' - N_COMPONENTS = SIZE(X, DIM=1) - IF (PRESENT(ONE_COMPONENT)) THEN - IF (ONE_COMPONENT) N_COMPONENTS = 1 - ENDIF - CALL SELF%W_DATA_TAG_APPENDED(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, & - IS_TUPLES=IS_TUPLES) - CALL SELF%IOFFSET_UPDATE(N_BYTE=SELF%WRITE_ON_SCRATCH_DATAARRAY(X=X)) - ERROR = SELF%ERROR - ENDFUNCTION W_DATA1_RANK4_R4P - - FUNCTION W_DATA1_RANK4_I8P(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR) - !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (I8P). - CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF !< WRITER. - CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. - INTEGER(I8P), INTENT(IN) :: X(1:,1:,1:,1:) !< DATA VARIABLE. - LOGICAL, INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT. - LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES". - INTEGER(I4P) :: ERROR !< ERROR STATUS. - CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. - INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. - - DATA_TYPE = 'Int64' - N_COMPONENTS = SIZE(X, DIM=1) - IF (PRESENT(ONE_COMPONENT)) THEN - IF (ONE_COMPONENT) N_COMPONENTS = 1 - ENDIF - CALL SELF%W_DATA_TAG_APPENDED(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, & - IS_TUPLES=IS_TUPLES) - CALL SELF%IOFFSET_UPDATE(N_BYTE=SELF%WRITE_ON_SCRATCH_DATAARRAY(X=X)) - ERROR = SELF%ERROR - ENDFUNCTION W_DATA1_RANK4_I8P - - FUNCTION W_DATA1_RANK4_I4P(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR) - !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (I4P). - CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF !< WRITER. - CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. - INTEGER(I4P), INTENT(IN) :: X(1:,1:,1:,1:) !< DATA VARIABLE. - LOGICAL, INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT. - LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES". - INTEGER(I4P) :: ERROR !< ERROR STATUS. - CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. - INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. - - DATA_TYPE = 'Int32' - N_COMPONENTS = SIZE(X, DIM=1) - IF (PRESENT(ONE_COMPONENT)) THEN - IF (ONE_COMPONENT) N_COMPONENTS = 1 - ENDIF - CALL SELF%W_DATA_TAG_APPENDED(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, & - IS_TUPLES=IS_TUPLES) - CALL SELF%IOFFSET_UPDATE(N_BYTE=SELF%WRITE_ON_SCRATCH_DATAARRAY(X=X)) - ERROR = SELF%ERROR - ENDFUNCTION W_DATA1_RANK4_I4P - - FUNCTION W_DATA1_RANK4_I2P(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR) - !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (I2P). - CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF !< WRITER. - CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. - INTEGER(I2P), INTENT(IN) :: X(1:,1:,1:,1:) !< DATA VARIABLE. - LOGICAL, INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT. - LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES". - INTEGER(I4P) :: ERROR !< ERROR STATUS. - CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. - INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. - - DATA_TYPE = 'Int16' - N_COMPONENTS = SIZE(X, DIM=1) - IF (PRESENT(ONE_COMPONENT)) THEN - IF (ONE_COMPONENT) N_COMPONENTS = 1 - ENDIF - CALL SELF%W_DATA_TAG_APPENDED(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, & - IS_TUPLES=IS_TUPLES) - CALL SELF%IOFFSET_UPDATE(N_BYTE=SELF%WRITE_ON_SCRATCH_DATAARRAY(X=X)) - ERROR = SELF%ERROR - ENDFUNCTION W_DATA1_RANK4_I2P - - FUNCTION W_DATA1_RANK4_I1P(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR) - !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (I1P). - CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF !< WRITER. - CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. - INTEGER(I1P), INTENT(IN) :: X(1:,1:,1:,1:) !< DATA VARIABLE. - LOGICAL, INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT. - LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES". - INTEGER(I4P) :: ERROR !< ERROR STATUS. - CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. - INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. - - DATA_TYPE = 'Int8' - N_COMPONENTS = SIZE(X, DIM=1) - IF (PRESENT(ONE_COMPONENT)) THEN - IF (ONE_COMPONENT) N_COMPONENTS = 1 - ENDIF - CALL SELF%W_DATA_TAG_APPENDED(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, & - IS_TUPLES=IS_TUPLES) - CALL SELF%IOFFSET_UPDATE(N_BYTE=SELF%WRITE_ON_SCRATCH_DATAARRAY(X=X)) - ERROR = SELF%ERROR - ENDFUNCTION W_DATA1_RANK4_I1P - - FUNCTION W_DATA3_RANK1_R8P(SELF, DATA_NAME, X, Y, Z, IS_TUPLES) RESULT(ERROR) - !< WRITE `<DATAARRAY... NumberOfComponents="3"...>...</DATAARRAY>` TAG (R8P). - CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF !< WRITER. - CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. - REAL(R8P), INTENT(IN) :: X(1:) !< X COMPONENT OF DATA VARIABLE. - REAL(R8P), INTENT(IN) :: Y(1:) !< Y COMPONENT OF DATA VARIABLE. - REAL(R8P), INTENT(IN) :: Z(1:) !< Z COMPONENT OF DATA VARIABLE. - LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD "NUMBEROFCOMPONENTS" ATTRIBUTE. - INTEGER(I4P) :: ERROR !< ERROR STATUS. - CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. - INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. - - DATA_TYPE = 'Float64' - N_COMPONENTS = 3 - CALL SELF%W_DATA_TAG_APPENDED(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, & - IS_TUPLES=IS_TUPLES) - CALL SELF%IOFFSET_UPDATE(N_BYTE=SELF%WRITE_ON_SCRATCH_DATAARRAY(X=X, Y=Y, Z=Z)) - ERROR = SELF%ERROR - ENDFUNCTION W_DATA3_RANK1_R8P + ENDFUNCTION W_DATA3_RANK1_R8P FUNCTION W_DATA3_RANK1_R4P(SELF, DATA_NAME, X, Y, Z, IS_TUPLES) RESULT(ERROR) !< WRITE `<DATAARRAY... NumberOfComponents="3"...>...</DATAARRAY>` TAG (R4P). @@ -15829,1976 +11423,312 @@ FUNCTION W_DATA3_RANK1_I1P(SELF, DATA_NAME, X, Y, Z, IS_TUPLES) RESULT(ERROR) ERROR = SELF%ERROR ENDFUNCTION W_DATA3_RANK1_I1P - FUNCTION W_DATA3_RANK3_R8P(SELF, DATA_NAME, X, Y, Z, IS_TUPLES) RESULT(ERROR) - !< WRITE `<DATAARRAY... NumberOfComponents="3"...>...</DATAARRAY>` TAG (R8P). - CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF !< WRITER. - CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. - REAL(R8P), INTENT(IN) :: X(1:,1:,1:) !< X COMPONENT OF DATA VARIABLE. - REAL(R8P), INTENT(IN) :: Y(1:,1:,1:) !< Y COMPONENT OF DATA VARIABLE. - REAL(R8P), INTENT(IN) :: Z(1:,1:,1:) !< Z COMPONENT OF DATA VARIABLE. - LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES". - INTEGER(I4P) :: ERROR !< ERROR STATUS. - CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. - INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. + SUBROUTINE W_DATA_APPENDED(SELF) + !< DO NOTHING, ASCII DATA CANNOT BE APPENDED. + CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF !< WRITER. + TYPE(STRING) :: TAG_ATTRIBUTES !< TAG ATTRIBUTES. + INTEGER(I4P) :: N_BYTE !< BYTES COUNT. + CHARACTER(LEN=2) :: DATAARRAY_TYPE !< DATAARRAY TYPE = R8,R4,I8,I4,I2,I1. + INTEGER(I4P) :: DATAARRAY_DIM !< DATAARRAY DIMENSION. + REAL(R8P), ALLOCATABLE :: DATAARRAY_R8P(:) !< DATAARRAY BUFFER OF R8P. + REAL(R4P), ALLOCATABLE :: DATAARRAY_R4P(:) !< DATAARRAY BUFFER OF R4P. + INTEGER(I8P), ALLOCATABLE :: DATAARRAY_I8P(:) !< DATAARRAY BUFFER OF I8P. + INTEGER(I4P), ALLOCATABLE :: DATAARRAY_I4P(:) !< DATAARRAY BUFFER OF I4P. + INTEGER(I2P), ALLOCATABLE :: DATAARRAY_I2P(:) !< DATAARRAY BUFFER OF I2P. + INTEGER(I1P), ALLOCATABLE :: DATAARRAY_I1P(:) !< DATAARRAY BUFFER OF I1P. - DATA_TYPE = 'Float64' - N_COMPONENTS = 3 - CALL SELF%W_DATA_TAG_APPENDED(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, & - IS_TUPLES=IS_TUPLES) - CALL SELF%IOFFSET_UPDATE(N_BYTE=SELF%WRITE_ON_SCRATCH_DATAARRAY(X=X, Y=Y, Z=Z)) - ERROR = SELF%ERROR - ENDFUNCTION W_DATA3_RANK3_R8P + CALL SELF%WRITE_START_TAG(NAME='AppendedData', ATTRIBUTES='encoding="'//SELF%ENCODING%CHARS()//'"') + WRITE(UNIT=SELF%XML, IOSTAT=SELF%ERROR)'_' + ENDFILE(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR) + REWIND(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR) + DO + CALL READ_DATAARRAY_FROM_SCRATCH + IF (SELF%ERROR==0) CALL W_DATA_ON_XML + IF (IS_IOSTAT_END(SELF%ERROR)) EXIT + ENDDO + CLOSE(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR) + WRITE(UNIT=SELF%XML, IOSTAT=SELF%ERROR)END_REC + CALL SELF%WRITE_END_TAG(NAME='AppendedData') + CONTAINS + SUBROUTINE READ_DATAARRAY_FROM_SCRATCH + !< READ THE CURRENT DATAARAY FROM SCRATCH FILE. - FUNCTION W_DATA3_RANK3_R4P(SELF, DATA_NAME, X, Y, Z, IS_TUPLES) RESULT(ERROR) - !< WRITE `<DATAARRAY... NumberOfComponents="3"...>...</DATAARRAY>` TAG (R4P). - CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF !< WRITER. - CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. - REAL(R4P), INTENT(IN) :: X(1:,1:,1:) !< X COMPONENT OF DATA VARIABLE. - REAL(R4P), INTENT(IN) :: Y(1:,1:,1:) !< Y COMPONENT OF DATA VARIABLE. - REAL(R4P), INTENT(IN) :: Z(1:,1:,1:) !< Z COMPONENT OF DATA VARIABLE. - LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES". - INTEGER(I4P) :: ERROR !< ERROR STATUS. - CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. - INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. + READ(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR, END=10)N_BYTE, DATAARRAY_TYPE, DATAARRAY_DIM + SELECT CASE(DATAARRAY_TYPE) + CASE('R8') + IF (ALLOCATED(DATAARRAY_R8P)) DEALLOCATE(DATAARRAY_R8P) ; ALLOCATE(DATAARRAY_R8P(1:DATAARRAY_DIM)) + READ(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)DATAARRAY_R8P + CASE('R4') + IF (ALLOCATED(DATAARRAY_R4P)) DEALLOCATE(DATAARRAY_R4P) ; ALLOCATE(DATAARRAY_R4P(1:DATAARRAY_DIM)) + READ(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)DATAARRAY_R4P + CASE('I8') + IF (ALLOCATED(DATAARRAY_I8P)) DEALLOCATE(DATAARRAY_I8P) ; ALLOCATE(DATAARRAY_I8P(1:DATAARRAY_DIM)) + READ(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)DATAARRAY_I8P + CASE('I4') + IF (ALLOCATED(DATAARRAY_I4P)) DEALLOCATE(DATAARRAY_I4P) ; ALLOCATE(DATAARRAY_I4P(1:DATAARRAY_DIM)) + READ(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)DATAARRAY_I4P + CASE('I2') + IF (ALLOCATED(DATAARRAY_I2P)) DEALLOCATE(DATAARRAY_I2P) ; ALLOCATE(DATAARRAY_I2P(1:DATAARRAY_DIM)) + READ(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)DATAARRAY_I2P + CASE('I1') + IF (ALLOCATED(DATAARRAY_I1P)) DEALLOCATE(DATAARRAY_I1P) ; ALLOCATE(DATAARRAY_I1P(1:DATAARRAY_DIM)) + READ(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)DATAARRAY_I1P + CASE DEFAULT + SELF%ERROR = 1 + WRITE (STDERR,'(A)')' ERROR: BAD DATAARRAY_TYPE = '//DATAARRAY_TYPE + WRITE (STDERR,'(A)')' BYTES = '//TRIM(STR(N=N_BYTE)) + WRITE (STDERR,'(A)')' DATAARRAY DIMENSION = '//TRIM(STR(N=DATAARRAY_DIM)) + ENDSELECT + 10 RETURN + ENDSUBROUTINE READ_DATAARRAY_FROM_SCRATCH - DATA_TYPE = 'Float32' - N_COMPONENTS = 3 - CALL SELF%W_DATA_TAG_APPENDED(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, & - IS_TUPLES=IS_TUPLES) - CALL SELF%IOFFSET_UPDATE(N_BYTE=SELF%WRITE_ON_SCRATCH_DATAARRAY(X=X, Y=Y, Z=Z)) - ERROR = SELF%ERROR - ENDFUNCTION W_DATA3_RANK3_R4P + SUBROUTINE W_DATA_ON_XML + !< WRITE THE CURRENT DATAARAY ON XML FILE. + CHARACTER(LEN=:), ALLOCATABLE :: CODE !< DATAARRAY ENCODED WITH BASE64 CODEC. - FUNCTION W_DATA3_RANK3_I8P(SELF, DATA_NAME, X, Y, Z, IS_TUPLES) RESULT(ERROR) - !< WRITE `<DATAARRAY... NumberOfComponents="3"...>...</DATAARRAY>` TAG (I8P). - CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF !< WRITER. - CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. - INTEGER(I8P), INTENT(IN) :: X(1:,1:,1:) !< X COMPONENT OF DATA VARIABLE. - INTEGER(I8P), INTENT(IN) :: Y(1:,1:,1:) !< Y COMPONENT OF DATA VARIABLE. - INTEGER(I8P), INTENT(IN) :: Z(1:,1:,1:) !< Z COMPONENT OF DATA VARIABLE. - LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES". - INTEGER(I4P) :: ERROR !< ERROR STATUS. - CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. - INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. - - DATA_TYPE = 'Int64' - N_COMPONENTS = 3 - CALL SELF%W_DATA_TAG_APPENDED(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, & - IS_TUPLES=IS_TUPLES) - CALL SELF%IOFFSET_UPDATE(N_BYTE=SELF%WRITE_ON_SCRATCH_DATAARRAY(X=X, Y=Y, Z=Z)) - ERROR = SELF%ERROR - ENDFUNCTION W_DATA3_RANK3_I8P - - FUNCTION W_DATA3_RANK3_I4P(SELF, DATA_NAME, X, Y, Z, IS_TUPLES) RESULT(ERROR) - !< WRITE `<DATAARRAY... NumberOfComponents="3"...>...</DATAARRAY>` TAG (I4P). - CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF !< WRITER. - CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. - INTEGER(I4P), INTENT(IN) :: X(1:,1:,1:) !< X COMPONENT OF DATA VARIABLE. - INTEGER(I4P), INTENT(IN) :: Y(1:,1:,1:) !< Y COMPONENT OF DATA VARIABLE. - INTEGER(I4P), INTENT(IN) :: Z(1:,1:,1:) !< Z COMPONENT OF DATA VARIABLE. - LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES". - INTEGER(I4P) :: ERROR !< ERROR STATUS. - CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. - INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. - - DATA_TYPE = 'Int32' - N_COMPONENTS = 3 - CALL SELF%W_DATA_TAG_APPENDED(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, & - IS_TUPLES=IS_TUPLES) - CALL SELF%IOFFSET_UPDATE(N_BYTE=SELF%WRITE_ON_SCRATCH_DATAARRAY(X=X, Y=Y, Z=Z)) - ERROR = SELF%ERROR - ENDFUNCTION W_DATA3_RANK3_I4P - - FUNCTION W_DATA3_RANK3_I2P(SELF, DATA_NAME, X, Y, Z, IS_TUPLES) RESULT(ERROR) - !< WRITE `<DATAARRAY... NumberOfComponents="3"...>...</DATAARRAY>` TAG (I2P). - CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF !< WRITER. - CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. - INTEGER(I2P), INTENT(IN) :: X(1:,1:,1:) !< X COMPONENT OF DATA VARIABLE. - INTEGER(I2P), INTENT(IN) :: Y(1:,1:,1:) !< Y COMPONENT OF DATA VARIABLE. - INTEGER(I2P), INTENT(IN) :: Z(1:,1:,1:) !< Z COMPONENT OF DATA VARIABLE. - LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES". - INTEGER(I4P) :: ERROR !< ERROR STATUS. - CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. - INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. - - DATA_TYPE = 'Int16' - N_COMPONENTS = 3 - CALL SELF%W_DATA_TAG_APPENDED(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, & - IS_TUPLES=IS_TUPLES) - CALL SELF%IOFFSET_UPDATE(N_BYTE=SELF%WRITE_ON_SCRATCH_DATAARRAY(X=X, Y=Y, Z=Z)) - ERROR = SELF%ERROR - ENDFUNCTION W_DATA3_RANK3_I2P - - FUNCTION W_DATA3_RANK3_I1P(SELF, DATA_NAME, X, Y, Z, IS_TUPLES) RESULT(ERROR) - !< WRITE `<DATAARRAY... NumberOfComponents="3"...>...</DATAARRAY>` TAG (I1P). - CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF !< WRITER. - CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. - INTEGER(I1P), INTENT(IN) :: X(1:,1:,1:) !< X COMPONENT OF DATA VARIABLE. - INTEGER(I1P), INTENT(IN) :: Y(1:,1:,1:) !< Y COMPONENT OF DATA VARIABLE. - INTEGER(I1P), INTENT(IN) :: Z(1:,1:,1:) !< Z COMPONENT OF DATA VARIABLE. - LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES". - INTEGER(I4P) :: ERROR !< ERROR STATUS. - CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. - INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. - - DATA_TYPE = 'Int8' - N_COMPONENTS = 3 - CALL SELF%W_DATA_TAG_APPENDED(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, & - IS_TUPLES=IS_TUPLES) - CALL SELF%IOFFSET_UPDATE(N_BYTE=SELF%WRITE_ON_SCRATCH_DATAARRAY(X=X, Y=Y, Z=Z)) - ERROR = SELF%ERROR - ENDFUNCTION W_DATA3_RANK3_I1P - - FUNCTION W_DATA6_RANK1_R8P(SELF, DATA_NAME, U, V, W, X, Y, Z, IS_TUPLES) RESULT(ERROR) - !< WRITE `<DATAARRAY... NumberOfComponents="3"...>...</DATAARRAY>` TAG (R8P). - CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF !< WRITER. - CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. - REAL(R8P), INTENT(IN) :: U(1:) !< U COMPONENT OF DATA VARIABLE. - REAL(R8P), INTENT(IN) :: V(1:) !< V COMPONENT OF DATA VARIABLE. - REAL(R8P), INTENT(IN) :: W(1:) !< W COMPONENT OF DATA VARIABLE. - REAL(R8P), INTENT(IN) :: X(1:) !< X COMPONENT OF DATA VARIABLE. - REAL(R8P), INTENT(IN) :: Y(1:) !< Y COMPONENT OF DATA VARIABLE. - REAL(R8P), INTENT(IN) :: Z(1:) !< Z COMPONENT OF DATA VARIABLE. - LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD "NUMBEROFCOMPONENTS" ATTRIBUTE. - INTEGER(I4P) :: ERROR !< ERROR STATUS. - CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. - INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. - - DATA_TYPE = 'Float64' - N_COMPONENTS = 6 - CALL SELF%W_DATA_TAG_APPENDED(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, & - IS_TUPLES=IS_TUPLES) - CALL SELF%IOFFSET_UPDATE(N_BYTE=SELF%WRITE_ON_SCRATCH_DATAARRAY(U=U, V=V, W=W, X=X, Y=Y, Z=Z)) - ERROR = SELF%ERROR - ENDFUNCTION W_DATA6_RANK1_R8P - - FUNCTION W_DATA6_RANK1_R4P(SELF, DATA_NAME, U, V, W, X, Y, Z, IS_TUPLES) RESULT(ERROR) - !< WRITE `<DATAARRAY... NumberOfComponents="3"...>...</DATAARRAY>` TAG (R4P). - CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF !< WRITER. - CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. - REAL(R4P), INTENT(IN) :: U(1:) !< U COMPONENT OF DATA VARIABLE. - REAL(R4P), INTENT(IN) :: V(1:) !< V COMPONENT OF DATA VARIABLE. - REAL(R4P), INTENT(IN) :: W(1:) !< W COMPONENT OF DATA VARIABLE. - REAL(R4P), INTENT(IN) :: X(1:) !< X COMPONENT OF DATA VARIABLE. - REAL(R4P), INTENT(IN) :: Y(1:) !< Y COMPONENT OF DATA VARIABLE. - REAL(R4P), INTENT(IN) :: Z(1:) !< Z COMPONENT OF DATA VARIABLE. - LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES". - INTEGER(I4P) :: ERROR !< ERROR STATUS. - CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. - INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. - - DATA_TYPE = 'Float32' - N_COMPONENTS = 6 - CALL SELF%W_DATA_TAG_APPENDED(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, & - IS_TUPLES=IS_TUPLES) - CALL SELF%IOFFSET_UPDATE(N_BYTE=SELF%WRITE_ON_SCRATCH_DATAARRAY(U=U, V=V, W=W, X=X, Y=Y, Z=Z)) - ERROR = SELF%ERROR - ENDFUNCTION W_DATA6_RANK1_R4P - - FUNCTION W_DATA6_RANK1_I8P(SELF, DATA_NAME, U, V, W, X, Y, Z, IS_TUPLES) RESULT(ERROR) - !< WRITE `<DATAARRAY... NumberOfComponents="6"...>...</DATAARRAY>` TAG (I8P). - CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF !< WRITER. - CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. - INTEGER(I8P), INTENT(IN) :: U(1:) !< U COMPONENT OF DATA VARIABLE. - INTEGER(I8P), INTENT(IN) :: V(1:) !< V COMPONENT OF DATA VARIABLE. - INTEGER(I8P), INTENT(IN) :: W(1:) !< W COMPONENT OF DATA VARIABLE. - INTEGER(I8P), INTENT(IN) :: X(1:) !< X COMPONENT OF DATA VARIABLE. - INTEGER(I8P), INTENT(IN) :: Y(1:) !< Y COMPONENT OF DATA VARIABLE. - INTEGER(I8P), INTENT(IN) :: Z(1:) !< Z COMPONENT OF DATA VARIABLE. - LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES". - INTEGER(I4P) :: ERROR !< ERROR STATUS. - CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. - INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. - - DATA_TYPE = 'Int64' - N_COMPONENTS = 6 - CALL SELF%W_DATA_TAG_APPENDED(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, & - IS_TUPLES=IS_TUPLES) - CALL SELF%IOFFSET_UPDATE(N_BYTE=SELF%WRITE_ON_SCRATCH_DATAARRAY(U=U, V=V, W=W, X=X, Y=Y, Z=Z)) - ERROR = SELF%ERROR - ENDFUNCTION W_DATA6_RANK1_I8P - - FUNCTION W_DATA6_RANK1_I4P(SELF, DATA_NAME, U, V, W, X, Y, Z, IS_TUPLES) RESULT(ERROR) - !< WRITE `<DATAARRAY... NumberOfComponents="6"...>...</DATAARRAY>` TAG (I4P). - CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF !< WRITER. - CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. - INTEGER(I4P), INTENT(IN) :: U(1:) !< U COMPONENT OF DATA VARIABLE. - INTEGER(I4P), INTENT(IN) :: V(1:) !< V COMPONENT OF DATA VARIABLE. - INTEGER(I4P), INTENT(IN) :: W(1:) !< W COMPONENT OF DATA VARIABLE. - INTEGER(I4P), INTENT(IN) :: X(1:) !< X COMPONENT OF DATA VARIABLE. - INTEGER(I4P), INTENT(IN) :: Y(1:) !< Y COMPONENT OF DATA VARIABLE. - INTEGER(I4P), INTENT(IN) :: Z(1:) !< Z COMPONENT OF DATA VARIABLE. - LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES". - INTEGER(I4P) :: ERROR !< ERROR STATUS. - CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. - INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. - - DATA_TYPE = 'Int32' - N_COMPONENTS = 6 - CALL SELF%W_DATA_TAG_APPENDED(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, & - IS_TUPLES=IS_TUPLES) - CALL SELF%IOFFSET_UPDATE(N_BYTE=SELF%WRITE_ON_SCRATCH_DATAARRAY(U=U, V=V, W=W, X=X, Y=Y, Z=Z)) - ERROR = SELF%ERROR - ENDFUNCTION W_DATA6_RANK1_I4P - - FUNCTION W_DATA6_RANK1_I2P(SELF, DATA_NAME, U, V, W, X, Y, Z, IS_TUPLES) RESULT(ERROR) - !< WRITE `<DATAARRAY... NumberOfComponents="6"...>...</DATAARRAY>` TAG (I2P). - CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF !< WRITER. - CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. - INTEGER(I2P), INTENT(IN) :: U(1:) !< U COMPONENT OF DATA VARIABLE. - INTEGER(I2P), INTENT(IN) :: V(1:) !< V COMPONENT OF DATA VARIABLE. - INTEGER(I2P), INTENT(IN) :: W(1:) !< W COMPONENT OF DATA VARIABLE. - INTEGER(I2P), INTENT(IN) :: X(1:) !< X COMPONENT OF DATA VARIABLE. - INTEGER(I2P), INTENT(IN) :: Y(1:) !< Y COMPONENT OF DATA VARIABLE. - INTEGER(I2P), INTENT(IN) :: Z(1:) !< Z COMPONENT OF DATA VARIABLE. - LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES". - INTEGER(I4P) :: ERROR !< ERROR STATUS. - CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. - INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. - - DATA_TYPE = 'Int16' - N_COMPONENTS = 6 - CALL SELF%W_DATA_TAG_APPENDED(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, & - IS_TUPLES=IS_TUPLES) - CALL SELF%IOFFSET_UPDATE(N_BYTE=SELF%WRITE_ON_SCRATCH_DATAARRAY(U=U, V=V, W=W, X=X, Y=Y, Z=Z)) - ERROR = SELF%ERROR - ENDFUNCTION W_DATA6_RANK1_I2P - - FUNCTION W_DATA6_RANK1_I1P(SELF, DATA_NAME, U, V, W, X, Y, Z, IS_TUPLES) RESULT(ERROR) - !< WRITE `<DATAARRAY... NumberOfComponents="6"...>...</DATAARRAY>` TAG (I1P). - CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF !< WRITER. - CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. - INTEGER(I1P), INTENT(IN) :: U(1:) !< U COMPONENT OF DATA VARIABLE. - INTEGER(I1P), INTENT(IN) :: V(1:) !< V COMPONENT OF DATA VARIABLE. - INTEGER(I1P), INTENT(IN) :: W(1:) !< W COMPONENT OF DATA VARIABLE. - INTEGER(I1P), INTENT(IN) :: X(1:) !< X COMPONENT OF DATA VARIABLE. - INTEGER(I1P), INTENT(IN) :: Y(1:) !< Y COMPONENT OF DATA VARIABLE. - INTEGER(I1P), INTENT(IN) :: Z(1:) !< Z COMPONENT OF DATA VARIABLE. - LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES". - INTEGER(I4P) :: ERROR !< ERROR STATUS. - CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. - INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. - - DATA_TYPE = 'Int8' - N_COMPONENTS = 6 - CALL SELF%W_DATA_TAG_APPENDED(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, & - IS_TUPLES=IS_TUPLES) - CALL SELF%IOFFSET_UPDATE(N_BYTE=SELF%WRITE_ON_SCRATCH_DATAARRAY(U=U, V=V, W=W, X=X, Y=Y, Z=Z)) - ERROR = SELF%ERROR - ENDFUNCTION W_DATA6_RANK1_I1P - - FUNCTION W_DATA6_RANK3_R8P(SELF, DATA_NAME, U, V, W, X, Y, Z, IS_TUPLES) RESULT(ERROR) - !< WRITE `<DATAARRAY... NumberOfComponents="6"...>...</DATAARRAY>` TAG (R8P). - CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF !< WRITER. - CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. - REAL(R8P), INTENT(IN) :: U(1:,1:,1:) !< U COMPONENT OF DATA VARIABLE. - REAL(R8P), INTENT(IN) :: V(1:,1:,1:) !< V COMPONENT OF DATA VARIABLE. - REAL(R8P), INTENT(IN) :: W(1:,1:,1:) !< W COMPONENT OF DATA VARIABLE. - REAL(R8P), INTENT(IN) :: X(1:,1:,1:) !< X COMPONENT OF DATA VARIABLE. - REAL(R8P), INTENT(IN) :: Y(1:,1:,1:) !< Y COMPONENT OF DATA VARIABLE. - REAL(R8P), INTENT(IN) :: Z(1:,1:,1:) !< Z COMPONENT OF DATA VARIABLE. - LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES". - INTEGER(I4P) :: ERROR !< ERROR STATUS. - CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. - INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. - - DATA_TYPE = 'Float64' - N_COMPONENTS = 6 - CALL SELF%W_DATA_TAG_APPENDED(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, & - IS_TUPLES=IS_TUPLES) - CALL SELF%IOFFSET_UPDATE(N_BYTE=SELF%WRITE_ON_SCRATCH_DATAARRAY(U=U, V=V, W=W, X=X, Y=Y, Z=Z)) - ERROR = SELF%ERROR - ENDFUNCTION W_DATA6_RANK3_R8P - - FUNCTION W_DATA6_RANK3_R4P(SELF, DATA_NAME, U, V, W, X, Y, Z, IS_TUPLES) RESULT(ERROR) - !< WRITE `<DATAARRAY... NumberOfComponents="6"...>...</DATAARRAY>` TAG (R4P). - CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF !< WRITER. - CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. - REAL(R4P), INTENT(IN) :: U(1:,1:,1:) !< U COMPONENT OF DATA VARIABLE. - REAL(R4P), INTENT(IN) :: V(1:,1:,1:) !< V COMPONENT OF DATA VARIABLE. - REAL(R4P), INTENT(IN) :: W(1:,1:,1:) !< W COMPONENT OF DATA VARIABLE. - REAL(R4P), INTENT(IN) :: X(1:,1:,1:) !< X COMPONENT OF DATA VARIABLE. - REAL(R4P), INTENT(IN) :: Y(1:,1:,1:) !< Y COMPONENT OF DATA VARIABLE. - REAL(R4P), INTENT(IN) :: Z(1:,1:,1:) !< Z COMPONENT OF DATA VARIABLE. - LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES". - INTEGER(I4P) :: ERROR !< ERROR STATUS. - CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. - INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. - - DATA_TYPE = 'Float32' - N_COMPONENTS = 6 - CALL SELF%W_DATA_TAG_APPENDED(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, & - IS_TUPLES=IS_TUPLES) - CALL SELF%IOFFSET_UPDATE(N_BYTE=SELF%WRITE_ON_SCRATCH_DATAARRAY(U=U, V=V, W=W, X=X, Y=Y, Z=Z)) - ERROR = SELF%ERROR - ENDFUNCTION W_DATA6_RANK3_R4P - - FUNCTION W_DATA6_RANK3_I8P(SELF, DATA_NAME, U, V, W, X, Y, Z, IS_TUPLES) RESULT(ERROR) - !< WRITE `<DATAARRAY... NumberOfComponents="3"...>...</DATAARRAY>` TAG (I8P). - CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF !< WRITER. - CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. - INTEGER(I8P), INTENT(IN) :: U(1:,1:,1:) !< U COMPONENT OF DATA VARIABLE. - INTEGER(I8P), INTENT(IN) :: V(1:,1:,1:) !< V COMPONENT OF DATA VARIABLE. - INTEGER(I8P), INTENT(IN) :: W(1:,1:,1:) !< W COMPONENT OF DATA VARIABLE. - INTEGER(I8P), INTENT(IN) :: X(1:,1:,1:) !< X COMPONENT OF DATA VARIABLE. - INTEGER(I8P), INTENT(IN) :: Y(1:,1:,1:) !< Y COMPONENT OF DATA VARIABLE. - INTEGER(I8P), INTENT(IN) :: Z(1:,1:,1:) !< Z COMPONENT OF DATA VARIABLE. - LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES". - INTEGER(I4P) :: ERROR !< ERROR STATUS. - CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. - INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. - - DATA_TYPE = 'Int64' - N_COMPONENTS = 6 - CALL SELF%W_DATA_TAG_APPENDED(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, & - IS_TUPLES=IS_TUPLES) - CALL SELF%IOFFSET_UPDATE(N_BYTE=SELF%WRITE_ON_SCRATCH_DATAARRAY(U=U, V=V, W=W, X=X, Y=Y, Z=Z)) - ERROR = SELF%ERROR - ENDFUNCTION W_DATA6_RANK3_I8P - - FUNCTION W_DATA6_RANK3_I4P(SELF, DATA_NAME, U, V, W, X, Y, Z, IS_TUPLES) RESULT(ERROR) - !< WRITE `<DATAARRAY... NumberOfComponents="6"...>...</DATAARRAY>` TAG (I4P). - CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF !< WRITER. - CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. - INTEGER(I4P), INTENT(IN) :: U(1:,1:,1:) !< U COMPONENT OF DATA VARIABLE. - INTEGER(I4P), INTENT(IN) :: V(1:,1:,1:) !< V COMPONENT OF DATA VARIABLE. - INTEGER(I4P), INTENT(IN) :: W(1:,1:,1:) !< W COMPONENT OF DATA VARIABLE. - INTEGER(I4P), INTENT(IN) :: X(1:,1:,1:) !< X COMPONENT OF DATA VARIABLE. - INTEGER(I4P), INTENT(IN) :: Y(1:,1:,1:) !< Y COMPONENT OF DATA VARIABLE. - INTEGER(I4P), INTENT(IN) :: Z(1:,1:,1:) !< Z COMPONENT OF DATA VARIABLE. - LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES". - INTEGER(I4P) :: ERROR !< ERROR STATUS. - CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. - INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. - - DATA_TYPE = 'Int32' - N_COMPONENTS = 6 - CALL SELF%W_DATA_TAG_APPENDED(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, & - IS_TUPLES=IS_TUPLES) - CALL SELF%IOFFSET_UPDATE(N_BYTE=SELF%WRITE_ON_SCRATCH_DATAARRAY(U=U, V=V, W=W, X=X, Y=Y, Z=Z)) - ERROR = SELF%ERROR - ENDFUNCTION W_DATA6_RANK3_I4P - - FUNCTION W_DATA6_RANK3_I2P(SELF, DATA_NAME, U, V, W, X, Y, Z, IS_TUPLES) RESULT(ERROR) - !< WRITE `<DATAARRAY... NumberOfComponents="6"...>...</DATAARRAY>` TAG (I2P). - CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF !< WRITER. - CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. - INTEGER(I2P), INTENT(IN) :: U(1:,1:,1:) !< U COMPONENT OF DATA VARIABLE. - INTEGER(I2P), INTENT(IN) :: V(1:,1:,1:) !< V COMPONENT OF DATA VARIABLE. - INTEGER(I2P), INTENT(IN) :: W(1:,1:,1:) !< W COMPONENT OF DATA VARIABLE. - INTEGER(I2P), INTENT(IN) :: X(1:,1:,1:) !< X COMPONENT OF DATA VARIABLE. - INTEGER(I2P), INTENT(IN) :: Y(1:,1:,1:) !< Y COMPONENT OF DATA VARIABLE. - INTEGER(I2P), INTENT(IN) :: Z(1:,1:,1:) !< Z COMPONENT OF DATA VARIABLE. - LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES". - INTEGER(I4P) :: ERROR !< ERROR STATUS. - CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. - INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. - - DATA_TYPE = 'Int16' - N_COMPONENTS = 6 - CALL SELF%W_DATA_TAG_APPENDED(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, & - IS_TUPLES=IS_TUPLES) - CALL SELF%IOFFSET_UPDATE(N_BYTE=SELF%WRITE_ON_SCRATCH_DATAARRAY(U=U, V=V, W=W, X=X, Y=Y, Z=Z)) - ERROR = SELF%ERROR - ENDFUNCTION W_DATA6_RANK3_I2P - - FUNCTION W_DATA6_RANK3_I1P(SELF, DATA_NAME, U, V, W, X, Y, Z, IS_TUPLES) RESULT(ERROR) - !< WRITE `<DATAARRAY... NumberOfComponents="6"...>...</DATAARRAY>` TAG (I1P). - CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF !< WRITER. - CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. - INTEGER(I1P), INTENT(IN) :: U(1:,1:,1:) !< U COMPONENT OF DATA VARIABLE. - INTEGER(I1P), INTENT(IN) :: V(1:,1:,1:) !< V COMPONENT OF DATA VARIABLE. - INTEGER(I1P), INTENT(IN) :: W(1:,1:,1:) !< W COMPONENT OF DATA VARIABLE. - INTEGER(I1P), INTENT(IN) :: X(1:,1:,1:) !< X COMPONENT OF DATA VARIABLE. - INTEGER(I1P), INTENT(IN) :: Y(1:,1:,1:) !< Y COMPONENT OF DATA VARIABLE. - INTEGER(I1P), INTENT(IN) :: Z(1:,1:,1:) !< Z COMPONENT OF DATA VARIABLE. - LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES". - INTEGER(I4P) :: ERROR !< ERROR STATUS. - CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. - INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. - - DATA_TYPE = 'Int8' - N_COMPONENTS = 6 - CALL SELF%W_DATA_TAG_APPENDED(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, & - IS_TUPLES=IS_TUPLES) - CALL SELF%IOFFSET_UPDATE(N_BYTE=SELF%WRITE_ON_SCRATCH_DATAARRAY(U=U, V=V, W=W, X=X, Y=Y, Z=Z)) - ERROR = SELF%ERROR - ENDFUNCTION W_DATA6_RANK3_I1P - - SUBROUTINE W_DATA_APPENDED(SELF) - !< DO NOTHING, ASCII DATA CANNOT BE APPENDED. - CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF !< WRITER. - TYPE(STRING) :: TAG_ATTRIBUTES !< TAG ATTRIBUTES. - INTEGER(I4P) :: N_BYTE !< BYTES COUNT. - CHARACTER(LEN=2) :: DATAARRAY_TYPE !< DATAARRAY TYPE = R8,R4,I8,I4,I2,I1. - INTEGER(I4P) :: DATAARRAY_DIM !< DATAARRAY DIMENSION. - REAL(R8P), ALLOCATABLE :: DATAARRAY_R8P(:) !< DATAARRAY BUFFER OF R8P. - REAL(R4P), ALLOCATABLE :: DATAARRAY_R4P(:) !< DATAARRAY BUFFER OF R4P. - INTEGER(I8P), ALLOCATABLE :: DATAARRAY_I8P(:) !< DATAARRAY BUFFER OF I8P. - INTEGER(I4P), ALLOCATABLE :: DATAARRAY_I4P(:) !< DATAARRAY BUFFER OF I4P. - INTEGER(I2P), ALLOCATABLE :: DATAARRAY_I2P(:) !< DATAARRAY BUFFER OF I2P. - INTEGER(I1P), ALLOCATABLE :: DATAARRAY_I1P(:) !< DATAARRAY BUFFER OF I1P. - - CALL SELF%WRITE_START_TAG(NAME='AppendedData', ATTRIBUTES='encoding="'//SELF%ENCODING%CHARS()//'"') - WRITE(UNIT=SELF%XML, IOSTAT=SELF%ERROR)'_' - ENDFILE(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR) - REWIND(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR) - DO - CALL READ_DATAARRAY_FROM_SCRATCH - IF (SELF%ERROR==0) CALL W_DATA_ON_XML - IF (IS_IOSTAT_END(SELF%ERROR)) EXIT - ENDDO - CLOSE(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR) - WRITE(UNIT=SELF%XML, IOSTAT=SELF%ERROR)END_REC - CALL SELF%WRITE_END_TAG(NAME='AppendedData') - CONTAINS - SUBROUTINE READ_DATAARRAY_FROM_SCRATCH - !< READ THE CURRENT DATAARAY FROM SCRATCH FILE. - - READ(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR, END=10)N_BYTE, DATAARRAY_TYPE, DATAARRAY_DIM - SELECT CASE(DATAARRAY_TYPE) - CASE('R8') - IF (ALLOCATED(DATAARRAY_R8P)) DEALLOCATE(DATAARRAY_R8P) ; ALLOCATE(DATAARRAY_R8P(1:DATAARRAY_DIM)) - READ(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)DATAARRAY_R8P - CASE('R4') - IF (ALLOCATED(DATAARRAY_R4P)) DEALLOCATE(DATAARRAY_R4P) ; ALLOCATE(DATAARRAY_R4P(1:DATAARRAY_DIM)) - READ(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)DATAARRAY_R4P - CASE('I8') - IF (ALLOCATED(DATAARRAY_I8P)) DEALLOCATE(DATAARRAY_I8P) ; ALLOCATE(DATAARRAY_I8P(1:DATAARRAY_DIM)) - READ(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)DATAARRAY_I8P - CASE('I4') - IF (ALLOCATED(DATAARRAY_I4P)) DEALLOCATE(DATAARRAY_I4P) ; ALLOCATE(DATAARRAY_I4P(1:DATAARRAY_DIM)) - READ(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)DATAARRAY_I4P - CASE('I2') - IF (ALLOCATED(DATAARRAY_I2P)) DEALLOCATE(DATAARRAY_I2P) ; ALLOCATE(DATAARRAY_I2P(1:DATAARRAY_DIM)) - READ(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)DATAARRAY_I2P - CASE('I1') - IF (ALLOCATED(DATAARRAY_I1P)) DEALLOCATE(DATAARRAY_I1P) ; ALLOCATE(DATAARRAY_I1P(1:DATAARRAY_DIM)) - READ(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)DATAARRAY_I1P - CASE DEFAULT - SELF%ERROR = 1 - WRITE (STDERR,'(A)')' ERROR: BAD DATAARRAY_TYPE = '//DATAARRAY_TYPE - WRITE (STDERR,'(A)')' BYTES = '//TRIM(STR(N=N_BYTE)) - WRITE (STDERR,'(A)')' DATAARRAY DIMENSION = '//TRIM(STR(N=DATAARRAY_DIM)) - ENDSELECT - 10 RETURN - ENDSUBROUTINE READ_DATAARRAY_FROM_SCRATCH - - SUBROUTINE W_DATA_ON_XML - !< WRITE THE CURRENT DATAARAY ON XML FILE. - CHARACTER(LEN=:), ALLOCATABLE :: CODE !< DATAARRAY ENCODED WITH BASE64 CODEC. - - IF (SELF%ENCODING=='raw') THEN - SELECT CASE(DATAARRAY_TYPE) - CASE('R8') - WRITE(UNIT=SELF%XML, IOSTAT=SELF%ERROR)N_BYTE, DATAARRAY_R8P - DEALLOCATE(DATAARRAY_R8P) - CASE('R4') - WRITE(UNIT=SELF%XML, IOSTAT=SELF%ERROR)N_BYTE, DATAARRAY_R4P - DEALLOCATE(DATAARRAY_R4P) - CASE('I8') - WRITE(UNIT=SELF%XML, IOSTAT=SELF%ERROR)N_BYTE, DATAARRAY_I8P - DEALLOCATE(DATAARRAY_I8P) - CASE('I4') - WRITE(UNIT=SELF%XML, IOSTAT=SELF%ERROR)N_BYTE, DATAARRAY_I4P - DEALLOCATE(DATAARRAY_I4P) - CASE('I2') - WRITE(UNIT=SELF%XML, IOSTAT=SELF%ERROR)N_BYTE, DATAARRAY_I2P - DEALLOCATE(DATAARRAY_I2P) - CASE('I1') - WRITE(UNIT=SELF%XML, IOSTAT=SELF%ERROR)N_BYTE, DATAARRAY_I1P - DEALLOCATE(DATAARRAY_I1P) - ENDSELECT - ELSE - SELECT CASE(DATAARRAY_TYPE) - CASE('R8') - CODE = ENCODE_BINARY_DATAARRAY(X=DATAARRAY_R8P) - WRITE(UNIT=SELF%XML, IOSTAT=SELF%ERROR)CODE - CASE('R4') - CODE = ENCODE_BINARY_DATAARRAY(X=DATAARRAY_R4P) - WRITE(UNIT=SELF%XML, IOSTAT=SELF%ERROR)CODE - CASE('I8') - CODE = ENCODE_BINARY_DATAARRAY(X=DATAARRAY_I8P) - WRITE(UNIT=SELF%XML, IOSTAT=SELF%ERROR)CODE - CASE('I4') - CODE = ENCODE_BINARY_DATAARRAY(X=DATAARRAY_I4P) - WRITE(UNIT=SELF%XML, IOSTAT=SELF%ERROR)CODE - CASE('I2') - CODE = ENCODE_BINARY_DATAARRAY(X=DATAARRAY_I2P) - WRITE(UNIT=SELF%XML, IOSTAT=SELF%ERROR)CODE - CASE('I1') - CODE = ENCODE_BINARY_DATAARRAY(X=DATAARRAY_I1P) - WRITE(UNIT=SELF%XML, IOSTAT=SELF%ERROR)CODE - ENDSELECT - ENDIF - ENDSUBROUTINE W_DATA_ON_XML - ENDSUBROUTINE W_DATA_APPENDED - - ! WRITE_ON_SCRATCH_DATAARRAY METHODS - FUNCTION WRITE_ON_SCRATCH_DATAARRAY1_RANK1(SELF, X) RESULT(N_BYTE) - !< WRITE A DATAARRAY WITH 1 COMPONENTS OF RANK 1. - CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF !< WRITER. - CLASS(*), INTENT(IN) :: X(1:) !< DATA VARIABLE. - INTEGER(I4P) :: N_BYTE !< NUMBER OF BYTES - INTEGER(I4P) :: NN !< NUMBER OF ELEMENTS. - - NN = SIZE(X, DIM=1) - SELECT TYPE(X) - TYPE IS(REAL(R8P)) - N_BYTE = NN*BYR8P - WRITE(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)N_BYTE, 'R8', NN - WRITE(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)X - TYPE IS(REAL(R4P)) - N_BYTE = NN*BYR4P - WRITE(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)N_BYTE, 'R4', NN - WRITE(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)X - TYPE IS(INTEGER(I8P)) - N_BYTE = NN*BYI8P - WRITE(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)N_BYTE, 'I8', NN - WRITE(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)X - TYPE IS(INTEGER(I4P)) - N_BYTE = NN*BYI4P - WRITE(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)N_BYTE, 'I4', NN - WRITE(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)X - TYPE IS(INTEGER(I2P)) - N_BYTE = NN*BYI2P - WRITE(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)N_BYTE, 'I2', NN - WRITE(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)X - TYPE IS(INTEGER(I1P)) - N_BYTE = NN*BYI1P - WRITE(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)N_BYTE, 'I1', NN - WRITE(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)X - ENDSELECT - ENDFUNCTION WRITE_ON_SCRATCH_DATAARRAY1_RANK1 - - FUNCTION WRITE_ON_SCRATCH_DATAARRAY1_RANK2(SELF, X) RESULT(N_BYTE) - !< WRITE A DATAARRAY WITH 1 COMPONENTS OF RANK 2. - CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF !< WRITER. - CLASS(*), INTENT(IN) :: X(1:,1:) !< DATA VARIABLE. - INTEGER(I4P) :: N_BYTE !< NUMBER OF BYTES - INTEGER(I4P) :: NN !< NUMBER OF ELEMENTS. - - NN = SIZE(X, DIM=1)*SIZE(X, DIM=2) - SELECT TYPE(X) - TYPE IS(REAL(R8P)) - N_BYTE = NN*BYR8P - WRITE(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)N_BYTE, 'R8', NN - WRITE(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)X - TYPE IS(REAL(R4P)) - N_BYTE = NN*BYR4P - WRITE(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)N_BYTE, 'R4', NN - WRITE(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)X - TYPE IS(INTEGER(I8P)) - N_BYTE = NN*BYI8P - WRITE(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)N_BYTE, 'I8', NN - WRITE(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)X - TYPE IS(INTEGER(I4P)) - N_BYTE = NN*BYI4P - WRITE(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)N_BYTE, 'I4', NN - WRITE(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)X - TYPE IS(INTEGER(I2P)) - N_BYTE = NN*BYI2P - WRITE(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)N_BYTE, 'I2', NN - WRITE(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)X - TYPE IS(INTEGER(I1P)) - N_BYTE = NN*BYI1P - WRITE(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)N_BYTE, 'I1', NN - WRITE(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)X - ENDSELECT - ENDFUNCTION WRITE_ON_SCRATCH_DATAARRAY1_RANK2 - - FUNCTION WRITE_ON_SCRATCH_DATAARRAY1_RANK3(SELF, X) RESULT(N_BYTE) - !< WRITE A DATAARRAY WITH 1 COMPONENTS OF RANK 3. - CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF !< WRITER. - CLASS(*), INTENT(IN) :: X(1:,1:,1:) !< DATA VARIABLE. - INTEGER(I4P) :: N_BYTE !< NUMBER OF BYTES - INTEGER(I4P) :: NN !< NUMBER OF ELEMENTS. - - NN = SIZE(X, DIM=1)*SIZE(X, DIM=2)*SIZE(X, DIM=3) - SELECT TYPE(X) - TYPE IS(REAL(R8P)) - N_BYTE = NN*BYR8P - WRITE(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)N_BYTE, 'R8', NN - WRITE(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)X - TYPE IS(REAL(R4P)) - N_BYTE = NN*BYR4P - WRITE(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)N_BYTE, 'R4', NN - WRITE(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)X - TYPE IS(INTEGER(I8P)) - N_BYTE = NN*BYI8P - WRITE(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)N_BYTE, 'I8', NN - WRITE(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)X - TYPE IS(INTEGER(I4P)) - N_BYTE = NN*BYI4P - WRITE(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)N_BYTE, 'I4', NN - WRITE(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)X - TYPE IS(INTEGER(I2P)) - N_BYTE = NN*BYI2P - WRITE(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)N_BYTE, 'I2', NN - WRITE(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)X - TYPE IS(INTEGER(I1P)) - N_BYTE = NN*BYI1P - WRITE(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)N_BYTE, 'I1', NN - WRITE(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)X - ENDSELECT - ENDFUNCTION WRITE_ON_SCRATCH_DATAARRAY1_RANK3 - - FUNCTION WRITE_ON_SCRATCH_DATAARRAY1_RANK4(SELF, X) RESULT(N_BYTE) - !< WRITE A DATAARRAY WITH 1 COMPONENTS OF RANK 4. - CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF !< WRITER. - CLASS(*), INTENT(IN) :: X(1:,1:,1:,1:) !< DATA VARIABLE. - INTEGER(I4P) :: N_BYTE !< NUMBER OF BYTES - INTEGER(I4P) :: NN !< NUMBER OF ELEMENTS. - - NN = SIZE(X, DIM=1)*SIZE(X, DIM=2)*SIZE(X, DIM=3)*SIZE(X, DIM=4) - SELECT TYPE(X) - TYPE IS(REAL(R8P)) - N_BYTE = NN*BYR8P - WRITE(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)N_BYTE, 'R8', NN - WRITE(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)X - TYPE IS(REAL(R4P)) - N_BYTE = NN*BYR4P - WRITE(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)N_BYTE, 'R4', NN - WRITE(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)X - TYPE IS(INTEGER(I8P)) - N_BYTE = NN*BYI8P - WRITE(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)N_BYTE, 'I8', NN - WRITE(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)X - TYPE IS(INTEGER(I4P)) - N_BYTE = NN*BYI4P - WRITE(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)N_BYTE, 'I4', NN - WRITE(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)X - TYPE IS(INTEGER(I2P)) - N_BYTE = NN*BYI2P - WRITE(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)N_BYTE, 'I2', NN - WRITE(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)X - TYPE IS(INTEGER(I1P)) - N_BYTE = NN*BYI1P - WRITE(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)N_BYTE, 'I1', NN - WRITE(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)X - ENDSELECT - ENDFUNCTION WRITE_ON_SCRATCH_DATAARRAY1_RANK4 - - FUNCTION WRITE_ON_SCRATCH_DATAARRAY3_RANK1_R8P(SELF, X, Y, Z) RESULT(N_BYTE) - !< WRITE A DATAARRAY WITH 3 COMPONENTS OF RANK 1 (R8P). - CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF !< WRITER. - REAL(R8P), INTENT(IN) :: X(1:) !< X COMPONENT. - REAL(R8P), INTENT(IN) :: Y(1:) !< Y COMPONENT. - REAL(R8P), INTENT(IN) :: Z(1:) !< Z COMPONENT. - INTEGER(I4P) :: N_BYTE !< NUMBER OF BYTES - INTEGER(I4P) :: N !< COUNTER. - - N_BYTE = SELF%WRITE_ON_SCRATCH_DATAARRAY(X=[(X(N), Y(N), Z(N), N=1,SIZE(X, DIM=1))]) - ENDFUNCTION WRITE_ON_SCRATCH_DATAARRAY3_RANK1_R8P - - FUNCTION WRITE_ON_SCRATCH_DATAARRAY3_RANK1_R4P(SELF, X, Y, Z) RESULT(N_BYTE) - !< WRITE A DATAARRAY WITH 3 COMPONENTS OF RANK 1 (R4P). - CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF !< WRITER. - REAL(R4P), INTENT(IN) :: X(1:) !< X COMPONENT. - REAL(R4P), INTENT(IN) :: Y(1:) !< Y COMPONENT. - REAL(R4P), INTENT(IN) :: Z(1:) !< Z COMPONENT. - INTEGER(I4P) :: N_BYTE !< NUMBER OF BYTES - INTEGER(I4P) :: N !< COUNTER. - - N_BYTE = SELF%WRITE_ON_SCRATCH_DATAARRAY(X=[(X(N), Y(N), Z(N), N=1,SIZE(X, DIM=1))]) - ENDFUNCTION WRITE_ON_SCRATCH_DATAARRAY3_RANK1_R4P - - FUNCTION WRITE_ON_SCRATCH_DATAARRAY3_RANK1_I8P(SELF, X, Y, Z) RESULT(N_BYTE) - !< WRITE A DATAARRAY WITH 3 COMPONENTS OF RANK 1 (I8P). - CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF !< WRITER. - INTEGER(I8P), INTENT(IN) :: X(1:) !< X COMPONENT. - INTEGER(I8P), INTENT(IN) :: Y(1:) !< Y COMPONENT. - INTEGER(I8P), INTENT(IN) :: Z(1:) !< Z COMPONENT. - INTEGER(I4P) :: N_BYTE !< NUMBER OF BYTES - INTEGER(I4P) :: N !< COUNTER. - - N_BYTE = SELF%WRITE_ON_SCRATCH_DATAARRAY(X=[(X(N), Y(N), Z(N), N=1,SIZE(X, DIM=1))]) - ENDFUNCTION WRITE_ON_SCRATCH_DATAARRAY3_RANK1_I8P - - FUNCTION WRITE_ON_SCRATCH_DATAARRAY3_RANK1_I4P(SELF, X, Y, Z) RESULT(N_BYTE) - !< WRITE A DATAARRAY WITH 3 COMPONENTS OF RANK 1 (I4P). - CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF !< WRITER. - INTEGER(I4P), INTENT(IN) :: X(1:) !< X COMPONENT. - INTEGER(I4P), INTENT(IN) :: Y(1:) !< Y COMPONENT. - INTEGER(I4P), INTENT(IN) :: Z(1:) !< Z COMPONENT. - INTEGER(I4P) :: N_BYTE !< NUMBER OF BYTES - INTEGER(I4P) :: N !< COUNTER. - - N_BYTE = SELF%WRITE_ON_SCRATCH_DATAARRAY(X=[(X(N), Y(N), Z(N), N=1,SIZE(X, DIM=1))]) - ENDFUNCTION WRITE_ON_SCRATCH_DATAARRAY3_RANK1_I4P - - FUNCTION WRITE_ON_SCRATCH_DATAARRAY3_RANK1_I2P(SELF, X, Y, Z) RESULT(N_BYTE) - !< WRITE A DATAARRAY WITH 3 COMPONENTS OF RANK 1 (I2P). - CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF !< WRITER. - INTEGER(I2P), INTENT(IN) :: X(1:) !< X COMPONENT. - INTEGER(I2P), INTENT(IN) :: Y(1:) !< Y COMPONENT. - INTEGER(I2P), INTENT(IN) :: Z(1:) !< Z COMPONENT. - INTEGER(I4P) :: N_BYTE !< NUMBER OF BYTES - INTEGER(I4P) :: N !< COUNTER. - - N_BYTE = SELF%WRITE_ON_SCRATCH_DATAARRAY(X=[(X(N), Y(N), Z(N), N=1,SIZE(X, DIM=1))]) - ENDFUNCTION WRITE_ON_SCRATCH_DATAARRAY3_RANK1_I2P - - FUNCTION WRITE_ON_SCRATCH_DATAARRAY3_RANK1_I1P(SELF, X, Y, Z) RESULT(N_BYTE) - !< WRITE A DATAARRAY WITH 3 COMPONENTS OF RANK 1 (I1P). - CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF !< WRITER. - INTEGER(I1P), INTENT(IN) :: X(1:) !< X COMPONENT. - INTEGER(I1P), INTENT(IN) :: Y(1:) !< Y COMPONENT. - INTEGER(I1P), INTENT(IN) :: Z(1:) !< Z COMPONENT. - INTEGER(I4P) :: N_BYTE !< NUMBER OF BYTES - INTEGER(I4P) :: N !< COUNTER. - - N_BYTE = SELF%WRITE_ON_SCRATCH_DATAARRAY(X=[(X(N), Y(N), Z(N), N=1,SIZE(X, DIM=1))]) - ENDFUNCTION WRITE_ON_SCRATCH_DATAARRAY3_RANK1_I1P - - FUNCTION WRITE_ON_SCRATCH_DATAARRAY3_RANK2_R8P(SELF, X, Y, Z) RESULT(N_BYTE) - !< WRITE A DATAARRAY WITH 3 COMPONENTS OF RANK 2 (R8P). - CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF !< WRITER. - REAL(R8P), INTENT(IN) :: X(1:,1:) !< X COMPONENT. - REAL(R8P), INTENT(IN) :: Y(1:,1:) !< Y COMPONENT. - REAL(R8P), INTENT(IN) :: Z(1:,1:) !< Z COMPONENT. - INTEGER(I4P) :: N_BYTE !< NUMBER OF BYTES - INTEGER(I4P) :: N1 !< COUNTER. - INTEGER(I4P) :: N2 !< COUNTER. - - N_BYTE = SELF%WRITE_ON_SCRATCH_DATAARRAY(X=[((X(N1,N2), Y(N1,N2), Z(N1,N2), N1=1,SIZE(X, DIM=1)),N2=1,SIZE(X, DIM=2))]) - ENDFUNCTION WRITE_ON_SCRATCH_DATAARRAY3_RANK2_R8P - - FUNCTION WRITE_ON_SCRATCH_DATAARRAY3_RANK2_R4P(SELF, X, Y, Z) RESULT(N_BYTE) - !< WRITE A DATAARRAY WITH 3 COMPONENTS OF RANK 2 (R4P). - CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF !< WRITER. - REAL(R4P), INTENT(IN) :: X(1:,1:) !< X COMPONENT. - REAL(R4P), INTENT(IN) :: Y(1:,1:) !< Y COMPONENT. - REAL(R4P), INTENT(IN) :: Z(1:,1:) !< Z COMPONENT. - INTEGER(I4P) :: N_BYTE !< NUMBER OF BYTES - INTEGER(I4P) :: N1 !< COUNTER. - INTEGER(I4P) :: N2 !< COUNTER. - - N_BYTE = SELF%WRITE_ON_SCRATCH_DATAARRAY(X=[((X(N1,N2), Y(N1,N2), Z(N1,N2), N1=1,SIZE(X, DIM=1)),N2=1,SIZE(X, DIM=2))]) - ENDFUNCTION WRITE_ON_SCRATCH_DATAARRAY3_RANK2_R4P - - FUNCTION WRITE_ON_SCRATCH_DATAARRAY3_RANK2_I8P(SELF, X, Y, Z) RESULT(N_BYTE) - !< WRITE A DATAARRAY WITH 3 COMPONENTS OF RANK 2 (I8P). - CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF !< WRITER. - INTEGER(I8P), INTENT(IN) :: X(1:,1:) !< X COMPONENT. - INTEGER(I8P), INTENT(IN) :: Y(1:,1:) !< Y COMPONENT. - INTEGER(I8P), INTENT(IN) :: Z(1:,1:) !< Z COMPONENT. - INTEGER(I4P) :: N_BYTE !< NUMBER OF BYTES - INTEGER(I4P) :: N1 !< COUNTER. - INTEGER(I4P) :: N2 !< COUNTER. - - N_BYTE = SELF%WRITE_ON_SCRATCH_DATAARRAY(X=[((X(N1,N2), Y(N1,N2), Z(N1,N2), N1=1,SIZE(X, DIM=1)),N2=1,SIZE(X, DIM=2))]) - ENDFUNCTION WRITE_ON_SCRATCH_DATAARRAY3_RANK2_I8P - - FUNCTION WRITE_ON_SCRATCH_DATAARRAY3_RANK2_I4P(SELF, X, Y, Z) RESULT(N_BYTE) - !< WRITE A DATAARRAY WITH 3 COMPONENTS OF RANK 2 (I4P). - CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF !< WRITER. - INTEGER(I4P), INTENT(IN) :: X(1:,1:) !< X COMPONENT. - INTEGER(I4P), INTENT(IN) :: Y(1:,1:) !< Y COMPONENT. - INTEGER(I4P), INTENT(IN) :: Z(1:,1:) !< Z COMPONENT. - INTEGER(I4P) :: N_BYTE !< NUMBER OF BYTES - INTEGER(I4P) :: N1 !< COUNTER. - INTEGER(I4P) :: N2 !< COUNTER. - - N_BYTE = SELF%WRITE_ON_SCRATCH_DATAARRAY(X=[((X(N1,N2), Y(N1,N2), Z(N1,N2), N1=1,SIZE(X, DIM=1)),N2=1,SIZE(X, DIM=2))]) - ENDFUNCTION WRITE_ON_SCRATCH_DATAARRAY3_RANK2_I4P - - FUNCTION WRITE_ON_SCRATCH_DATAARRAY3_RANK2_I2P(SELF, X, Y, Z) RESULT(N_BYTE) - !< WRITE A DATAARRAY WITH 3 COMPONENTS OF RANK 2 (I2P). - CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF !< WRITER. - INTEGER(I2P), INTENT(IN) :: X(1:,1:) !< X COMPONENT. - INTEGER(I2P), INTENT(IN) :: Y(1:,1:) !< Y COMPONENT. - INTEGER(I2P), INTENT(IN) :: Z(1:,1:) !< Z COMPONENT. - INTEGER(I4P) :: N_BYTE !< NUMBER OF BYTES - INTEGER(I4P) :: N1 !< COUNTER. - INTEGER(I4P) :: N2 !< COUNTER. - - N_BYTE = SELF%WRITE_ON_SCRATCH_DATAARRAY(X=[((X(N1,N2), Y(N1,N2), Z(N1,N2), N1=1,SIZE(X, DIM=1)),N2=1,SIZE(X, DIM=2))]) - ENDFUNCTION WRITE_ON_SCRATCH_DATAARRAY3_RANK2_I2P - - FUNCTION WRITE_ON_SCRATCH_DATAARRAY3_RANK2_I1P(SELF, X, Y, Z) RESULT(N_BYTE) - !< WRITE A DATAARRAY WITH 3 COMPONENTS OF RANK 2 (I1P). - CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF !< WRITER. - INTEGER(I1P), INTENT(IN) :: X(1:,1:) !< X COMPONENT. - INTEGER(I1P), INTENT(IN) :: Y(1:,1:) !< Y COMPONENT. - INTEGER(I1P), INTENT(IN) :: Z(1:,1:) !< Z COMPONENT. - INTEGER(I4P) :: N_BYTE !< NUMBER OF BYTES - INTEGER(I4P) :: N1 !< COUNTER. - INTEGER(I4P) :: N2 !< COUNTER. - - N_BYTE = SELF%WRITE_ON_SCRATCH_DATAARRAY(X=[((X(N1,N2), Y(N1,N2), Z(N1,N2), N1=1,SIZE(X, DIM=1)),N2=1,SIZE(X, DIM=2))]) - ENDFUNCTION WRITE_ON_SCRATCH_DATAARRAY3_RANK2_I1P - - FUNCTION WRITE_ON_SCRATCH_DATAARRAY3_RANK3_R8P(SELF, X, Y, Z) RESULT(N_BYTE) - !< WRITE A DATAARRAY WITH 3 COMPONENTS OF RANK 3 (R8P). - CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF !< WRITER. - REAL(R8P), INTENT(IN) :: X(1:,1:,1:) !< X COMPONENT. - REAL(R8P), INTENT(IN) :: Y(1:,1:,1:) !< Y COMPONENT. - REAL(R8P), INTENT(IN) :: Z(1:,1:,1:) !< Z COMPONENT. - INTEGER(I4P) :: N_BYTE !< NUMBER OF BYTES - INTEGER(I4P) :: N1 !< COUNTER. - INTEGER(I4P) :: N2 !< COUNTER. - INTEGER(I4P) :: N3 !< COUNTER. - - N_BYTE = SELF%WRITE_ON_SCRATCH_DATAARRAY(X=[(((X(N1,N2,N3), Y(N1,N2,N3), Z(N1,N2,N3), & - N1=1,SIZE(X, DIM=1)),N2=1,SIZE(X, DIM=2)),N3=1,SIZE(X, DIM=3))]) - ENDFUNCTION WRITE_ON_SCRATCH_DATAARRAY3_RANK3_R8P - - FUNCTION WRITE_ON_SCRATCH_DATAARRAY3_RANK3_R4P(SELF, X, Y, Z) RESULT(N_BYTE) - !< WRITE A DATAARRAY WITH 3 COMPONENTS OF RANK 3 (R4P). - CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF !< WRITER. - REAL(R4P), INTENT(IN) :: X(1:,1:,1:) !< X COMPONENT. - REAL(R4P), INTENT(IN) :: Y(1:,1:,1:) !< Y COMPONENT. - REAL(R4P), INTENT(IN) :: Z(1:,1:,1:) !< Z COMPONENT. - INTEGER(I4P) :: N_BYTE !< NUMBER OF BYTES - INTEGER(I4P) :: N1 !< COUNTER. - INTEGER(I4P) :: N2 !< COUNTER. - INTEGER(I4P) :: N3 !< COUNTER. - - N_BYTE = SELF%WRITE_ON_SCRATCH_DATAARRAY(X=[(((X(N1,N2,N3), Y(N1,N2,N3), Z(N1,N2,N3), & - N1=1,SIZE(X, DIM=1)),N2=1,SIZE(X, DIM=2)),N3=1,SIZE(X, DIM=3))]) - ENDFUNCTION WRITE_ON_SCRATCH_DATAARRAY3_RANK3_R4P - - FUNCTION WRITE_ON_SCRATCH_DATAARRAY3_RANK3_I8P(SELF, X, Y, Z) RESULT(N_BYTE) - !< WRITE A DATAARRAY WITH 3 COMPONENTS OF RANK 3 (I8P). - CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF !< WRITER. - INTEGER(I8P), INTENT(IN) :: X(1:,1:,1:) !< X COMPONENT. - INTEGER(I8P), INTENT(IN) :: Y(1:,1:,1:) !< Y COMPONENT. - INTEGER(I8P), INTENT(IN) :: Z(1:,1:,1:) !< Z COMPONENT. - INTEGER(I4P) :: N_BYTE !< NUMBER OF BYTES - INTEGER(I4P) :: N1 !< COUNTER. - INTEGER(I4P) :: N2 !< COUNTER. - INTEGER(I4P) :: N3 !< COUNTER. - - N_BYTE = SELF%WRITE_ON_SCRATCH_DATAARRAY(X=[(((X(N1,N2,N3), Y(N1,N2,N3), Z(N1,N2,N3), & - N1=1,SIZE(X, DIM=1)),N2=1,SIZE(X, DIM=2)),N3=1,SIZE(X, DIM=3))]) - ENDFUNCTION WRITE_ON_SCRATCH_DATAARRAY3_RANK3_I8P - - FUNCTION WRITE_ON_SCRATCH_DATAARRAY3_RANK3_I4P(SELF, X, Y, Z) RESULT(N_BYTE) - !< WRITE A DATAARRAY WITH 3 COMPONENTS OF RANK 3 (I4P). - CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF !< WRITER. - INTEGER(I4P), INTENT(IN) :: X(1:,1:,1:) !< X COMPONENT. - INTEGER(I4P), INTENT(IN) :: Y(1:,1:,1:) !< Y COMPONENT. - INTEGER(I4P), INTENT(IN) :: Z(1:,1:,1:) !< Z COMPONENT. - INTEGER(I4P) :: N_BYTE !< NUMBER OF BYTES - INTEGER(I4P) :: N1 !< COUNTER. - INTEGER(I4P) :: N2 !< COUNTER. - INTEGER(I4P) :: N3 !< COUNTER. - - N_BYTE = SELF%WRITE_ON_SCRATCH_DATAARRAY(X=[(((X(N1,N2,N3), Y(N1,N2,N3), Z(N1,N2,N3), & - N1=1,SIZE(X, DIM=1)),N2=1,SIZE(X, DIM=2)),N3=1,SIZE(X, DIM=3))]) - ENDFUNCTION WRITE_ON_SCRATCH_DATAARRAY3_RANK3_I4P - - FUNCTION WRITE_ON_SCRATCH_DATAARRAY3_RANK3_I2P(SELF, X, Y, Z) RESULT(N_BYTE) - !< WRITE A DATAARRAY WITH 3 COMPONENTS OF RANK 3 (I2P). - CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF !< WRITER. - INTEGER(I2P), INTENT(IN) :: X(1:,1:,1:) !< X COMPONENT. - INTEGER(I2P), INTENT(IN) :: Y(1:,1:,1:) !< Y COMPONENT. - INTEGER(I2P), INTENT(IN) :: Z(1:,1:,1:) !< Z COMPONENT. - INTEGER(I4P) :: N_BYTE !< NUMBER OF BYTES - INTEGER(I4P) :: N1 !< COUNTER. - INTEGER(I4P) :: N2 !< COUNTER. - INTEGER(I4P) :: N3 !< COUNTER. - - N_BYTE = SELF%WRITE_ON_SCRATCH_DATAARRAY(X=[(((X(N1,N2,N3), Y(N1,N2,N3), Z(N1,N2,N3), & - N1=1,SIZE(X, DIM=1)),N2=1,SIZE(X, DIM=2)),N3=1,SIZE(X, DIM=3))]) - ENDFUNCTION WRITE_ON_SCRATCH_DATAARRAY3_RANK3_I2P - - FUNCTION WRITE_ON_SCRATCH_DATAARRAY3_RANK3_I1P(SELF, X, Y, Z) RESULT(N_BYTE) - !< WRITE A DATAARRAY WITH 3 COMPONENTS OF RANK 3 (I1P). - CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF !< WRITER. - INTEGER(I1P), INTENT(IN) :: X(1:,1:,1:) !< X COMPONENT. - INTEGER(I1P), INTENT(IN) :: Y(1:,1:,1:) !< Y COMPONENT. - INTEGER(I1P), INTENT(IN) :: Z(1:,1:,1:) !< Z COMPONENT. - INTEGER(I4P) :: N_BYTE !< NUMBER OF BYTES - INTEGER(I4P) :: N1 !< COUNTER. - INTEGER(I4P) :: N2 !< COUNTER. - INTEGER(I4P) :: N3 !< COUNTER. - - N_BYTE = SELF%WRITE_ON_SCRATCH_DATAARRAY(X=[(((X(N1,N2,N3), Y(N1,N2,N3), Z(N1,N2,N3), & - N1=1,SIZE(X, DIM=1)),N2=1,SIZE(X, DIM=2)),N3=1,SIZE(X, DIM=3))]) - ENDFUNCTION WRITE_ON_SCRATCH_DATAARRAY3_RANK3_I1P - - FUNCTION WRITE_ON_SCRATCH_DATAARRAY6_RANK1_R8P(SELF, U, V, W, X, Y, Z) RESULT(N_BYTE) - !< WRITE A DATAARRAY WITH 6 COMPONENTS OF RANK 1 (R8P). - CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF !< WRITER. - REAL(R8P), INTENT(IN) :: U(1:) !< U COMPONENT. - REAL(R8P), INTENT(IN) :: V(1:) !< V COMPONENT. - REAL(R8P), INTENT(IN) :: W(1:) !< W COMPONENT. - REAL(R8P), INTENT(IN) :: X(1:) !< X COMPONENT. - REAL(R8P), INTENT(IN) :: Y(1:) !< Y COMPONENT. - REAL(R8P), INTENT(IN) :: Z(1:) !< Z COMPONENT. - INTEGER(I4P) :: N_BYTE !< NUMBER OF BYTES - INTEGER(I4P) :: N !< COUNTER. - - N_BYTE = SELF%WRITE_ON_SCRATCH_DATAARRAY(X=[(U(N), V(N), W(N), X(N), Y(N), Z(N), N=1,SIZE(X, DIM=1))]) - ENDFUNCTION WRITE_ON_SCRATCH_DATAARRAY6_RANK1_R8P - - FUNCTION WRITE_ON_SCRATCH_DATAARRAY6_RANK1_R4P(SELF, U, V, W, X, Y, Z) RESULT(N_BYTE) - !< WRITE A DATAARRAY WITH 6 COMPONENTS OF RANK 1 (R4P). - CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF !< WRITER. - REAL(R4P), INTENT(IN) :: U(1:) !< U COMPONENT. - REAL(R4P), INTENT(IN) :: V(1:) !< V COMPONENT. - REAL(R4P), INTENT(IN) :: W(1:) !< W COMPONENT. - REAL(R4P), INTENT(IN) :: X(1:) !< X COMPONENT. - REAL(R4P), INTENT(IN) :: Y(1:) !< Y COMPONENT. - REAL(R4P), INTENT(IN) :: Z(1:) !< Z COMPONENT. - INTEGER(I4P) :: N_BYTE !< NUMBER OF BYTES - INTEGER(I4P) :: N !< COUNTER. - - N_BYTE = SELF%WRITE_ON_SCRATCH_DATAARRAY(X=[(U(N), V(N), W(N), X(N), Y(N), Z(N), N=1,SIZE(X, DIM=1))]) - ENDFUNCTION WRITE_ON_SCRATCH_DATAARRAY6_RANK1_R4P - - FUNCTION WRITE_ON_SCRATCH_DATAARRAY6_RANK1_I8P(SELF, U, V, W, X, Y, Z) RESULT(N_BYTE) - !< WRITE A DATAARRAY WITH 3 COMPONENTS OF RANK 1 (I8P). - CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF !< WRITER. - INTEGER(I8P), INTENT(IN) :: U(1:) !< U COMPONENT. - INTEGER(I8P), INTENT(IN) :: V(1:) !< V COMPONENT. - INTEGER(I8P), INTENT(IN) :: W(1:) !< W COMPONENT. - INTEGER(I8P), INTENT(IN) :: X(1:) !< X COMPONENT. - INTEGER(I8P), INTENT(IN) :: Y(1:) !< Y COMPONENT. - INTEGER(I8P), INTENT(IN) :: Z(1:) !< Z COMPONENT. - INTEGER(I4P) :: N_BYTE !< NUMBER OF BYTES - INTEGER(I4P) :: N !< COUNTER. - - N_BYTE = SELF%WRITE_ON_SCRATCH_DATAARRAY(X=[(U(N), V(N), W(N), X(N), Y(N), Z(N), N=1,SIZE(X, DIM=1))]) - ENDFUNCTION WRITE_ON_SCRATCH_DATAARRAY6_RANK1_I8P - - FUNCTION WRITE_ON_SCRATCH_DATAARRAY6_RANK1_I4P(SELF, U, V, W, X, Y, Z) RESULT(N_BYTE) - !< WRITE A DATAARRAY WITH 6 COMPONENTS OF RANK 1 (I4P). - CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF !< WRITER. - INTEGER(I4P), INTENT(IN) :: U(1:) !< U COMPONENT. - INTEGER(I4P), INTENT(IN) :: V(1:) !< V COMPONENT. - INTEGER(I4P), INTENT(IN) :: W(1:) !< W COMPONENT. - INTEGER(I4P), INTENT(IN) :: X(1:) !< X COMPONENT. - INTEGER(I4P), INTENT(IN) :: Y(1:) !< Y COMPONENT. - INTEGER(I4P), INTENT(IN) :: Z(1:) !< Z COMPONENT. - INTEGER(I4P) :: N_BYTE !< NUMBER OF BYTES - INTEGER(I4P) :: N !< COUNTER. - - N_BYTE = SELF%WRITE_ON_SCRATCH_DATAARRAY(X=[(U(N), V(N), W(N), X(N), Y(N), Z(N), N=1,SIZE(X, DIM=1))]) - ENDFUNCTION WRITE_ON_SCRATCH_DATAARRAY6_RANK1_I4P - - FUNCTION WRITE_ON_SCRATCH_DATAARRAY6_RANK1_I2P(SELF, U, V, W, X, Y, Z) RESULT(N_BYTE) - !< WRITE A DATAARRAY WITH 6 COMPONENTS OF RANK 1 (I2P). - CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF !< WRITER. - INTEGER(I2P), INTENT(IN) :: U(1:) !< U COMPONENT. - INTEGER(I2P), INTENT(IN) :: V(1:) !< V COMPONENT. - INTEGER(I2P), INTENT(IN) :: W(1:) !< W COMPONENT. - INTEGER(I2P), INTENT(IN) :: X(1:) !< X COMPONENT. - INTEGER(I2P), INTENT(IN) :: Y(1:) !< Y COMPONENT. - INTEGER(I2P), INTENT(IN) :: Z(1:) !< Z COMPONENT. - INTEGER(I4P) :: N_BYTE !< NUMBER OF BYTES - INTEGER(I4P) :: N !< COUNTER. - - N_BYTE = SELF%WRITE_ON_SCRATCH_DATAARRAY(X=[(U(N), V(N), W(N), X(N), Y(N), Z(N), N=1,SIZE(X, DIM=1))]) - ENDFUNCTION WRITE_ON_SCRATCH_DATAARRAY6_RANK1_I2P - - FUNCTION WRITE_ON_SCRATCH_DATAARRAY6_RANK1_I1P(SELF, U, V, W, X, Y, Z) RESULT(N_BYTE) - !< WRITE A DATAARRAY WITH 6 COMPONENTS OF RANK 1 (I1P). - CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF !< WRITER. - INTEGER(I1P), INTENT(IN) :: U(1:) !< U COMPONENT. - INTEGER(I1P), INTENT(IN) :: V(1:) !< V COMPONENT. - INTEGER(I1P), INTENT(IN) :: W(1:) !< W COMPONENT. - INTEGER(I1P), INTENT(IN) :: X(1:) !< X COMPONENT. - INTEGER(I1P), INTENT(IN) :: Y(1:) !< Y COMPONENT. - INTEGER(I1P), INTENT(IN) :: Z(1:) !< Z COMPONENT. - INTEGER(I4P) :: N_BYTE !< NUMBER OF BYTES - INTEGER(I4P) :: N !< COUNTER. - - N_BYTE = SELF%WRITE_ON_SCRATCH_DATAARRAY(X=[(U(N), V(N), W(N), X(N), Y(N), Z(N), N=1,SIZE(X, DIM=1))]) - ENDFUNCTION WRITE_ON_SCRATCH_DATAARRAY6_RANK1_I1P - - FUNCTION WRITE_ON_SCRATCH_DATAARRAY6_RANK2_R8P(SELF, U, V, W, X, Y, Z) RESULT(N_BYTE) - !< WRITE A DATAARRAY WITH 6 COMPONENTS OF RANK 2 (R8P). - CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF !< WRITER. - REAL(R8P), INTENT(IN) :: U(1:,1:) !< U COMPONENT. - REAL(R8P), INTENT(IN) :: V(1:,1:) !< V COMPONENT. - REAL(R8P), INTENT(IN) :: W(1:,1:) !< W COMPONENT. - REAL(R8P), INTENT(IN) :: X(1:,1:) !< X COMPONENT. - REAL(R8P), INTENT(IN) :: Y(1:,1:) !< Y COMPONENT. - REAL(R8P), INTENT(IN) :: Z(1:,1:) !< Z COMPONENT. - INTEGER(I4P) :: N_BYTE !< NUMBER OF BYTES - INTEGER(I4P) :: N1 !< COUNTER. - INTEGER(I4P) :: N2 !< COUNTER. - - N_BYTE = SELF%WRITE_ON_SCRATCH_DATAARRAY(X=[((U(N1,N2), V(N1,N2), W(N1,N2), & - X(N1,N2), Y(N1,N2), Z(N1,N2), N1=1,SIZE(X, DIM=1)),N2=1,SIZE(X, DIM=2))]) - ENDFUNCTION WRITE_ON_SCRATCH_DATAARRAY6_RANK2_R8P - - FUNCTION WRITE_ON_SCRATCH_DATAARRAY6_RANK2_R4P(SELF, U, V, W, X, Y, Z) RESULT(N_BYTE) - !< WRITE A DATAARRAY WITH 6 COMPONENTS OF RANK 2 (R4P). - CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF !< WRITER. - REAL(R4P), INTENT(IN) :: U(1:,1:) !< U COMPONENT. - REAL(R4P), INTENT(IN) :: V(1:,1:) !< V COMPONENT. - REAL(R4P), INTENT(IN) :: W(1:,1:) !< W COMPONENT. - REAL(R4P), INTENT(IN) :: X(1:,1:) !< X COMPONENT. - REAL(R4P), INTENT(IN) :: Y(1:,1:) !< Y COMPONENT. - REAL(R4P), INTENT(IN) :: Z(1:,1:) !< Z COMPONENT. - INTEGER(I4P) :: N_BYTE !< NUMBER OF BYTES - INTEGER(I4P) :: N1 !< COUNTER. - INTEGER(I4P) :: N2 !< COUNTER. - - N_BYTE = SELF%WRITE_ON_SCRATCH_DATAARRAY(X=[((U(N1,N2), V(N1,N2), W(N1,N2), & - X(N1,N2), Y(N1,N2), Z(N1,N2), N1=1,SIZE(X, DIM=1)),N2=1,SIZE(X, DIM=2))]) - ENDFUNCTION WRITE_ON_SCRATCH_DATAARRAY6_RANK2_R4P - - FUNCTION WRITE_ON_SCRATCH_DATAARRAY6_RANK2_I8P(SELF, U, V, W, X, Y, Z) RESULT(N_BYTE) - !< WRITE A DATAARRAY WITH 6 COMPONENTS OF RANK 2 (I8P). - CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF !< WRITER. - INTEGER(I8P), INTENT(IN) :: U(1:,1:) !< U COMPONENT. - INTEGER(I8P), INTENT(IN) :: V(1:,1:) !< V COMPONENT. - INTEGER(I8P), INTENT(IN) :: W(1:,1:) !< W COMPONENT. - INTEGER(I8P), INTENT(IN) :: X(1:,1:) !< X COMPONENT. - INTEGER(I8P), INTENT(IN) :: Y(1:,1:) !< Y COMPONENT. - INTEGER(I8P), INTENT(IN) :: Z(1:,1:) !< Z COMPONENT. - INTEGER(I4P) :: N_BYTE !< NUMBER OF BYTES - INTEGER(I4P) :: N1 !< COUNTER. - INTEGER(I4P) :: N2 !< COUNTER. - - N_BYTE = SELF%WRITE_ON_SCRATCH_DATAARRAY(X=[((U(N1,N2), V(N1,N2), W(N1,N2), & - X(N1,N2), Y(N1,N2), Z(N1,N2), N1=1,SIZE(X, DIM=1)),N2=1,SIZE(X, DIM=2))]) - ENDFUNCTION WRITE_ON_SCRATCH_DATAARRAY6_RANK2_I8P - - FUNCTION WRITE_ON_SCRATCH_DATAARRAY6_RANK2_I4P(SELF, U, V, W, X, Y, Z) RESULT(N_BYTE) - !< WRITE A DATAARRAY WITH 6 COMPONENTS OF RANK 2 (I4P). - CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF !< WRITER. - INTEGER(I4P), INTENT(IN) :: U(1:,1:) !< U COMPONENT. - INTEGER(I4P), INTENT(IN) :: V(1:,1:) !< V COMPONENT. - INTEGER(I4P), INTENT(IN) :: W(1:,1:) !< W COMPONENT. - INTEGER(I4P), INTENT(IN) :: X(1:,1:) !< X COMPONENT. - INTEGER(I4P), INTENT(IN) :: Y(1:,1:) !< Y COMPONENT. - INTEGER(I4P), INTENT(IN) :: Z(1:,1:) !< Z COMPONENT. - INTEGER(I4P) :: N_BYTE !< NUMBER OF BYTES - INTEGER(I4P) :: N1 !< COUNTER. - INTEGER(I4P) :: N2 !< COUNTER. - - N_BYTE = SELF%WRITE_ON_SCRATCH_DATAARRAY(X=[((U(N1,N2), V(N1,N2), W(N1,N2), & - X(N1,N2), Y(N1,N2), Z(N1,N2), N1=1,SIZE(X, DIM=1)),N2=1,SIZE(X, DIM=2))]) - ENDFUNCTION WRITE_ON_SCRATCH_DATAARRAY6_RANK2_I4P - - FUNCTION WRITE_ON_SCRATCH_DATAARRAY6_RANK2_I2P(SELF, U, V, W, X, Y, Z) RESULT(N_BYTE) - !< WRITE A DATAARRAY WITH 6 COMPONENTS OF RANK 2 (I2P). - CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF !< WRITER. - INTEGER(I2P), INTENT(IN) :: U(1:,1:) !< U COMPONENT. - INTEGER(I2P), INTENT(IN) :: V(1:,1:) !< V COMPONENT. - INTEGER(I2P), INTENT(IN) :: W(1:,1:) !< W COMPONENT. - INTEGER(I2P), INTENT(IN) :: X(1:,1:) !< X COMPONENT. - INTEGER(I2P), INTENT(IN) :: Y(1:,1:) !< Y COMPONENT. - INTEGER(I2P), INTENT(IN) :: Z(1:,1:) !< Z COMPONENT. - INTEGER(I4P) :: N_BYTE !< NUMBER OF BYTES - INTEGER(I4P) :: N1 !< COUNTER. - INTEGER(I4P) :: N2 !< COUNTER. - - N_BYTE = SELF%WRITE_ON_SCRATCH_DATAARRAY(X=[((U(N1,N2), V(N1,N2), W(N1,N2), & - X(N1,N2), Y(N1,N2), Z(N1,N2), N1=1,SIZE(X, DIM=1)),N2=1,SIZE(X, DIM=2))]) - ENDFUNCTION WRITE_ON_SCRATCH_DATAARRAY6_RANK2_I2P - - FUNCTION WRITE_ON_SCRATCH_DATAARRAY6_RANK2_I1P(SELF, U, V, W, X, Y, Z) RESULT(N_BYTE) - !< WRITE A DATAARRAY WITH 6 COMPONENTS OF RANK 2 (I1P). - CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF !< WRITER. - INTEGER(I1P), INTENT(IN) :: U(1:,1:) !< U COMPONENT. - INTEGER(I1P), INTENT(IN) :: V(1:,1:) !< V COMPONENT. - INTEGER(I1P), INTENT(IN) :: W(1:,1:) !< W COMPONENT. - INTEGER(I1P), INTENT(IN) :: X(1:,1:) !< X COMPONENT. - INTEGER(I1P), INTENT(IN) :: Y(1:,1:) !< Y COMPONENT. - INTEGER(I1P), INTENT(IN) :: Z(1:,1:) !< Z COMPONENT. - INTEGER(I4P) :: N_BYTE !< NUMBER OF BYTES - INTEGER(I4P) :: N1 !< COUNTER. - INTEGER(I4P) :: N2 !< COUNTER. - - N_BYTE = SELF%WRITE_ON_SCRATCH_DATAARRAY(X=[((U(N1,N2), V(N1,N2), W(N1,N2), & - X(N1,N2), Y(N1,N2), Z(N1,N2), N1=1,SIZE(X, DIM=1)),N2=1,SIZE(X, DIM=2))]) - ENDFUNCTION WRITE_ON_SCRATCH_DATAARRAY6_RANK2_I1P - - FUNCTION WRITE_ON_SCRATCH_DATAARRAY6_RANK3_R8P(SELF, U, V, W, X, Y, Z) RESULT(N_BYTE) - !< WRITE A DATAARRAY WITH 6 COMPONENTS OF RANK 3 (R8P). - CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF !< WRITER. - REAL(R8P), INTENT(IN) :: U(1:,1:,1:) !< U COMPONENT. - REAL(R8P), INTENT(IN) :: V(1:,1:,1:) !< V COMPONENT. - REAL(R8P), INTENT(IN) :: W(1:,1:,1:) !< W COMPONENT. - REAL(R8P), INTENT(IN) :: X(1:,1:,1:) !< X COMPONENT. - REAL(R8P), INTENT(IN) :: Y(1:,1:,1:) !< Y COMPONENT. - REAL(R8P), INTENT(IN) :: Z(1:,1:,1:) !< Z COMPONENT. - INTEGER(I4P) :: N_BYTE !< NUMBER OF BYTES - INTEGER(I4P) :: N1 !< COUNTER. - INTEGER(I4P) :: N2 !< COUNTER. - INTEGER(I4P) :: N3 !< COUNTER. - - N_BYTE = SELF%WRITE_ON_SCRATCH_DATAARRAY(X=[(((U(N1,N2,N3), V(N1,N2,N3), W(N1,N2,N3), & - X(N1,N2,N3), Y(N1,N2,N3), Z(N1,N2,N3), & - N1=1,SIZE(X, DIM=1)),N2=1,SIZE(X, DIM=2)),N3=1,SIZE(X, DIM=3))]) - ENDFUNCTION WRITE_ON_SCRATCH_DATAARRAY6_RANK3_R8P - - FUNCTION WRITE_ON_SCRATCH_DATAARRAY6_RANK3_R4P(SELF, U, V, W, X, Y, Z) RESULT(N_BYTE) - !< WRITE A DATAARRAY WITH 6 COMPONENTS OF RANK 3 (R4P). - CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF !< WRITER. - REAL(R4P), INTENT(IN) :: U(1:,1:,1:) !< U COMPONENT. - REAL(R4P), INTENT(IN) :: V(1:,1:,1:) !< V COMPONENT. - REAL(R4P), INTENT(IN) :: W(1:,1:,1:) !< W COMPONENT. - REAL(R4P), INTENT(IN) :: X(1:,1:,1:) !< X COMPONENT. - REAL(R4P), INTENT(IN) :: Y(1:,1:,1:) !< Y COMPONENT. - REAL(R4P), INTENT(IN) :: Z(1:,1:,1:) !< Z COMPONENT. - INTEGER(I4P) :: N_BYTE !< NUMBER OF BYTES - INTEGER(I4P) :: N1 !< COUNTER. - INTEGER(I4P) :: N2 !< COUNTER. - INTEGER(I4P) :: N3 !< COUNTER. - - N_BYTE = SELF%WRITE_ON_SCRATCH_DATAARRAY(X=[(((U(N1,N2,N3), V(N1,N2,N3), W(N1,N2,N3), X(N1,N2,N3), Y(N1,N2,N3), Z(N1,N2,N3), & - N1=1,SIZE(X, DIM=1)),N2=1,SIZE(X, DIM=2)),N3=1,SIZE(X, DIM=3))]) - ENDFUNCTION WRITE_ON_SCRATCH_DATAARRAY6_RANK3_R4P - - FUNCTION WRITE_ON_SCRATCH_DATAARRAY6_RANK3_I8P(SELF, U, V, W, X, Y, Z) RESULT(N_BYTE) - !< WRITE A DATAARRAY WITH 6 COMPONENTS OF RANK 3 (I8P). - CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF !< WRITER. - INTEGER(I8P), INTENT(IN) :: U(1:,1:,1:) !< U COMPONENT. - INTEGER(I8P), INTENT(IN) :: V(1:,1:,1:) !< V COMPONENT. - INTEGER(I8P), INTENT(IN) :: W(1:,1:,1:) !< W COMPONENT. - INTEGER(I8P), INTENT(IN) :: X(1:,1:,1:) !< X COMPONENT. - INTEGER(I8P), INTENT(IN) :: Y(1:,1:,1:) !< Y COMPONENT. - INTEGER(I8P), INTENT(IN) :: Z(1:,1:,1:) !< Z COMPONENT. - INTEGER(I4P) :: N_BYTE !< NUMBER OF BYTES - INTEGER(I4P) :: N1 !< COUNTER. - INTEGER(I4P) :: N2 !< COUNTER. - INTEGER(I4P) :: N3 !< COUNTER. - - N_BYTE = SELF%WRITE_ON_SCRATCH_DATAARRAY(X=[(((U(N1,N2,N3), V(N1,N2,N3), W(N1,N2,N3), X(N1,N2,N3), Y(N1,N2,N3), Z(N1,N2,N3), & - N1=1,SIZE(X, DIM=1)),N2=1,SIZE(X, DIM=2)),N3=1,SIZE(X, DIM=3))]) - ENDFUNCTION WRITE_ON_SCRATCH_DATAARRAY6_RANK3_I8P - - FUNCTION WRITE_ON_SCRATCH_DATAARRAY6_RANK3_I4P(SELF, U, V, W, X, Y, Z) RESULT(N_BYTE) - !< WRITE A DATAARRAY WITH 6 COMPONENTS OF RANK 3 (I4P). - CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF !< WRITER. - INTEGER(I4P), INTENT(IN) :: U(1:,1:,1:) !< U COMPONENT. - INTEGER(I4P), INTENT(IN) :: V(1:,1:,1:) !< V COMPONENT. - INTEGER(I4P), INTENT(IN) :: W(1:,1:,1:) !< W COMPONENT. - INTEGER(I4P), INTENT(IN) :: X(1:,1:,1:) !< X COMPONENT. - INTEGER(I4P), INTENT(IN) :: Y(1:,1:,1:) !< Y COMPONENT. - INTEGER(I4P), INTENT(IN) :: Z(1:,1:,1:) !< Z COMPONENT. - INTEGER(I4P) :: N_BYTE !< NUMBER OF BYTES - INTEGER(I4P) :: N1 !< COUNTER. - INTEGER(I4P) :: N2 !< COUNTER. - INTEGER(I4P) :: N3 !< COUNTER. - - N_BYTE = SELF%WRITE_ON_SCRATCH_DATAARRAY(X=[(((U(N1,N2,N3), V(N1,N2,N3), W(N1,N2,N3), X(N1,N2,N3), Y(N1,N2,N3), Z(N1,N2,N3), & - N1=1,SIZE(X, DIM=1)),N2=1,SIZE(X, DIM=2)),N3=1,SIZE(X, DIM=3))]) - ENDFUNCTION WRITE_ON_SCRATCH_DATAARRAY6_RANK3_I4P - - FUNCTION WRITE_ON_SCRATCH_DATAARRAY6_RANK3_I2P(SELF, U, V, W, X, Y, Z) RESULT(N_BYTE) - !< WRITE A DATAARRAY WITH 6 COMPONENTS OF RANK 3 (I2P). - CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF !< WRITER. - INTEGER(I2P), INTENT(IN) :: U(1:,1:,1:) !< U COMPONENT. - INTEGER(I2P), INTENT(IN) :: V(1:,1:,1:) !< V COMPONENT. - INTEGER(I2P), INTENT(IN) :: W(1:,1:,1:) !< W COMPONENT. - INTEGER(I2P), INTENT(IN) :: X(1:,1:,1:) !< X COMPONENT. - INTEGER(I2P), INTENT(IN) :: Y(1:,1:,1:) !< Y COMPONENT. - INTEGER(I2P), INTENT(IN) :: Z(1:,1:,1:) !< Z COMPONENT. - INTEGER(I4P) :: N_BYTE !< NUMBER OF BYTES - INTEGER(I4P) :: N1 !< COUNTER. - INTEGER(I4P) :: N2 !< COUNTER. - INTEGER(I4P) :: N3 !< COUNTER. - - N_BYTE = SELF%WRITE_ON_SCRATCH_DATAARRAY(X=[(((U(N1,N2,N3), V(N1,N2,N3), W(N1,N2,N3), X(N1,N2,N3), Y(N1,N2,N3), Z(N1,N2,N3), & - N1=1,SIZE(X, DIM=1)),N2=1,SIZE(X, DIM=2)),N3=1,SIZE(X, DIM=3))]) - ENDFUNCTION WRITE_ON_SCRATCH_DATAARRAY6_RANK3_I2P - - FUNCTION WRITE_ON_SCRATCH_DATAARRAY6_RANK3_I1P(SELF, U, V, W, X, Y, Z) RESULT(N_BYTE) - !< WRITE A DATAARRAY WITH 6 COMPONENTS OF RANK 3 (I1P). - CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF !< WRITER. - INTEGER(I1P), INTENT(IN) :: U(1:,1:,1:) !< U COMPONENT. - INTEGER(I1P), INTENT(IN) :: V(1:,1:,1:) !< V COMPONENT. - INTEGER(I1P), INTENT(IN) :: W(1:,1:,1:) !< W COMPONENT. - INTEGER(I1P), INTENT(IN) :: X(1:,1:,1:) !< X COMPONENT. - INTEGER(I1P), INTENT(IN) :: Y(1:,1:,1:) !< Y COMPONENT. - INTEGER(I1P), INTENT(IN) :: Z(1:,1:,1:) !< Z COMPONENT. - INTEGER(I4P) :: N_BYTE !< NUMBER OF BYTES - INTEGER(I4P) :: N1 !< COUNTER. - INTEGER(I4P) :: N2 !< COUNTER. - INTEGER(I4P) :: N3 !< COUNTER. - - N_BYTE = SELF%WRITE_ON_SCRATCH_DATAARRAY(X=[(((U(N1,N2,N3), V(N1,N2,N3), W(N1,N2,N3), X(N1,N2,N3), Y(N1,N2,N3), Z(N1,N2,N3), & - N1=1,SIZE(X, DIM=1)),N2=1,SIZE(X, DIM=2)),N3=1,SIZE(X, DIM=3))]) - ENDFUNCTION WRITE_ON_SCRATCH_DATAARRAY6_RANK3_I1P -ENDMODULE VTKF_FILE_XML_WRITER_APPENDED - - - - -!< VTK FILE XML WRITER, BINARY LOCAL. -MODULE VTKF_FILE_XML_WRITER_BINARY_LOCAL -!< VTK FILE XML WRITER, BINARY LOCAL. -!< -!< THIS WRITER IS (CURRENTLY) THE ONLY ONE ABLE ALSO TO CREATE A *VOLATILE* FILE (ENABLING VOLATILE OPTION). -!< INSTEAD OF SAVING DATA INTO A REAL FILE ON THE SYSTEM, THIS WRITER CAN SAVE DATA INTO A (VOLATILE) CHARACTERS STRING THAT CAN BE -!< USED ALSO ON (SLAVE) PROCESSES THAT HAVE NOT ACCESS TO FILESYSTEM: THE VOLATILE STRING CAN BE EASILY SENT TO OTHER (MASTER) -!< PROCESSES HAVING ACCESS TO FILESYTEM. THE VOLATILE WRITER MODE IS DESIGNED TO FACILITATE THE USE OF THE LIBRARY IN PARALLEL -!< ENVINROMENTS WEHERE NOT ALL PROCESSES/THREADS HAVE ACCESS TO FILESYSTEM. -USE PENF -USE STRINGIFOR -USE VTK_FORTRAN_DATAARRAY_ENCODER -USE VTKF_FILE_XML_WRITER_ABSTRACT - -IMPLICIT NONE -PRIVATE -PUBLIC :: XML_WRITER_BINARY_LOCAL - -TYPE, EXTENDS(XML_WRITER_ABSTRACT) :: XML_WRITER_BINARY_LOCAL - !< VTK FILE XML WRITER, BINARY LOCAL. - CONTAINS - ! DEFERRED METHODS - PROCEDURE, PASS(SELF) :: INITIALIZE !< INITIALIZE WRITER. - PROCEDURE, PASS(SELF) :: FINALIZE !< FINALIZE WRITER. - PROCEDURE, PASS(SELF) :: W_DATA1_RANK1_R8P !< WRITE DATAARRAY 1, RANK 1, R8P. - PROCEDURE, PASS(SELF) :: W_DATA1_RANK1_R4P !< WRITE DATAARRAY 1, RANK 1, R4P. - PROCEDURE, PASS(SELF) :: W_DATA1_RANK1_I8P !< WRITE DATAARRAY 1, RANK 1, I8P. - PROCEDURE, PASS(SELF) :: W_DATA1_RANK1_I4P !< WRITE DATAARRAY 1, RANK 1, I4P. - PROCEDURE, PASS(SELF) :: W_DATA1_RANK1_I2P !< WRITE DATAARRAY 1, RANK 1, I2P. - PROCEDURE, PASS(SELF) :: W_DATA1_RANK1_I1P !< WRITE DATAARRAY 1, RANK 1, I1P. - PROCEDURE, PASS(SELF) :: W_DATA1_RANK2_R8P !< WRITE DATAARRAY 1, RANK 2, R8P. - PROCEDURE, PASS(SELF) :: W_DATA1_RANK2_R4P !< WRITE DATAARRAY 1, RANK 2, R4P. - PROCEDURE, PASS(SELF) :: W_DATA1_RANK2_I8P !< WRITE DATAARRAY 1, RANK 2, I8P. - PROCEDURE, PASS(SELF) :: W_DATA1_RANK2_I4P !< WRITE DATAARRAY 1, RANK 2, I4P. - PROCEDURE, PASS(SELF) :: W_DATA1_RANK2_I2P !< WRITE DATAARRAY 1, RANK 2, I2P. - PROCEDURE, PASS(SELF) :: W_DATA1_RANK2_I1P !< WRITE DATAARRAY 1, RANK 2, I1P. - PROCEDURE, PASS(SELF) :: W_DATA1_RANK3_R8P !< WRITE DATAARRAY 1, RANK 3, R8P. - PROCEDURE, PASS(SELF) :: W_DATA1_RANK3_R4P !< WRITE DATAARRAY 1, RANK 3, R4P. - PROCEDURE, PASS(SELF) :: W_DATA1_RANK3_I8P !< WRITE DATAARRAY 1, RANK 3, I8P. - PROCEDURE, PASS(SELF) :: W_DATA1_RANK3_I4P !< WRITE DATAARRAY 1, RANK 3, I4P. - PROCEDURE, PASS(SELF) :: W_DATA1_RANK3_I2P !< WRITE DATAARRAY 1, RANK 3, I2P. - PROCEDURE, PASS(SELF) :: W_DATA1_RANK3_I1P !< WRITE DATAARRAY 1, RANK 3, I1P. - PROCEDURE, PASS(SELF) :: W_DATA1_RANK4_R8P !< WRITE DATAARRAY 1, RANK 4, R8P. - PROCEDURE, PASS(SELF) :: W_DATA1_RANK4_R4P !< WRITE DATAARRAY 1, RANK 4, R4P. - PROCEDURE, PASS(SELF) :: W_DATA1_RANK4_I8P !< WRITE DATAARRAY 1, RANK 4, I8P. - PROCEDURE, PASS(SELF) :: W_DATA1_RANK4_I4P !< WRITE DATAARRAY 1, RANK 4, I4P. - PROCEDURE, PASS(SELF) :: W_DATA1_RANK4_I2P !< WRITE DATAARRAY 1, RANK 4, I2P. - PROCEDURE, PASS(SELF) :: W_DATA1_RANK4_I1P !< WRITE DATAARRAY 1, RANK 4, I1P. - PROCEDURE, PASS(SELF) :: W_DATA3_RANK1_R8P !< WRITE DATAARRAY 3, RANK 1, R8P. - PROCEDURE, PASS(SELF) :: W_DATA3_RANK1_R4P !< WRITE DATAARRAY 3, RANK 1, R4P. - PROCEDURE, PASS(SELF) :: W_DATA3_RANK1_I8P !< WRITE DATAARRAY 3, RANK 1, I8P. - PROCEDURE, PASS(SELF) :: W_DATA3_RANK1_I4P !< WRITE DATAARRAY 3, RANK 1, I4P. - PROCEDURE, PASS(SELF) :: W_DATA3_RANK1_I2P !< WRITE DATAARRAY 3, RANK 1, I2P. - PROCEDURE, PASS(SELF) :: W_DATA3_RANK1_I1P !< WRITE DATAARRAY 3, RANK 1, I1P. - PROCEDURE, PASS(SELF) :: W_DATA3_RANK3_R8P !< WRITE DATAARRAY 3, RANK 3, R8P. - PROCEDURE, PASS(SELF) :: W_DATA3_RANK3_R4P !< WRITE DATAARRAY 3, RANK 3, R4P. - PROCEDURE, PASS(SELF) :: W_DATA3_RANK3_I8P !< WRITE DATAARRAY 3, RANK 3, I8P. - PROCEDURE, PASS(SELF) :: W_DATA3_RANK3_I4P !< WRITE DATAARRAY 3, RANK 3, I4P. - PROCEDURE, PASS(SELF) :: W_DATA3_RANK3_I2P !< WRITE DATAARRAY 3, RANK 3, I2P. - PROCEDURE, PASS(SELF) :: W_DATA3_RANK3_I1P !< WRITE DATAARRAY 3, RANK 3, I1P. - PROCEDURE, PASS(SELF) :: W_DATA6_RANK1_R8P !< WRITE DATAARRAY 6, RANK 1, R8P. - PROCEDURE, PASS(SELF) :: W_DATA6_RANK1_R4P !< WRITE DATAARRAY 6, RANK 1, R4P. - PROCEDURE, PASS(SELF) :: W_DATA6_RANK1_I8P !< WRITE DATAARRAY 6, RANK 1, I8P. - PROCEDURE, PASS(SELF) :: W_DATA6_RANK1_I4P !< WRITE DATAARRAY 6, RANK 1, I4P. - PROCEDURE, PASS(SELF) :: W_DATA6_RANK1_I2P !< WRITE DATAARRAY 6, RANK 1, I2P. - PROCEDURE, PASS(SELF) :: W_DATA6_RANK1_I1P !< WRITE DATAARRAY 6, RANK 1, I1P. - PROCEDURE, PASS(SELF) :: W_DATA6_RANK3_R8P !< WRITE DATAARRAY 6, RANK 3, R8P. - PROCEDURE, PASS(SELF) :: W_DATA6_RANK3_R4P !< WRITE DATAARRAY 6, RANK 3, R4P. - PROCEDURE, PASS(SELF) :: W_DATA6_RANK3_I8P !< WRITE DATAARRAY 6, RANK 3, I8P. - PROCEDURE, PASS(SELF) :: W_DATA6_RANK3_I4P !< WRITE DATAARRAY 6, RANK 3, I4P. - PROCEDURE, PASS(SELF) :: W_DATA6_RANK3_I2P !< WRITE DATAARRAY 6, RANK 3, I2P. - PROCEDURE, PASS(SELF) :: W_DATA6_RANK3_I1P !< WRITE DATAARRAY 6, RANK 3, I1P. - PROCEDURE, PASS(SELF) :: W_DATA_APPENDED !< WRITE APPENDED. -ENDTYPE XML_WRITER_BINARY_LOCAL -CONTAINS - FUNCTION INITIALIZE(SELF, FORMAT, FILENAME, MESH_TOPOLOGY, NX1, NX2, NY1, NY2, NZ1, NZ2, & - IS_VOLATILE, MESH_KIND) RESULT(ERROR) - !< INITIALIZE WRITER. - CLASS(XML_WRITER_BINARY_LOCAL), INTENT(INOUT) :: SELF !< WRITER. - CHARACTER(*), INTENT(IN) :: FORMAT !< FILE FORMAT: BINARY. - CHARACTER(*), INTENT(IN) :: FILENAME !< FILE NAME. - CHARACTER(*), INTENT(IN) :: MESH_TOPOLOGY !< MESH TOPOLOGY. - INTEGER(I4P), INTENT(IN), OPTIONAL :: NX1 !< INITIAL NODE OF X AXIS. - INTEGER(I4P), INTENT(IN), OPTIONAL :: NX2 !< FINAL NODE OF X AXIS. - INTEGER(I4P), INTENT(IN), OPTIONAL :: NY1 !< INITIAL NODE OF Y AXIS. - INTEGER(I4P), INTENT(IN), OPTIONAL :: NY2 !< FINAL NODE OF Y AXIS. - INTEGER(I4P), INTENT(IN), OPTIONAL :: NZ1 !< INITIAL NODE OF Z AXIS. - INTEGER(I4P), INTENT(IN), OPTIONAL :: NZ2 !< FINAL NODE OF Z AXIS. - CHARACTER(*), INTENT(IN), OPTIONAL :: MESH_KIND !< KIND OF MESH DATA: FLOAT64, FLOAT32, ECC. - LOGICAL, INTENT(IN), OPTIONAL :: IS_VOLATILE !< FLAG TO CHECK VOLATILE WRITER. - INTEGER(I4P) :: ERROR !< ERROR STATUS. - - SELF%IS_VOLATILE = .FALSE. ; IF (PRESENT(IS_VOLATILE)) SELF%IS_VOLATILE = IS_VOLATILE - SELF%TOPOLOGY = TRIM(ADJUSTL(MESH_TOPOLOGY)) - SELF%FORMAT_CH = FORMAT - SELF%FORMAT_CH = SELF%FORMAT_CH%LOWER() - CALL SELF%OPEN_XML_FILE(FILENAME=FILENAME) - CALL SELF%WRITE_HEADER_TAG - CALL SELF%WRITE_TOPOLOGY_TAG(NX1=NX1, NX2=NX2, NY1=NY1, NY2=NY2, NZ1=NZ1, NZ2=NZ2, MESH_KIND=MESH_KIND) - ERROR = SELF%ERROR - ENDFUNCTION INITIALIZE - - FUNCTION FINALIZE(SELF) RESULT(ERROR) - !< FINALIZE WRITER. - CLASS(XML_WRITER_BINARY_LOCAL), INTENT(INOUT) :: SELF !< WRITER. - INTEGER(I4P) :: ERROR !< ERROR STATUS. - - CALL SELF%WRITE_END_TAG(NAME=SELF%TOPOLOGY%CHARS()) - CALL SELF%WRITE_END_TAG(NAME='VTKFile') - CALL SELF%CLOSE_XML_FILE - ERROR = SELF%ERROR - ENDFUNCTION FINALIZE - - ! W_DATA METHODS - FUNCTION W_DATA1_RANK1_R8P(SELF, DATA_NAME, X, IS_TUPLES) RESULT(ERROR) - !< WRITE `<DATAARRAY... NumberOfComponents="1"...>...</DATAARRAY>` TAG (R8P). - CLASS(XML_WRITER_BINARY_LOCAL), INTENT(INOUT) :: SELF !< WRITER. - CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. - REAL(R8P), INTENT(IN) :: X(1:) !< DATA VARIABLE. - LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". - INTEGER(I4P) :: ERROR !< ERROR STATUS. - CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. - INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. - CHARACTER(LEN=:), ALLOCATABLE :: CODE !< DATA VARIABLE ENCODED, BINARY OR BASE64 CODEC. - - DATA_TYPE = 'Float64' - N_COMPONENTS = 1 - CODE = ENCODE_BINARY_DATAARRAY(X=X) - CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, & - IS_TUPLES=IS_TUPLES) - ERROR = SELF%ERROR - ENDFUNCTION W_DATA1_RANK1_R8P - - FUNCTION W_DATA1_RANK1_R4P(SELF, DATA_NAME, X, IS_TUPLES) RESULT(ERROR) - !< WRITE `<DATAARRAY... NumberOfComponents="1"...>...</DATAARRAY>` TAG (R4P). - CLASS(XML_WRITER_BINARY_LOCAL), INTENT(INOUT) :: SELF !< WRITER. - CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. - REAL(R4P), INTENT(IN) :: X(1:) !< DATA VARIABLE. - LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". - INTEGER(I4P) :: ERROR !< ERROR STATUS. - CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. - INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. - CHARACTER(LEN=:), ALLOCATABLE :: CODE !< DATA VARIABLE ENCODED, BINARY OR BASE64 CODEC. - - DATA_TYPE = 'Float32' - N_COMPONENTS = 1 - CODE = ENCODE_BINARY_DATAARRAY(X=X) - CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, & - IS_TUPLES=IS_TUPLES) - ERROR = SELF%ERROR - ENDFUNCTION W_DATA1_RANK1_R4P - - FUNCTION W_DATA1_RANK1_I8P(SELF, DATA_NAME, X, IS_TUPLES) RESULT(ERROR) - !< WRITE `<DATAARRAY... NumberOfComponents="1"...>...</DATAARRAY>` TAG (I8P). - CLASS(XML_WRITER_BINARY_LOCAL), INTENT(INOUT) :: SELF !< WRITER. - CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. - INTEGER(I8P), INTENT(IN) :: X(1:) !< DATA VARIABLE. - LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". - INTEGER(I4P) :: ERROR !< ERROR STATUS. - CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. - INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. - CHARACTER(LEN=:), ALLOCATABLE :: CODE !< DATA VARIABLE ENCODED, BINARY OR BASE64 CODEC. - - DATA_TYPE = 'Int64' - N_COMPONENTS = 1 - CODE = ENCODE_BINARY_DATAARRAY(X=X) - CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, & - IS_TUPLES=IS_TUPLES) - ERROR = SELF%ERROR - ENDFUNCTION W_DATA1_RANK1_I8P - - FUNCTION W_DATA1_RANK1_I4P(SELF, DATA_NAME, X, IS_TUPLES) RESULT(ERROR) - !< WRITE `<DATAARRAY... NumberOfComponents="1"...>...</DATAARRAY>` TAG (I4P). - CLASS(XML_WRITER_BINARY_LOCAL), INTENT(INOUT) :: SELF !< WRITER. - CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. - INTEGER(I4P), INTENT(IN) :: X(1:) !< DATA VARIABLE. - LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". - INTEGER(I4P) :: ERROR !< ERROR STATUS. - CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. - INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. - CHARACTER(LEN=:), ALLOCATABLE :: CODE !< DATA VARIABLE ENCODED, BINARY OR BASE64 CODEC. - - DATA_TYPE = 'Int32' - N_COMPONENTS = 1 - CODE = ENCODE_BINARY_DATAARRAY(X=X) - CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, & - IS_TUPLES=IS_TUPLES) - ERROR = SELF%ERROR - ENDFUNCTION W_DATA1_RANK1_I4P - - FUNCTION W_DATA1_RANK1_I2P(SELF, DATA_NAME, X, IS_TUPLES) RESULT(ERROR) - !< WRITE `<DATAARRAY... NumberOfComponents="1"...>...</DATAARRAY>` TAG (I2P). - CLASS(XML_WRITER_BINARY_LOCAL), INTENT(INOUT) :: SELF !< WRITER. - CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. - INTEGER(I2P), INTENT(IN) :: X(1:) !< DATA VARIABLE. - LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". - INTEGER(I4P) :: ERROR !< ERROR STATUS. - CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. - INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. - CHARACTER(LEN=:), ALLOCATABLE :: CODE !< DATA VARIABLE ENCODED, BINARY OR BASE64 CODEC. - - DATA_TYPE = 'Int16' - N_COMPONENTS = 1 - CODE = ENCODE_BINARY_DATAARRAY(X=X) - CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, & - IS_TUPLES=IS_TUPLES) - ERROR = SELF%ERROR - ENDFUNCTION W_DATA1_RANK1_I2P - - FUNCTION W_DATA1_RANK1_I1P(SELF, DATA_NAME, X, IS_TUPLES) RESULT(ERROR) - !< WRITE `<DATAARRAY... NumberOfComponents="1"...>...</DATAARRAY>` TAG (I1P). - CLASS(XML_WRITER_BINARY_LOCAL), INTENT(INOUT) :: SELF !< WRITER. - CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. - INTEGER(I1P), INTENT(IN) :: X(1:) !< DATA VARIABLE. - LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". - INTEGER(I4P) :: ERROR !< ERROR STATUS. - CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. - INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. - CHARACTER(LEN=:), ALLOCATABLE :: CODE !< DATA VARIABLE ENCODED, BINARY OR BASE64 CODEC. - - DATA_TYPE = 'Int8' - N_COMPONENTS = 1 - CODE = ENCODE_BINARY_DATAARRAY(X=X) - CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, & - IS_TUPLES=IS_TUPLES) - ERROR = SELF%ERROR - ENDFUNCTION W_DATA1_RANK1_I1P - - FUNCTION W_DATA1_RANK2_R8P(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR) - !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (R8P). - CLASS(XML_WRITER_BINARY_LOCAL), INTENT(INOUT) :: SELF !< WRITER. - CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. - REAL(R8P), INTENT(IN) :: X(1:,1:) !< DATA VARIABLE. - LOGICAL, INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT. - LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". - INTEGER(I4P) :: ERROR !< ERROR STATUS. - CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. - INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. - CHARACTER(LEN=:), ALLOCATABLE :: CODE !< DATA VARIABLE ENCODED, BINARY OR BASE64 CODEC. - - DATA_TYPE = 'Float64' - N_COMPONENTS = SIZE(X, DIM=1) - IF (PRESENT(ONE_COMPONENT)) THEN - IF (ONE_COMPONENT) N_COMPONENTS = 1 - ENDIF - CODE = ENCODE_BINARY_DATAARRAY(X=X) - CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, & - IS_TUPLES=IS_TUPLES) - ERROR = SELF%ERROR - ENDFUNCTION W_DATA1_RANK2_R8P - - FUNCTION W_DATA1_RANK2_R4P(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR) - !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (R4P). - CLASS(XML_WRITER_BINARY_LOCAL), INTENT(INOUT) :: SELF !< WRITER. - CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. - REAL(R4P), INTENT(IN) :: X(1:,1:) !< DATA VARIABLE. - LOGICAL, INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT. - LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". - INTEGER(I4P) :: ERROR !< ERROR STATUS. - CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. - INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. - CHARACTER(LEN=:), ALLOCATABLE :: CODE !< DATA VARIABLE ENCODED, BINARY OR BASE64 CODEC. - - DATA_TYPE = 'Float32' - N_COMPONENTS = SIZE(X, DIM=1) - IF (PRESENT(ONE_COMPONENT)) THEN - IF (ONE_COMPONENT) N_COMPONENTS = 1 - ENDIF - CODE = ENCODE_BINARY_DATAARRAY(X=X) - CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, & - IS_TUPLES=IS_TUPLES) - ERROR = SELF%ERROR - ENDFUNCTION W_DATA1_RANK2_R4P - - FUNCTION W_DATA1_RANK2_I8P(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR) - !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (I8P). - CLASS(XML_WRITER_BINARY_LOCAL), INTENT(INOUT) :: SELF !< WRITER. - CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. - INTEGER(I8P), INTENT(IN) :: X(1:,1:) !< DATA VARIABLE. - LOGICAL, INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT. - LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". - INTEGER(I4P) :: ERROR !< ERROR STATUS. - CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. - INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. - CHARACTER(LEN=:), ALLOCATABLE :: CODE !< DATA VARIABLE ENCODED, BINARY OR BASE64 CODEC. - - DATA_TYPE = 'Int64' - N_COMPONENTS = SIZE(X, DIM=1) - IF (PRESENT(ONE_COMPONENT)) THEN - IF (ONE_COMPONENT) N_COMPONENTS = 1 - ENDIF - CODE = ENCODE_BINARY_DATAARRAY(X=X) - CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, & - IS_TUPLES=IS_TUPLES) - ERROR = SELF%ERROR - ENDFUNCTION W_DATA1_RANK2_I8P - - FUNCTION W_DATA1_RANK2_I4P(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR) - !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (I4P). - CLASS(XML_WRITER_BINARY_LOCAL), INTENT(INOUT) :: SELF !< WRITER. - CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. - INTEGER(I4P), INTENT(IN) :: X(1:,1:) !< DATA VARIABLE. - LOGICAL, INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT. - LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". - INTEGER(I4P) :: ERROR !< ERROR STATUS. - CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. - INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. - CHARACTER(LEN=:), ALLOCATABLE :: CODE !< DATA VARIABLE ENCODED, BINARY OR BASE64 CODEC. - - DATA_TYPE = 'Int32' - N_COMPONENTS = SIZE(X, DIM=1) - IF (PRESENT(ONE_COMPONENT)) THEN - IF (ONE_COMPONENT) N_COMPONENTS = 1 - ENDIF - CODE = ENCODE_BINARY_DATAARRAY(X=X) - CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, & - IS_TUPLES=IS_TUPLES) - ERROR = SELF%ERROR - ENDFUNCTION W_DATA1_RANK2_I4P - - FUNCTION W_DATA1_RANK2_I2P(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR) - !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (I2P). - CLASS(XML_WRITER_BINARY_LOCAL), INTENT(INOUT) :: SELF !< WRITER. - CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. - INTEGER(I2P), INTENT(IN) :: X(1:,1:) !< DATA VARIABLE. - LOGICAL, INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT. - LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". - INTEGER(I4P) :: ERROR !< ERROR STATUS. - CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. - INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. - CHARACTER(LEN=:), ALLOCATABLE :: CODE !< DATA VARIABLE ENCODED, BINARY OR BASE64 CODEC. - - DATA_TYPE = 'Int16' - N_COMPONENTS = SIZE(X, DIM=1) - IF (PRESENT(ONE_COMPONENT)) THEN - IF (ONE_COMPONENT) N_COMPONENTS = 1 - ENDIF - CODE = ENCODE_BINARY_DATAARRAY(X=X) - CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, & - IS_TUPLES=IS_TUPLES) - ERROR = SELF%ERROR - ENDFUNCTION W_DATA1_RANK2_I2P - - FUNCTION W_DATA1_RANK2_I1P(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR) - !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (I1P). - CLASS(XML_WRITER_BINARY_LOCAL), INTENT(INOUT) :: SELF !< WRITER. - CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. - INTEGER(I1P), INTENT(IN) :: X(1:,1:) !< DATA VARIABLE. - LOGICAL, INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT. - LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". - INTEGER(I4P) :: ERROR !< ERROR STATUS. - CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. - INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. - CHARACTER(LEN=:), ALLOCATABLE :: CODE !< DATA VARIABLE ENCODED, BINARY OR BASE64 CODEC. - - DATA_TYPE = 'Int8' - N_COMPONENTS = SIZE(X, DIM=1) - IF (PRESENT(ONE_COMPONENT)) THEN - IF (ONE_COMPONENT) N_COMPONENTS = 1 - ENDIF - CODE = ENCODE_BINARY_DATAARRAY(X=X) - CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, & - IS_TUPLES=IS_TUPLES) - ERROR = SELF%ERROR - ENDFUNCTION W_DATA1_RANK2_I1P - - FUNCTION W_DATA1_RANK3_R8P(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR) - !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (R8P). - CLASS(XML_WRITER_BINARY_LOCAL), INTENT(INOUT) :: SELF !< WRITER. - CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. - REAL(R8P), INTENT(IN) :: X(1:,1:,1:) !< DATA VARIABLE. - LOGICAL, INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT. - LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". - INTEGER(I4P) :: ERROR !< ERROR STATUS. - CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. - INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. - CHARACTER(LEN=:), ALLOCATABLE :: CODE !< DATA VARIABLE ENCODED, BINARY OR BASE64 CODEC. - - DATA_TYPE = 'Float64' - N_COMPONENTS = SIZE(X, DIM=1) - IF (PRESENT(ONE_COMPONENT)) THEN - IF (ONE_COMPONENT) N_COMPONENTS = 1 - ENDIF - CODE = ENCODE_BINARY_DATAARRAY(X=X) - CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, & - IS_TUPLES=IS_TUPLES) - ERROR = SELF%ERROR - ENDFUNCTION W_DATA1_RANK3_R8P - - FUNCTION W_DATA1_RANK3_R4P(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR) - !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (R4P). - CLASS(XML_WRITER_BINARY_LOCAL), INTENT(INOUT) :: SELF !< WRITER. - CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. - REAL(R4P), INTENT(IN) :: X(1:,1:,1:) !< DATA VARIABLE. - LOGICAL, INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT. - LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". - INTEGER(I4P) :: ERROR !< ERROR STATUS. - CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. - INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. - CHARACTER(LEN=:), ALLOCATABLE :: CODE !< DATA VARIABLE ENCODED, BINARY OR BASE64 CODEC. - - DATA_TYPE = 'Float32' - N_COMPONENTS = SIZE(X, DIM=1) - IF (PRESENT(ONE_COMPONENT)) THEN - IF (ONE_COMPONENT) N_COMPONENTS = 1 - ENDIF - CODE = ENCODE_BINARY_DATAARRAY(X=X) - CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, & - IS_TUPLES=IS_TUPLES) - ERROR = SELF%ERROR - ENDFUNCTION W_DATA1_RANK3_R4P - - FUNCTION W_DATA1_RANK3_I8P(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR) - !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (I8P). - CLASS(XML_WRITER_BINARY_LOCAL), INTENT(INOUT) :: SELF !< WRITER. - CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. - INTEGER(I8P), INTENT(IN) :: X(1:,1:,1:) !< DATA VARIABLE. - LOGICAL, INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT. - LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". - INTEGER(I4P) :: ERROR !< ERROR STATUS. - CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. - INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. - CHARACTER(LEN=:), ALLOCATABLE :: CODE !< DATA VARIABLE ENCODED, BINARY OR BASE64 CODEC. - - DATA_TYPE = 'Int64' - N_COMPONENTS = SIZE(X, DIM=1) - IF (PRESENT(ONE_COMPONENT)) THEN - IF (ONE_COMPONENT) N_COMPONENTS = 1 - ENDIF - CODE = ENCODE_BINARY_DATAARRAY(X=X) - CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, & - IS_TUPLES=IS_TUPLES) - ERROR = SELF%ERROR - ENDFUNCTION W_DATA1_RANK3_I8P - - FUNCTION W_DATA1_RANK3_I4P(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR) - !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (I4P). - CLASS(XML_WRITER_BINARY_LOCAL), INTENT(INOUT) :: SELF !< WRITER. - CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. - INTEGER(I4P), INTENT(IN) :: X(1:,1:,1:) !< DATA VARIABLE. - LOGICAL, INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT. - LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". - INTEGER(I4P) :: ERROR !< ERROR STATUS. - CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. - INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. - CHARACTER(LEN=:), ALLOCATABLE :: CODE !< DATA VARIABLE ENCODED, BINARY OR BASE64 CODEC. + IF (SELF%ENCODING=='raw') THEN + SELECT CASE(DATAARRAY_TYPE) + CASE('R8') + WRITE(UNIT=SELF%XML, IOSTAT=SELF%ERROR)N_BYTE, DATAARRAY_R8P + DEALLOCATE(DATAARRAY_R8P) + CASE('R4') + WRITE(UNIT=SELF%XML, IOSTAT=SELF%ERROR)N_BYTE, DATAARRAY_R4P + DEALLOCATE(DATAARRAY_R4P) + CASE('I8') + WRITE(UNIT=SELF%XML, IOSTAT=SELF%ERROR)N_BYTE, DATAARRAY_I8P + DEALLOCATE(DATAARRAY_I8P) + CASE('I4') + WRITE(UNIT=SELF%XML, IOSTAT=SELF%ERROR)N_BYTE, DATAARRAY_I4P + DEALLOCATE(DATAARRAY_I4P) + CASE('I2') + WRITE(UNIT=SELF%XML, IOSTAT=SELF%ERROR)N_BYTE, DATAARRAY_I2P + DEALLOCATE(DATAARRAY_I2P) + CASE('I1') + WRITE(UNIT=SELF%XML, IOSTAT=SELF%ERROR)N_BYTE, DATAARRAY_I1P + DEALLOCATE(DATAARRAY_I1P) + ENDSELECT + ELSE + SELECT CASE(DATAARRAY_TYPE) + CASE('R8') + CODE = ENCODE_BINARY_DATAARRAY(X=DATAARRAY_R8P) + WRITE(UNIT=SELF%XML, IOSTAT=SELF%ERROR)CODE + CASE('R4') + CODE = ENCODE_BINARY_DATAARRAY(X=DATAARRAY_R4P) + WRITE(UNIT=SELF%XML, IOSTAT=SELF%ERROR)CODE + CASE('I8') + CODE = ENCODE_BINARY_DATAARRAY(X=DATAARRAY_I8P) + WRITE(UNIT=SELF%XML, IOSTAT=SELF%ERROR)CODE + CASE('I4') + CODE = ENCODE_BINARY_DATAARRAY(X=DATAARRAY_I4P) + WRITE(UNIT=SELF%XML, IOSTAT=SELF%ERROR)CODE + CASE('I2') + CODE = ENCODE_BINARY_DATAARRAY(X=DATAARRAY_I2P) + WRITE(UNIT=SELF%XML, IOSTAT=SELF%ERROR)CODE + CASE('I1') + CODE = ENCODE_BINARY_DATAARRAY(X=DATAARRAY_I1P) + WRITE(UNIT=SELF%XML, IOSTAT=SELF%ERROR)CODE + ENDSELECT + ENDIF + ENDSUBROUTINE W_DATA_ON_XML + ENDSUBROUTINE W_DATA_APPENDED - DATA_TYPE = 'Int32' - N_COMPONENTS = SIZE(X, DIM=1) - IF (PRESENT(ONE_COMPONENT)) THEN - IF (ONE_COMPONENT) N_COMPONENTS = 1 - ENDIF - CODE = ENCODE_BINARY_DATAARRAY(X=X) - CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, & - IS_TUPLES=IS_TUPLES) - ERROR = SELF%ERROR - ENDFUNCTION W_DATA1_RANK3_I4P + ! WRITE_ON_SCRATCH_DATAARRAY METHODS + FUNCTION WRITE_ON_SCRATCH_DATAARRAY1_RANK1(SELF, X) RESULT(N_BYTE) + !< WRITE A DATAARRAY WITH 1 COMPONENTS OF RANK 1. + CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF !< WRITER. + CLASS(*), INTENT(IN) :: X(1:) !< DATA VARIABLE. + INTEGER(I4P) :: N_BYTE !< NUMBER OF BYTES + INTEGER(I4P) :: NN !< NUMBER OF ELEMENTS. - FUNCTION W_DATA1_RANK3_I2P(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR) - !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (I2P). - CLASS(XML_WRITER_BINARY_LOCAL), INTENT(INOUT) :: SELF !< WRITER. - CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. - INTEGER(I2P), INTENT(IN) :: X(1:,1:,1:) !< DATA VARIABLE. - LOGICAL, INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT. - LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". - INTEGER(I4P) :: ERROR !< ERROR STATUS. - CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. - INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. - CHARACTER(LEN=:), ALLOCATABLE :: CODE !< DATA VARIABLE ENCODED, BINARY OR BASE64 CODEC. + NN = SIZE(X, DIM=1) + SELECT TYPE(X) + TYPE IS(REAL(R8P)) + N_BYTE = NN*BYR8P + WRITE(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)N_BYTE, 'R8', NN + WRITE(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)X + TYPE IS(REAL(R4P)) + N_BYTE = NN*BYR4P + WRITE(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)N_BYTE, 'R4', NN + WRITE(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)X + TYPE IS(INTEGER(I8P)) + N_BYTE = NN*BYI8P + WRITE(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)N_BYTE, 'I8', NN + WRITE(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)X + TYPE IS(INTEGER(I4P)) + N_BYTE = NN*BYI4P + WRITE(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)N_BYTE, 'I4', NN + WRITE(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)X + TYPE IS(INTEGER(I2P)) + N_BYTE = NN*BYI2P + WRITE(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)N_BYTE, 'I2', NN + WRITE(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)X + TYPE IS(INTEGER(I1P)) + N_BYTE = NN*BYI1P + WRITE(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)N_BYTE, 'I1', NN + WRITE(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)X + ENDSELECT + ENDFUNCTION WRITE_ON_SCRATCH_DATAARRAY1_RANK1 - DATA_TYPE = 'Int16' - N_COMPONENTS = SIZE(X, DIM=1) - IF (PRESENT(ONE_COMPONENT)) THEN - IF (ONE_COMPONENT) N_COMPONENTS = 1 - ENDIF - CODE = ENCODE_BINARY_DATAARRAY(X=X) - CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, & - IS_TUPLES=IS_TUPLES) - ERROR = SELF%ERROR - ENDFUNCTION W_DATA1_RANK3_I2P + FUNCTION WRITE_ON_SCRATCH_DATAARRAY3_RANK1_R8P(SELF, X, Y, Z) RESULT(N_BYTE) + !< WRITE A DATAARRAY WITH 3 COMPONENTS OF RANK 1 (R8P). + CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF !< WRITER. + REAL(R8P), INTENT(IN) :: X(1:) !< X COMPONENT. + REAL(R8P), INTENT(IN) :: Y(1:) !< Y COMPONENT. + REAL(R8P), INTENT(IN) :: Z(1:) !< Z COMPONENT. + INTEGER(I4P) :: N_BYTE !< NUMBER OF BYTES + INTEGER(I4P) :: N !< COUNTER. - FUNCTION W_DATA1_RANK3_I1P(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR) - !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (I1P). - CLASS(XML_WRITER_BINARY_LOCAL), INTENT(INOUT) :: SELF !< WRITER. - CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. - INTEGER(I1P), INTENT(IN) :: X(1:,1:,1:) !< DATA VARIABLE. - LOGICAL, INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT. - LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". - INTEGER(I4P) :: ERROR !< ERROR STATUS. - CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. - INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. - CHARACTER(LEN=:), ALLOCATABLE :: CODE !< DATA VARIABLE ENCODED, BINARY OR BASE64 CODEC. + N_BYTE = SELF%WRITE_ON_SCRATCH_DATAARRAY(X=[(X(N), Y(N), Z(N), N=1,SIZE(X, DIM=1))]) + ENDFUNCTION WRITE_ON_SCRATCH_DATAARRAY3_RANK1_R8P - DATA_TYPE = 'Int8' - N_COMPONENTS = SIZE(X, DIM=1) - IF (PRESENT(ONE_COMPONENT)) THEN - IF (ONE_COMPONENT) N_COMPONENTS = 1 - ENDIF - CODE = ENCODE_BINARY_DATAARRAY(X=X) - CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, & - IS_TUPLES=IS_TUPLES) - ERROR = SELF%ERROR - ENDFUNCTION W_DATA1_RANK3_I1P - - FUNCTION W_DATA1_RANK4_R8P(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR) - !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (R8P). - CLASS(XML_WRITER_BINARY_LOCAL), INTENT(INOUT) :: SELF !< WRITER. - CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. - REAL(R8P), INTENT(IN) :: X(1:,1:,1:,1:) !< DATA VARIABLE. - LOGICAL, INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT. - LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". - INTEGER(I4P) :: ERROR !< ERROR STATUS. - CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. - INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. - CHARACTER(LEN=:), ALLOCATABLE :: CODE !< DATA VARIABLE ENCODED, BINARY OR BASE64 CODEC. + FUNCTION WRITE_ON_SCRATCH_DATAARRAY3_RANK1_R4P(SELF, X, Y, Z) RESULT(N_BYTE) + !< WRITE A DATAARRAY WITH 3 COMPONENTS OF RANK 1 (R4P). + CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF !< WRITER. + REAL(R4P), INTENT(IN) :: X(1:) !< X COMPONENT. + REAL(R4P), INTENT(IN) :: Y(1:) !< Y COMPONENT. + REAL(R4P), INTENT(IN) :: Z(1:) !< Z COMPONENT. + INTEGER(I4P) :: N_BYTE !< NUMBER OF BYTES + INTEGER(I4P) :: N !< COUNTER. - DATA_TYPE = 'Float64' - N_COMPONENTS = SIZE(X, DIM=1) - IF (PRESENT(ONE_COMPONENT)) THEN - IF (ONE_COMPONENT) N_COMPONENTS = 1 - ENDIF - CODE = ENCODE_BINARY_DATAARRAY(X=X) - CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, & - IS_TUPLES=IS_TUPLES) - ERROR = SELF%ERROR - ENDFUNCTION W_DATA1_RANK4_R8P - - FUNCTION W_DATA1_RANK4_R4P(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR) - !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (R4P). - CLASS(XML_WRITER_BINARY_LOCAL), INTENT(INOUT) :: SELF !< WRITER. - CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. - REAL(R4P), INTENT(IN) :: X(1:,1:,1:,1:) !< DATA VARIABLE. - LOGICAL, INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT. - LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". - INTEGER(I4P) :: ERROR !< ERROR STATUS. - CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. - INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. - CHARACTER(LEN=:), ALLOCATABLE :: CODE !< DATA VARIABLE ENCODED, BINARY OR BASE64 CODEC. + N_BYTE = SELF%WRITE_ON_SCRATCH_DATAARRAY(X=[(X(N), Y(N), Z(N), N=1,SIZE(X, DIM=1))]) + ENDFUNCTION WRITE_ON_SCRATCH_DATAARRAY3_RANK1_R4P - DATA_TYPE = 'Float32' - N_COMPONENTS = SIZE(X, DIM=1) - IF (PRESENT(ONE_COMPONENT)) THEN - IF (ONE_COMPONENT) N_COMPONENTS = 1 - ENDIF - CODE = ENCODE_BINARY_DATAARRAY(X=X) - CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, & - IS_TUPLES=IS_TUPLES) - ERROR = SELF%ERROR - ENDFUNCTION W_DATA1_RANK4_R4P - - FUNCTION W_DATA1_RANK4_I8P(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR) - !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (I8P). - CLASS(XML_WRITER_BINARY_LOCAL), INTENT(INOUT) :: SELF !< WRITER. - CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. - INTEGER(I8P), INTENT(IN) :: X(1:,1:,1:,1:) !< DATA VARIABLE. - LOGICAL, INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT. - LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". - INTEGER(I4P) :: ERROR !< ERROR STATUS. - CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. - INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. - CHARACTER(LEN=:), ALLOCATABLE :: CODE !< DATA VARIABLE ENCODED, BINARY OR BASE64 CODEC. + FUNCTION WRITE_ON_SCRATCH_DATAARRAY3_RANK1_I8P(SELF, X, Y, Z) RESULT(N_BYTE) + !< WRITE A DATAARRAY WITH 3 COMPONENTS OF RANK 1 (I8P). + CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF !< WRITER. + INTEGER(I8P), INTENT(IN) :: X(1:) !< X COMPONENT. + INTEGER(I8P), INTENT(IN) :: Y(1:) !< Y COMPONENT. + INTEGER(I8P), INTENT(IN) :: Z(1:) !< Z COMPONENT. + INTEGER(I4P) :: N_BYTE !< NUMBER OF BYTES + INTEGER(I4P) :: N !< COUNTER. - DATA_TYPE = 'Int64' - N_COMPONENTS = SIZE(X, DIM=1) - IF (PRESENT(ONE_COMPONENT)) THEN - IF (ONE_COMPONENT) N_COMPONENTS = 1 - ENDIF - CODE = ENCODE_BINARY_DATAARRAY(X=X) - CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, & - IS_TUPLES=IS_TUPLES) - ERROR = SELF%ERROR - ENDFUNCTION W_DATA1_RANK4_I8P - - FUNCTION W_DATA1_RANK4_I4P(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR) - !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (I4P). - CLASS(XML_WRITER_BINARY_LOCAL), INTENT(INOUT) :: SELF !< WRITER. - CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. - INTEGER(I4P), INTENT(IN) :: X(1:,1:,1:,1:) !< DATA VARIABLE. - LOGICAL, INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT. - LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". - INTEGER(I4P) :: ERROR !< ERROR STATUS. - CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. - INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. - CHARACTER(LEN=:), ALLOCATABLE :: CODE !< DATA VARIABLE ENCODED, BINARY OR BASE64 CODEC. + N_BYTE = SELF%WRITE_ON_SCRATCH_DATAARRAY(X=[(X(N), Y(N), Z(N), N=1,SIZE(X, DIM=1))]) + ENDFUNCTION WRITE_ON_SCRATCH_DATAARRAY3_RANK1_I8P - DATA_TYPE = 'Int32' - N_COMPONENTS = SIZE(X, DIM=1) - IF (PRESENT(ONE_COMPONENT)) THEN - IF (ONE_COMPONENT) N_COMPONENTS = 1 - ENDIF - CODE = ENCODE_BINARY_DATAARRAY(X=X) - CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, & - IS_TUPLES=IS_TUPLES) - ERROR = SELF%ERROR - ENDFUNCTION W_DATA1_RANK4_I4P - - FUNCTION W_DATA1_RANK4_I2P(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR) - !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (I2P). - CLASS(XML_WRITER_BINARY_LOCAL), INTENT(INOUT) :: SELF !< WRITER. - CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. - INTEGER(I2P), INTENT(IN) :: X(1:,1:,1:,1:) !< DATA VARIABLE. - LOGICAL, INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT. - LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". - INTEGER(I4P) :: ERROR !< ERROR STATUS. - CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. - INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. - CHARACTER(LEN=:), ALLOCATABLE :: CODE !< DATA VARIABLE ENCODED, BINARY OR BASE64 CODEC. + FUNCTION WRITE_ON_SCRATCH_DATAARRAY3_RANK1_I4P(SELF, X, Y, Z) RESULT(N_BYTE) + !< WRITE A DATAARRAY WITH 3 COMPONENTS OF RANK 1 (I4P). + CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF !< WRITER. + INTEGER(I4P), INTENT(IN) :: X(1:) !< X COMPONENT. + INTEGER(I4P), INTENT(IN) :: Y(1:) !< Y COMPONENT. + INTEGER(I4P), INTENT(IN) :: Z(1:) !< Z COMPONENT. + INTEGER(I4P) :: N_BYTE !< NUMBER OF BYTES + INTEGER(I4P) :: N !< COUNTER. - DATA_TYPE = 'Int16' - N_COMPONENTS = SIZE(X, DIM=1) - IF (PRESENT(ONE_COMPONENT)) THEN - IF (ONE_COMPONENT) N_COMPONENTS = 1 - ENDIF - CODE = ENCODE_BINARY_DATAARRAY(X=X) - CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, & - IS_TUPLES=IS_TUPLES) - ERROR = SELF%ERROR - ENDFUNCTION W_DATA1_RANK4_I2P - - FUNCTION W_DATA1_RANK4_I1P(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR) - !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (I1P). - CLASS(XML_WRITER_BINARY_LOCAL), INTENT(INOUT) :: SELF !< WRITER. - CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. - INTEGER(I1P), INTENT(IN) :: X(1:,1:,1:,1:) !< DATA VARIABLE. - LOGICAL, INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT. - LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". - INTEGER(I4P) :: ERROR !< ERROR STATUS. - CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. - INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. - CHARACTER(LEN=:), ALLOCATABLE :: CODE !< DATA VARIABLE ENCODED, BINARY OR BASE64 CODEC. + N_BYTE = SELF%WRITE_ON_SCRATCH_DATAARRAY(X=[(X(N), Y(N), Z(N), N=1,SIZE(X, DIM=1))]) + ENDFUNCTION WRITE_ON_SCRATCH_DATAARRAY3_RANK1_I4P - DATA_TYPE = 'Int8' - N_COMPONENTS = SIZE(X, DIM=1) - IF (PRESENT(ONE_COMPONENT)) THEN - IF (ONE_COMPONENT) N_COMPONENTS = 1 - ENDIF - CODE = ENCODE_BINARY_DATAARRAY(X=X) - CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, & - IS_TUPLES=IS_TUPLES) - ERROR = SELF%ERROR - ENDFUNCTION W_DATA1_RANK4_I1P + FUNCTION WRITE_ON_SCRATCH_DATAARRAY3_RANK1_I2P(SELF, X, Y, Z) RESULT(N_BYTE) + !< WRITE A DATAARRAY WITH 3 COMPONENTS OF RANK 1 (I2P). + CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF !< WRITER. + INTEGER(I2P), INTENT(IN) :: X(1:) !< X COMPONENT. + INTEGER(I2P), INTENT(IN) :: Y(1:) !< Y COMPONENT. + INTEGER(I2P), INTENT(IN) :: Z(1:) !< Z COMPONENT. + INTEGER(I4P) :: N_BYTE !< NUMBER OF BYTES + INTEGER(I4P) :: N !< COUNTER. - FUNCTION W_DATA3_RANK1_R8P(SELF, DATA_NAME, X, Y, Z, IS_TUPLES) RESULT(ERROR) - !< WRITE `<DATAARRAY... NumberOfComponents="3"...>...</DATAARRAY>` TAG (R8P). - CLASS(XML_WRITER_BINARY_LOCAL), INTENT(INOUT) :: SELF !< WRITER. - CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. - REAL(R8P), INTENT(IN) :: X(1:) !< X COMPONENT OF DATA VARIABLE. - REAL(R8P), INTENT(IN) :: Y(1:) !< Y COMPONENT OF DATA VARIABLE. - REAL(R8P), INTENT(IN) :: Z(1:) !< Z COMPONENT OF DATA VARIABLE. - LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". - INTEGER(I4P) :: ERROR !< ERROR STATUS. - CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. - INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. - CHARACTER(LEN=:), ALLOCATABLE :: CODE !< DATA VARIABLE ENCODED, BINARY OR BASE64 CODEC. + N_BYTE = SELF%WRITE_ON_SCRATCH_DATAARRAY(X=[(X(N), Y(N), Z(N), N=1,SIZE(X, DIM=1))]) + ENDFUNCTION WRITE_ON_SCRATCH_DATAARRAY3_RANK1_I2P - DATA_TYPE = 'Float64' - N_COMPONENTS = 3 - CODE = ENCODE_BINARY_DATAARRAY(X=X, Y=Y, Z=Z) - CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, & - IS_TUPLES=IS_TUPLES) - ERROR = SELF%ERROR - ENDFUNCTION W_DATA3_RANK1_R8P + FUNCTION WRITE_ON_SCRATCH_DATAARRAY3_RANK1_I1P(SELF, X, Y, Z) RESULT(N_BYTE) + !< WRITE A DATAARRAY WITH 3 COMPONENTS OF RANK 1 (I1P). + CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF !< WRITER. + INTEGER(I1P), INTENT(IN) :: X(1:) !< X COMPONENT. + INTEGER(I1P), INTENT(IN) :: Y(1:) !< Y COMPONENT. + INTEGER(I1P), INTENT(IN) :: Z(1:) !< Z COMPONENT. + INTEGER(I4P) :: N_BYTE !< NUMBER OF BYTES + INTEGER(I4P) :: N !< COUNTER. - FUNCTION W_DATA3_RANK1_R4P(SELF, DATA_NAME, X, Y, Z, IS_TUPLES) RESULT(ERROR) - !< WRITE `<DATAARRAY... NumberOfComponents="3"...>...</DATAARRAY>` TAG (R4P). - CLASS(XML_WRITER_BINARY_LOCAL), INTENT(INOUT) :: SELF !< WRITER. - CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. - REAL(R4P), INTENT(IN) :: X(1:) !< X COMPONENT OF DATA VARIABLE. - REAL(R4P), INTENT(IN) :: Y(1:) !< Y COMPONENT OF DATA VARIABLE. - REAL(R4P), INTENT(IN) :: Z(1:) !< Z COMPONENT OF DATA VARIABLE. - LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". - INTEGER(I4P) :: ERROR !< ERROR STATUS. - CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. - INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. - CHARACTER(LEN=:), ALLOCATABLE :: CODE !< DATA VARIABLE ENCODED, BINARY OR BASE64 CODEC. + N_BYTE = SELF%WRITE_ON_SCRATCH_DATAARRAY(X=[(X(N), Y(N), Z(N), N=1,SIZE(X, DIM=1))]) + ENDFUNCTION WRITE_ON_SCRATCH_DATAARRAY3_RANK1_I1P + +ENDMODULE VTKF_FILE_XML_WRITER_APPENDED - DATA_TYPE = 'Float32' - N_COMPONENTS = 3 - CODE = ENCODE_BINARY_DATAARRAY(X=X, Y=Y, Z=Z) - CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, & - IS_TUPLES=IS_TUPLES) - ERROR = SELF%ERROR - ENDFUNCTION W_DATA3_RANK1_R4P - FUNCTION W_DATA3_RANK1_I8P(SELF, DATA_NAME, X, Y, Z, IS_TUPLES) RESULT(ERROR) - !< WRITE `<DATAARRAY... NumberOfComponents="3"...>...</DATAARRAY>` TAG (I8P). - CLASS(XML_WRITER_BINARY_LOCAL), INTENT(INOUT) :: SELF !< WRITER. - CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. - INTEGER(I8P), INTENT(IN) :: X(1:) !< X COMPONENT OF DATA VARIABLE. - INTEGER(I8P), INTENT(IN) :: Y(1:) !< Y COMPONENT OF DATA VARIABLE. - INTEGER(I8P), INTENT(IN) :: Z(1:) !< Z COMPONENT OF DATA VARIABLE. - LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". - INTEGER(I4P) :: ERROR !< ERROR STATUS. - CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. - INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. - CHARACTER(LEN=:), ALLOCATABLE :: CODE !< DATA VARIABLE ENCODED, BINARY OR BASE64 CODEC. - DATA_TYPE = 'Int64' - N_COMPONENTS = 3 - CODE = ENCODE_BINARY_DATAARRAY(X=X, Y=Y, Z=Z) - CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, & - IS_TUPLES=IS_TUPLES) - ERROR = SELF%ERROR - ENDFUNCTION W_DATA3_RANK1_I8P - FUNCTION W_DATA3_RANK1_I4P(SELF, DATA_NAME, X, Y, Z, IS_TUPLES) RESULT(ERROR) - !< WRITE `<DATAARRAY... NumberOfComponents="3"...>...</DATAARRAY>` TAG (I4P). - CLASS(XML_WRITER_BINARY_LOCAL), INTENT(INOUT) :: SELF !< WRITER. - CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. - INTEGER(I4P), INTENT(IN) :: X(1:) !< X COMPONENT OF DATA VARIABLE. - INTEGER(I4P), INTENT(IN) :: Y(1:) !< Y COMPONENT OF DATA VARIABLE. - INTEGER(I4P), INTENT(IN) :: Z(1:) !< Z COMPONENT OF DATA VARIABLE. - LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". - INTEGER(I4P) :: ERROR !< ERROR STATUS. - CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. - INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. - CHARACTER(LEN=:), ALLOCATABLE :: CODE !< DATA VARIABLE ENCODED, BINARY OR BASE64 CODEC. +!< VTK FILE XML WRITER, BINARY LOCAL. +MODULE VTKF_FILE_XML_WRITER_BINARY_LOCAL +!< VTK FILE XML WRITER, BINARY LOCAL. +!< +!< THIS WRITER IS (CURRENTLY) THE ONLY ONE ABLE ALSO TO CREATE A *VOLATILE* FILE (ENABLING VOLATILE OPTION). +!< INSTEAD OF SAVING DATA INTO A REAL FILE ON THE SYSTEM, THIS WRITER CAN SAVE DATA INTO A (VOLATILE) CHARACTERS STRING THAT CAN BE +!< USED ALSO ON (SLAVE) PROCESSES THAT HAVE NOT ACCESS TO FILESYSTEM: THE VOLATILE STRING CAN BE EASILY SENT TO OTHER (MASTER) +!< PROCESSES HAVING ACCESS TO FILESYTEM. THE VOLATILE WRITER MODE IS DESIGNED TO FACILITATE THE USE OF THE LIBRARY IN PARALLEL +!< ENVINROMENTS WEHERE NOT ALL PROCESSES/THREADS HAVE ACCESS TO FILESYSTEM. +USE PENF +USE STRINGIFOR +USE VTK_FORTRAN_DATAARRAY_ENCODER +USE VTKF_FILE_XML_WRITER_ABSTRACT - DATA_TYPE = 'Int32' - N_COMPONENTS = 3 - CODE = ENCODE_BINARY_DATAARRAY(X=X, Y=Y, Z=Z) - CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, & - IS_TUPLES=IS_TUPLES) - ERROR = SELF%ERROR - ENDFUNCTION W_DATA3_RANK1_I4P +IMPLICIT NONE +PRIVATE +PUBLIC :: XML_WRITER_BINARY_LOCAL - FUNCTION W_DATA3_RANK1_I2P(SELF, DATA_NAME, X, Y, Z, IS_TUPLES) RESULT(ERROR) - !< WRITE `<DATAARRAY... NumberOfComponents="3"...>...</DATAARRAY>` TAG (I2P). - CLASS(XML_WRITER_BINARY_LOCAL), INTENT(INOUT) :: SELF !< WRITER. - CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. - INTEGER(I2P), INTENT(IN) :: X(1:) !< X COMPONENT OF DATA VARIABLE. - INTEGER(I2P), INTENT(IN) :: Y(1:) !< Y COMPONENT OF DATA VARIABLE. - INTEGER(I2P), INTENT(IN) :: Z(1:) !< Z COMPONENT OF DATA VARIABLE. - LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". - INTEGER(I4P) :: ERROR !< ERROR STATUS. - CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. - INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. - CHARACTER(LEN=:), ALLOCATABLE :: CODE !< DATA VARIABLE ENCODED, BINARY OR BASE64 CODEC. +TYPE, EXTENDS(XML_WRITER_ABSTRACT) :: XML_WRITER_BINARY_LOCAL + !< VTK FILE XML WRITER, BINARY LOCAL. + CONTAINS + ! DEFERRED METHODS + PROCEDURE, PASS(SELF) :: INITIALIZE !< INITIALIZE WRITER. + PROCEDURE, PASS(SELF) :: FINALIZE !< FINALIZE WRITER. + PROCEDURE, PASS(SELF) :: W_DATA1_RANK1_R8P !< WRITE DATAARRAY 1, RANK 1, R8P. + PROCEDURE, PASS(SELF) :: W_DATA1_RANK1_R4P !< WRITE DATAARRAY 1, RANK 1, R4P. + PROCEDURE, PASS(SELF) :: W_DATA1_RANK1_I8P !< WRITE DATAARRAY 1, RANK 1, I8P. + PROCEDURE, PASS(SELF) :: W_DATA1_RANK1_I4P !< WRITE DATAARRAY 1, RANK 1, I4P. + PROCEDURE, PASS(SELF) :: W_DATA1_RANK1_I2P !< WRITE DATAARRAY 1, RANK 1, I2P. + PROCEDURE, PASS(SELF) :: W_DATA1_RANK1_I1P !< WRITE DATAARRAY 1, RANK 1, I1P. + PROCEDURE, PASS(SELF) :: W_DATA3_RANK1_R8P !< WRITE DATAARRAY 3, RANK 1, R8P. + PROCEDURE, PASS(SELF) :: W_DATA3_RANK1_R4P !< WRITE DATAARRAY 3, RANK 1, R4P. + PROCEDURE, PASS(SELF) :: W_DATA3_RANK1_I8P !< WRITE DATAARRAY 3, RANK 1, I8P. + PROCEDURE, PASS(SELF) :: W_DATA3_RANK1_I4P !< WRITE DATAARRAY 3, RANK 1, I4P. + PROCEDURE, PASS(SELF) :: W_DATA3_RANK1_I2P !< WRITE DATAARRAY 3, RANK 1, I2P. + PROCEDURE, PASS(SELF) :: W_DATA3_RANK1_I1P !< WRITE DATAARRAY 3, RANK 1, I1P. + PROCEDURE, PASS(SELF) :: W_DATA_APPENDED !< WRITE APPENDED. +ENDTYPE XML_WRITER_BINARY_LOCAL +CONTAINS + FUNCTION INITIALIZE(SELF, FORMAT, FILENAME, MESH_TOPOLOGY, NX1, NX2, NY1, NY2, NZ1, NZ2, & + IS_VOLATILE, MESH_KIND) RESULT(ERROR) + !< INITIALIZE WRITER. + CLASS(XML_WRITER_BINARY_LOCAL), INTENT(INOUT) :: SELF !< WRITER. + CHARACTER(*), INTENT(IN) :: FORMAT !< FILE FORMAT: BINARY. + CHARACTER(*), INTENT(IN) :: FILENAME !< FILE NAME. + CHARACTER(*), INTENT(IN) :: MESH_TOPOLOGY !< MESH TOPOLOGY. + INTEGER(I4P), INTENT(IN), OPTIONAL :: NX1 !< INITIAL NODE OF X AXIS. + INTEGER(I4P), INTENT(IN), OPTIONAL :: NX2 !< FINAL NODE OF X AXIS. + INTEGER(I4P), INTENT(IN), OPTIONAL :: NY1 !< INITIAL NODE OF Y AXIS. + INTEGER(I4P), INTENT(IN), OPTIONAL :: NY2 !< FINAL NODE OF Y AXIS. + INTEGER(I4P), INTENT(IN), OPTIONAL :: NZ1 !< INITIAL NODE OF Z AXIS. + INTEGER(I4P), INTENT(IN), OPTIONAL :: NZ2 !< FINAL NODE OF Z AXIS. + CHARACTER(*), INTENT(IN), OPTIONAL :: MESH_KIND !< KIND OF MESH DATA: FLOAT64, FLOAT32, ECC. + LOGICAL, INTENT(IN), OPTIONAL :: IS_VOLATILE !< FLAG TO CHECK VOLATILE WRITER. + INTEGER(I4P) :: ERROR !< ERROR STATUS. - DATA_TYPE = 'Int16' - N_COMPONENTS = 3 - CODE = ENCODE_BINARY_DATAARRAY(X=X, Y=Y, Z=Z) - CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, & - IS_TUPLES=IS_TUPLES) + SELF%IS_VOLATILE = .FALSE. ; IF (PRESENT(IS_VOLATILE)) SELF%IS_VOLATILE = IS_VOLATILE + SELF%TOPOLOGY = TRIM(ADJUSTL(MESH_TOPOLOGY)) + SELF%FORMAT_CH = FORMAT + SELF%FORMAT_CH = SELF%FORMAT_CH%LOWER() + CALL SELF%OPEN_XML_FILE(FILENAME=FILENAME) + CALL SELF%WRITE_HEADER_TAG + CALL SELF%WRITE_TOPOLOGY_TAG(NX1=NX1, NX2=NX2, NY1=NY1, NY2=NY2, NZ1=NZ1, NZ2=NZ2, MESH_KIND=MESH_KIND) ERROR = SELF%ERROR - ENDFUNCTION W_DATA3_RANK1_I2P + ENDFUNCTION INITIALIZE - FUNCTION W_DATA3_RANK1_I1P(SELF, DATA_NAME, X, Y, Z, IS_TUPLES) RESULT(ERROR) - !< WRITE `<DATAARRAY... NumberOfComponents="3"...>...</DATAARRAY>` TAG (I1P). - CLASS(XML_WRITER_BINARY_LOCAL), INTENT(INOUT) :: SELF !< WRITER. - CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. - INTEGER(I1P), INTENT(IN) :: X(1:) !< X COMPONENT OF DATA VARIABLE. - INTEGER(I1P), INTENT(IN) :: Y(1:) !< Y COMPONENT OF DATA VARIABLE. - INTEGER(I1P), INTENT(IN) :: Z(1:) !< Z COMPONENT OF DATA VARIABLE. - LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". - INTEGER(I4P) :: ERROR !< ERROR STATUS. - CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. - INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. - CHARACTER(LEN=:), ALLOCATABLE :: CODE !< DATA VARIABLE ENCODED, BINARY OR BASE64 CODEC. + FUNCTION FINALIZE(SELF) RESULT(ERROR) + !< FINALIZE WRITER. + CLASS(XML_WRITER_BINARY_LOCAL), INTENT(INOUT) :: SELF !< WRITER. + INTEGER(I4P) :: ERROR !< ERROR STATUS. - DATA_TYPE = 'Int8' - N_COMPONENTS = 3 - CODE = ENCODE_BINARY_DATAARRAY(X=X, Y=Y, Z=Z) - CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, & - IS_TUPLES=IS_TUPLES) + CALL SELF%WRITE_END_TAG(NAME=SELF%TOPOLOGY%CHARS()) + CALL SELF%WRITE_END_TAG(NAME='VTKFile') + CALL SELF%CLOSE_XML_FILE ERROR = SELF%ERROR - ENDFUNCTION W_DATA3_RANK1_I1P + ENDFUNCTION FINALIZE - FUNCTION W_DATA3_RANK3_R8P(SELF, DATA_NAME, X, Y, Z, IS_TUPLES) RESULT(ERROR) - !< WRITE `<DATAARRAY... NumberOfComponents="3"...>...</DATAARRAY>` TAG (R8P). + ! W_DATA METHODS + FUNCTION W_DATA1_RANK1_R8P(SELF, DATA_NAME, X, IS_TUPLES) RESULT(ERROR) + !< WRITE `<DATAARRAY... NumberOfComponents="1"...>...</DATAARRAY>` TAG (R8P). CLASS(XML_WRITER_BINARY_LOCAL), INTENT(INOUT) :: SELF !< WRITER. CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. - REAL(R8P), INTENT(IN) :: X(1:,1:,1:) !< X COMPONENT OF DATA VARIABLE. - REAL(R8P), INTENT(IN) :: Y(1:,1:,1:) !< Y COMPONENT OF DATA VARIABLE. - REAL(R8P), INTENT(IN) :: Z(1:,1:,1:) !< Z COMPONENT OF DATA VARIABLE. + REAL(R8P), INTENT(IN) :: X(1:) !< DATA VARIABLE. LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". INTEGER(I4P) :: ERROR !< ERROR STATUS. CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. @@ -17806,20 +11736,18 @@ FUNCTION W_DATA3_RANK3_R8P(SELF, DATA_NAME, X, Y, Z, IS_TUPLES) RESULT(ERROR) CHARACTER(LEN=:), ALLOCATABLE :: CODE !< DATA VARIABLE ENCODED, BINARY OR BASE64 CODEC. DATA_TYPE = 'Float64' - N_COMPONENTS = 3 - CODE = ENCODE_BINARY_DATAARRAY(X=X, Y=Y, Z=Z) + N_COMPONENTS = 1 + CODE = ENCODE_BINARY_DATAARRAY(X=X) CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, & IS_TUPLES=IS_TUPLES) ERROR = SELF%ERROR - ENDFUNCTION W_DATA3_RANK3_R8P + ENDFUNCTION W_DATA1_RANK1_R8P - FUNCTION W_DATA3_RANK3_R4P(SELF, DATA_NAME, X, Y, Z, IS_TUPLES) RESULT(ERROR) - !< WRITE `<DATAARRAY... NumberOfComponents="3"...>...</DATAARRAY>` TAG (R4P). + FUNCTION W_DATA1_RANK1_R4P(SELF, DATA_NAME, X, IS_TUPLES) RESULT(ERROR) + !< WRITE `<DATAARRAY... NumberOfComponents="1"...>...</DATAARRAY>` TAG (R4P). CLASS(XML_WRITER_BINARY_LOCAL), INTENT(INOUT) :: SELF !< WRITER. CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. - REAL(R4P), INTENT(IN) :: X(1:,1:,1:) !< X COMPONENT OF DATA VARIABLE. - REAL(R4P), INTENT(IN) :: Y(1:,1:,1:) !< Y COMPONENT OF DATA VARIABLE. - REAL(R4P), INTENT(IN) :: Z(1:,1:,1:) !< Z COMPONENT OF DATA VARIABLE. + REAL(R4P), INTENT(IN) :: X(1:) !< DATA VARIABLE. LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". INTEGER(I4P) :: ERROR !< ERROR STATUS. CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. @@ -17827,20 +11755,18 @@ FUNCTION W_DATA3_RANK3_R4P(SELF, DATA_NAME, X, Y, Z, IS_TUPLES) RESULT(ERROR) CHARACTER(LEN=:), ALLOCATABLE :: CODE !< DATA VARIABLE ENCODED, BINARY OR BASE64 CODEC. DATA_TYPE = 'Float32' - N_COMPONENTS = 3 - CODE = ENCODE_BINARY_DATAARRAY(X=X, Y=Y, Z=Z) + N_COMPONENTS = 1 + CODE = ENCODE_BINARY_DATAARRAY(X=X) CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, & IS_TUPLES=IS_TUPLES) ERROR = SELF%ERROR - ENDFUNCTION W_DATA3_RANK3_R4P + ENDFUNCTION W_DATA1_RANK1_R4P - FUNCTION W_DATA3_RANK3_I8P(SELF, DATA_NAME, X, Y, Z, IS_TUPLES) RESULT(ERROR) - !< WRITE `<DATAARRAY... NumberOfComponents="3"...>...</DATAARRAY>` TAG (I8P). + FUNCTION W_DATA1_RANK1_I8P(SELF, DATA_NAME, X, IS_TUPLES) RESULT(ERROR) + !< WRITE `<DATAARRAY... NumberOfComponents="1"...>...</DATAARRAY>` TAG (I8P). CLASS(XML_WRITER_BINARY_LOCAL), INTENT(INOUT) :: SELF !< WRITER. CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. - INTEGER(I8P), INTENT(IN) :: X(1:,1:,1:) !< X COMPONENT OF DATA VARIABLE. - INTEGER(I8P), INTENT(IN) :: Y(1:,1:,1:) !< Y COMPONENT OF DATA VARIABLE. - INTEGER(I8P), INTENT(IN) :: Z(1:,1:,1:) !< Z COMPONENT OF DATA VARIABLE. + INTEGER(I8P), INTENT(IN) :: X(1:) !< DATA VARIABLE. LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". INTEGER(I4P) :: ERROR !< ERROR STATUS. CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. @@ -17848,20 +11774,18 @@ FUNCTION W_DATA3_RANK3_I8P(SELF, DATA_NAME, X, Y, Z, IS_TUPLES) RESULT(ERROR) CHARACTER(LEN=:), ALLOCATABLE :: CODE !< DATA VARIABLE ENCODED, BINARY OR BASE64 CODEC. DATA_TYPE = 'Int64' - N_COMPONENTS = 3 - CODE = ENCODE_BINARY_DATAARRAY(X=X, Y=Y, Z=Z) + N_COMPONENTS = 1 + CODE = ENCODE_BINARY_DATAARRAY(X=X) CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, & IS_TUPLES=IS_TUPLES) ERROR = SELF%ERROR - ENDFUNCTION W_DATA3_RANK3_I8P + ENDFUNCTION W_DATA1_RANK1_I8P - FUNCTION W_DATA3_RANK3_I4P(SELF, DATA_NAME, X, Y, Z, IS_TUPLES) RESULT(ERROR) - !< WRITE `<DATAARRAY... NumberOfComponents="3"...>...</DATAARRAY>` TAG (I4P). + FUNCTION W_DATA1_RANK1_I4P(SELF, DATA_NAME, X, IS_TUPLES) RESULT(ERROR) + !< WRITE `<DATAARRAY... NumberOfComponents="1"...>...</DATAARRAY>` TAG (I4P). CLASS(XML_WRITER_BINARY_LOCAL), INTENT(INOUT) :: SELF !< WRITER. CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. - INTEGER(I4P), INTENT(IN) :: X(1:,1:,1:) !< X COMPONENT OF DATA VARIABLE. - INTEGER(I4P), INTENT(IN) :: Y(1:,1:,1:) !< Y COMPONENT OF DATA VARIABLE. - INTEGER(I4P), INTENT(IN) :: Z(1:,1:,1:) !< Z COMPONENT OF DATA VARIABLE. + INTEGER(I4P), INTENT(IN) :: X(1:) !< DATA VARIABLE. LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". INTEGER(I4P) :: ERROR !< ERROR STATUS. CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. @@ -17869,20 +11793,18 @@ FUNCTION W_DATA3_RANK3_I4P(SELF, DATA_NAME, X, Y, Z, IS_TUPLES) RESULT(ERROR) CHARACTER(LEN=:), ALLOCATABLE :: CODE !< DATA VARIABLE ENCODED, BINARY OR BASE64 CODEC. DATA_TYPE = 'Int32' - N_COMPONENTS = 3 - CODE = ENCODE_BINARY_DATAARRAY(X=X, Y=Y, Z=Z) + N_COMPONENTS = 1 + CODE = ENCODE_BINARY_DATAARRAY(X=X) CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, & IS_TUPLES=IS_TUPLES) ERROR = SELF%ERROR - ENDFUNCTION W_DATA3_RANK3_I4P + ENDFUNCTION W_DATA1_RANK1_I4P - FUNCTION W_DATA3_RANK3_I2P(SELF, DATA_NAME, X, Y, Z, IS_TUPLES) RESULT(ERROR) - !< WRITE `<DATAARRAY... NumberOfComponents="3"...>...</DATAARRAY>` TAG (I2P). + FUNCTION W_DATA1_RANK1_I2P(SELF, DATA_NAME, X, IS_TUPLES) RESULT(ERROR) + !< WRITE `<DATAARRAY... NumberOfComponents="1"...>...</DATAARRAY>` TAG (I2P). CLASS(XML_WRITER_BINARY_LOCAL), INTENT(INOUT) :: SELF !< WRITER. CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. - INTEGER(I2P), INTENT(IN) :: X(1:,1:,1:) !< X COMPONENT OF DATA VARIABLE. - INTEGER(I2P), INTENT(IN) :: Y(1:,1:,1:) !< Y COMPONENT OF DATA VARIABLE. - INTEGER(I2P), INTENT(IN) :: Z(1:,1:,1:) !< Z COMPONENT OF DATA VARIABLE. + INTEGER(I2P), INTENT(IN) :: X(1:) !< DATA VARIABLE. LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". INTEGER(I4P) :: ERROR !< ERROR STATUS. CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. @@ -17890,20 +11812,18 @@ FUNCTION W_DATA3_RANK3_I2P(SELF, DATA_NAME, X, Y, Z, IS_TUPLES) RESULT(ERROR) CHARACTER(LEN=:), ALLOCATABLE :: CODE !< DATA VARIABLE ENCODED, BINARY OR BASE64 CODEC. DATA_TYPE = 'Int16' - N_COMPONENTS = 3 - CODE = ENCODE_BINARY_DATAARRAY(X=X, Y=Y, Z=Z) + N_COMPONENTS = 1 + CODE = ENCODE_BINARY_DATAARRAY(X=X) CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, & IS_TUPLES=IS_TUPLES) ERROR = SELF%ERROR - ENDFUNCTION W_DATA3_RANK3_I2P + ENDFUNCTION W_DATA1_RANK1_I2P - FUNCTION W_DATA3_RANK3_I1P(SELF, DATA_NAME, X, Y, Z, IS_TUPLES) RESULT(ERROR) - !< WRITE `<DATAARRAY... NumberOfComponents="3"...>...</DATAARRAY>` TAG (I1P). + FUNCTION W_DATA1_RANK1_I1P(SELF, DATA_NAME, X, IS_TUPLES) RESULT(ERROR) + !< WRITE `<DATAARRAY... NumberOfComponents="1"...>...</DATAARRAY>` TAG (I1P). CLASS(XML_WRITER_BINARY_LOCAL), INTENT(INOUT) :: SELF !< WRITER. CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. - INTEGER(I1P), INTENT(IN) :: X(1:,1:,1:) !< X COMPONENT OF DATA VARIABLE. - INTEGER(I1P), INTENT(IN) :: Y(1:,1:,1:) !< Y COMPONENT OF DATA VARIABLE. - INTEGER(I1P), INTENT(IN) :: Z(1:,1:,1:) !< Z COMPONENT OF DATA VARIABLE. + INTEGER(I1P), INTENT(IN) :: X(1:) !< DATA VARIABLE. LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". INTEGER(I4P) :: ERROR !< ERROR STATUS. CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. @@ -17911,20 +11831,17 @@ FUNCTION W_DATA3_RANK3_I1P(SELF, DATA_NAME, X, Y, Z, IS_TUPLES) RESULT(ERROR) CHARACTER(LEN=:), ALLOCATABLE :: CODE !< DATA VARIABLE ENCODED, BINARY OR BASE64 CODEC. DATA_TYPE = 'Int8' - N_COMPONENTS = 3 - CODE = ENCODE_BINARY_DATAARRAY(X=X, Y=Y, Z=Z) + N_COMPONENTS = 1 + CODE = ENCODE_BINARY_DATAARRAY(X=X) CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, & IS_TUPLES=IS_TUPLES) ERROR = SELF%ERROR - ENDFUNCTION W_DATA3_RANK3_I1P - - FUNCTION W_DATA6_RANK1_R8P(SELF, DATA_NAME, U, V, W, X, Y, Z, IS_TUPLES) RESULT(ERROR) - !< WRITE `<DATAARRAY... NumberOfComponents="6"...>...</DATAARRAY>` TAG (R8P). + ENDFUNCTION W_DATA1_RANK1_I1P + + FUNCTION W_DATA3_RANK1_R8P(SELF, DATA_NAME, X, Y, Z, IS_TUPLES) RESULT(ERROR) + !< WRITE `<DATAARRAY... NumberOfComponents="3"...>...</DATAARRAY>` TAG (R8P). CLASS(XML_WRITER_BINARY_LOCAL), INTENT(INOUT) :: SELF !< WRITER. CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. - REAL(R8P), INTENT(IN) :: U(1:) !< U COMPONENT OF DATA VARIABLE. - REAL(R8P), INTENT(IN) :: V(1:) !< V COMPONENT OF DATA VARIABLE. - REAL(R8P), INTENT(IN) :: W(1:) !< W COMPONENT OF DATA VARIABLE. REAL(R8P), INTENT(IN) :: X(1:) !< X COMPONENT OF DATA VARIABLE. REAL(R8P), INTENT(IN) :: Y(1:) !< Y COMPONENT OF DATA VARIABLE. REAL(R8P), INTENT(IN) :: Z(1:) !< Z COMPONENT OF DATA VARIABLE. @@ -17935,20 +11852,17 @@ FUNCTION W_DATA6_RANK1_R8P(SELF, DATA_NAME, U, V, W, X, Y, Z, IS_TUPLES) RESULT( CHARACTER(LEN=:), ALLOCATABLE :: CODE !< DATA VARIABLE ENCODED, BINARY OR BASE64 CODEC. DATA_TYPE = 'Float64' - N_COMPONENTS = 6 - CODE = ENCODE_BINARY_DATAARRAY(U=U, V=V, W=W, X=X, Y=Y, Z=Z) + N_COMPONENTS = 3 + CODE = ENCODE_BINARY_DATAARRAY(X=X, Y=Y, Z=Z) CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, & IS_TUPLES=IS_TUPLES) ERROR = SELF%ERROR - ENDFUNCTION W_DATA6_RANK1_R8P + ENDFUNCTION W_DATA3_RANK1_R8P - FUNCTION W_DATA6_RANK1_R4P(SELF, DATA_NAME, U, V, W, X, Y, Z, IS_TUPLES) RESULT(ERROR) + FUNCTION W_DATA3_RANK1_R4P(SELF, DATA_NAME, X, Y, Z, IS_TUPLES) RESULT(ERROR) !< WRITE `<DATAARRAY... NumberOfComponents="3"...>...</DATAARRAY>` TAG (R4P). CLASS(XML_WRITER_BINARY_LOCAL), INTENT(INOUT) :: SELF !< WRITER. CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. - REAL(R4P), INTENT(IN) :: U(1:) !< U COMPONENT OF DATA VARIABLE. - REAL(R4P), INTENT(IN) :: V(1:) !< V COMPONENT OF DATA VARIABLE. - REAL(R4P), INTENT(IN) :: W(1:) !< W COMPONENT OF DATA VARIABLE. REAL(R4P), INTENT(IN) :: X(1:) !< X COMPONENT OF DATA VARIABLE. REAL(R4P), INTENT(IN) :: Y(1:) !< Y COMPONENT OF DATA VARIABLE. REAL(R4P), INTENT(IN) :: Z(1:) !< Z COMPONENT OF DATA VARIABLE. @@ -17959,20 +11873,17 @@ FUNCTION W_DATA6_RANK1_R4P(SELF, DATA_NAME, U, V, W, X, Y, Z, IS_TUPLES) RESULT( CHARACTER(LEN=:), ALLOCATABLE :: CODE !< DATA VARIABLE ENCODED, BINARY OR BASE64 CODEC. DATA_TYPE = 'Float32' - N_COMPONENTS = 6 - CODE = ENCODE_BINARY_DATAARRAY(U=U, V=V, W=W, X=X, Y=Y, Z=Z) + N_COMPONENTS = 3 + CODE = ENCODE_BINARY_DATAARRAY(X=X, Y=Y, Z=Z) CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, & IS_TUPLES=IS_TUPLES) ERROR = SELF%ERROR - ENDFUNCTION W_DATA6_RANK1_R4P + ENDFUNCTION W_DATA3_RANK1_R4P - FUNCTION W_DATA6_RANK1_I8P(SELF, DATA_NAME, U, V, W, X, Y, Z, IS_TUPLES) RESULT(ERROR) + FUNCTION W_DATA3_RANK1_I8P(SELF, DATA_NAME, X, Y, Z, IS_TUPLES) RESULT(ERROR) !< WRITE `<DATAARRAY... NumberOfComponents="3"...>...</DATAARRAY>` TAG (I8P). CLASS(XML_WRITER_BINARY_LOCAL), INTENT(INOUT) :: SELF !< WRITER. CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. - INTEGER(I8P), INTENT(IN) :: U(1:) !< U COMPONENT OF DATA VARIABLE. - INTEGER(I8P), INTENT(IN) :: V(1:) !< V COMPONENT OF DATA VARIABLE. - INTEGER(I8P), INTENT(IN) :: W(1:) !< W COMPONENT OF DATA VARIABLE. INTEGER(I8P), INTENT(IN) :: X(1:) !< X COMPONENT OF DATA VARIABLE. INTEGER(I8P), INTENT(IN) :: Y(1:) !< Y COMPONENT OF DATA VARIABLE. INTEGER(I8P), INTENT(IN) :: Z(1:) !< Z COMPONENT OF DATA VARIABLE. @@ -17983,20 +11894,17 @@ FUNCTION W_DATA6_RANK1_I8P(SELF, DATA_NAME, U, V, W, X, Y, Z, IS_TUPLES) RESULT( CHARACTER(LEN=:), ALLOCATABLE :: CODE !< DATA VARIABLE ENCODED, BINARY OR BASE64 CODEC. DATA_TYPE = 'Int64' - N_COMPONENTS = 6 - CODE = ENCODE_BINARY_DATAARRAY(U=U, V=V, W=W, X=X, Y=Y, Z=Z) + N_COMPONENTS = 3 + CODE = ENCODE_BINARY_DATAARRAY(X=X, Y=Y, Z=Z) CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, & IS_TUPLES=IS_TUPLES) ERROR = SELF%ERROR - ENDFUNCTION W_DATA6_RANK1_I8P + ENDFUNCTION W_DATA3_RANK1_I8P - FUNCTION W_DATA6_RANK1_I4P(SELF, DATA_NAME, U, V, W, X, Y, Z, IS_TUPLES) RESULT(ERROR) + FUNCTION W_DATA3_RANK1_I4P(SELF, DATA_NAME, X, Y, Z, IS_TUPLES) RESULT(ERROR) !< WRITE `<DATAARRAY... NumberOfComponents="3"...>...</DATAARRAY>` TAG (I4P). CLASS(XML_WRITER_BINARY_LOCAL), INTENT(INOUT) :: SELF !< WRITER. CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. - INTEGER(I4P), INTENT(IN) :: U(1:) !< U COMPONENT OF DATA VARIABLE. - INTEGER(I4P), INTENT(IN) :: V(1:) !< V COMPONENT OF DATA VARIABLE. - INTEGER(I4P), INTENT(IN) :: W(1:) !< W COMPONENT OF DATA VARIABLE. INTEGER(I4P), INTENT(IN) :: X(1:) !< X COMPONENT OF DATA VARIABLE. INTEGER(I4P), INTENT(IN) :: Y(1:) !< Y COMPONENT OF DATA VARIABLE. INTEGER(I4P), INTENT(IN) :: Z(1:) !< Z COMPONENT OF DATA VARIABLE. @@ -18007,20 +11915,17 @@ FUNCTION W_DATA6_RANK1_I4P(SELF, DATA_NAME, U, V, W, X, Y, Z, IS_TUPLES) RESULT( CHARACTER(LEN=:), ALLOCATABLE :: CODE !< DATA VARIABLE ENCODED, BINARY OR BASE64 CODEC. DATA_TYPE = 'Int32' - N_COMPONENTS = 6 - CODE = ENCODE_BINARY_DATAARRAY(U=U, V=V, W=W, X=X, Y=Y, Z=Z) + N_COMPONENTS = 3 + CODE = ENCODE_BINARY_DATAARRAY(X=X, Y=Y, Z=Z) CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, & IS_TUPLES=IS_TUPLES) ERROR = SELF%ERROR - ENDFUNCTION W_DATA6_RANK1_I4P + ENDFUNCTION W_DATA3_RANK1_I4P - FUNCTION W_DATA6_RANK1_I2P(SELF, DATA_NAME, U, V, W, X, Y, Z, IS_TUPLES) RESULT(ERROR) + FUNCTION W_DATA3_RANK1_I2P(SELF, DATA_NAME, X, Y, Z, IS_TUPLES) RESULT(ERROR) !< WRITE `<DATAARRAY... NumberOfComponents="3"...>...</DATAARRAY>` TAG (I2P). CLASS(XML_WRITER_BINARY_LOCAL), INTENT(INOUT) :: SELF !< WRITER. CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. - INTEGER(I2P), INTENT(IN) :: U(1:) !< U COMPONENT OF DATA VARIABLE. - INTEGER(I2P), INTENT(IN) :: V(1:) !< V COMPONENT OF DATA VARIABLE. - INTEGER(I2P), INTENT(IN) :: W(1:) !< W COMPONENT OF DATA VARIABLE. INTEGER(I2P), INTENT(IN) :: X(1:) !< X COMPONENT OF DATA VARIABLE. INTEGER(I2P), INTENT(IN) :: Y(1:) !< Y COMPONENT OF DATA VARIABLE. INTEGER(I2P), INTENT(IN) :: Z(1:) !< Z COMPONENT OF DATA VARIABLE. @@ -18031,20 +11936,17 @@ FUNCTION W_DATA6_RANK1_I2P(SELF, DATA_NAME, U, V, W, X, Y, Z, IS_TUPLES) RESULT( CHARACTER(LEN=:), ALLOCATABLE :: CODE !< DATA VARIABLE ENCODED, BINARY OR BASE64 CODEC. DATA_TYPE = 'Int16' - N_COMPONENTS = 6 - CODE = ENCODE_BINARY_DATAARRAY(U=U, V=V, W=W, X=X, Y=Y, Z=Z) + N_COMPONENTS = 3 + CODE = ENCODE_BINARY_DATAARRAY(X=X, Y=Y, Z=Z) CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, & IS_TUPLES=IS_TUPLES) ERROR = SELF%ERROR - ENDFUNCTION W_DATA6_RANK1_I2P + ENDFUNCTION W_DATA3_RANK1_I2P - FUNCTION W_DATA6_RANK1_I1P(SELF, DATA_NAME, U, V, W, X, Y, Z, IS_TUPLES) RESULT(ERROR) + FUNCTION W_DATA3_RANK1_I1P(SELF, DATA_NAME, X, Y, Z, IS_TUPLES) RESULT(ERROR) !< WRITE `<DATAARRAY... NumberOfComponents="3"...>...</DATAARRAY>` TAG (I1P). CLASS(XML_WRITER_BINARY_LOCAL), INTENT(INOUT) :: SELF !< WRITER. CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. - INTEGER(I1P), INTENT(IN) :: U(1:) !< U COMPONENT OF DATA VARIABLE. - INTEGER(I1P), INTENT(IN) :: V(1:) !< V COMPONENT OF DATA VARIABLE. - INTEGER(I1P), INTENT(IN) :: W(1:) !< W COMPONENT OF DATA VARIABLE. INTEGER(I1P), INTENT(IN) :: X(1:) !< X COMPONENT OF DATA VARIABLE. INTEGER(I1P), INTENT(IN) :: Y(1:) !< Y COMPONENT OF DATA VARIABLE. INTEGER(I1P), INTENT(IN) :: Z(1:) !< Z COMPONENT OF DATA VARIABLE. @@ -18055,157 +11957,13 @@ FUNCTION W_DATA6_RANK1_I1P(SELF, DATA_NAME, U, V, W, X, Y, Z, IS_TUPLES) RESULT( CHARACTER(LEN=:), ALLOCATABLE :: CODE !< DATA VARIABLE ENCODED, BINARY OR BASE64 CODEC. DATA_TYPE = 'Int8' - N_COMPONENTS = 6 - CODE = ENCODE_BINARY_DATAARRAY(U=U, V=V, W=W, X=X, Y=Y, Z=Z) - CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, & - IS_TUPLES=IS_TUPLES) - ERROR = SELF%ERROR - ENDFUNCTION W_DATA6_RANK1_I1P - - FUNCTION W_DATA6_RANK3_R8P(SELF, DATA_NAME, U, V, W, X, Y, Z, IS_TUPLES) RESULT(ERROR) - !< WRITE `<DATAARRAY... NumberOfComponents="3"...>...</DATAARRAY>` TAG (R8P). - CLASS(XML_WRITER_BINARY_LOCAL), INTENT(INOUT) :: SELF !< WRITER. - CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. - REAL(R8P), INTENT(IN) :: U(1:,1:,1:) !< U COMPONENT OF DATA VARIABLE. - REAL(R8P), INTENT(IN) :: V(1:,1:,1:) !< V COMPONENT OF DATA VARIABLE. - REAL(R8P), INTENT(IN) :: W(1:,1:,1:) !< W COMPONENT OF DATA VARIABLE. - REAL(R8P), INTENT(IN) :: X(1:,1:,1:) !< X COMPONENT OF DATA VARIABLE. - REAL(R8P), INTENT(IN) :: Y(1:,1:,1:) !< Y COMPONENT OF DATA VARIABLE. - REAL(R8P), INTENT(IN) :: Z(1:,1:,1:) !< Z COMPONENT OF DATA VARIABLE. - LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". - INTEGER(I4P) :: ERROR !< ERROR STATUS. - CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. - INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. - CHARACTER(LEN=:), ALLOCATABLE :: CODE !< DATA VARIABLE ENCODED, BINARY OR BASE64 CODEC. - - DATA_TYPE = 'Float64' - N_COMPONENTS = 6 - CODE = ENCODE_BINARY_DATAARRAY(U=U, V=V, W=W, X=X, Y=Y, Z=Z) - CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, & - IS_TUPLES=IS_TUPLES) - ERROR = SELF%ERROR - ENDFUNCTION W_DATA6_RANK3_R8P - - FUNCTION W_DATA6_RANK3_R4P(SELF, DATA_NAME, U, V, W, X, Y, Z, IS_TUPLES) RESULT(ERROR) - !< WRITE `<DATAARRAY... NumberOfComponents="3"...>...</DATAARRAY>` TAG (R4P). - CLASS(XML_WRITER_BINARY_LOCAL), INTENT(INOUT) :: SELF !< WRITER. - CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. - REAL(R4P), INTENT(IN) :: U(1:,1:,1:) !< U COMPONENT OF DATA VARIABLE. - REAL(R4P), INTENT(IN) :: V(1:,1:,1:) !< V COMPONENT OF DATA VARIABLE. - REAL(R4P), INTENT(IN) :: W(1:,1:,1:) !< W COMPONENT OF DATA VARIABLE. - REAL(R4P), INTENT(IN) :: X(1:,1:,1:) !< X COMPONENT OF DATA VARIABLE. - REAL(R4P), INTENT(IN) :: Y(1:,1:,1:) !< Y COMPONENT OF DATA VARIABLE. - REAL(R4P), INTENT(IN) :: Z(1:,1:,1:) !< Z COMPONENT OF DATA VARIABLE. - LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". - INTEGER(I4P) :: ERROR !< ERROR STATUS. - CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. - INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. - CHARACTER(LEN=:), ALLOCATABLE :: CODE !< DATA VARIABLE ENCODED, BINARY OR BASE64 CODEC. - - DATA_TYPE = 'Float32' - N_COMPONENTS = 6 - CODE = ENCODE_BINARY_DATAARRAY(U=U, V=V, W=W, X=X, Y=Y, Z=Z) - CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, & - IS_TUPLES=IS_TUPLES) - ERROR = SELF%ERROR - ENDFUNCTION W_DATA6_RANK3_R4P - - FUNCTION W_DATA6_RANK3_I8P(SELF, DATA_NAME, U, V, W, X, Y, Z, IS_TUPLES) RESULT(ERROR) - !< WRITE `<DATAARRAY... NumberOfComponents="3"...>...</DATAARRAY>` TAG (I8P). - CLASS(XML_WRITER_BINARY_LOCAL), INTENT(INOUT) :: SELF !< WRITER. - CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. - INTEGER(I8P), INTENT(IN) :: U(1:,1:,1:) !< U COMPONENT OF DATA VARIABLE. - INTEGER(I8P), INTENT(IN) :: V(1:,1:,1:) !< V COMPONENT OF DATA VARIABLE. - INTEGER(I8P), INTENT(IN) :: W(1:,1:,1:) !< W COMPONENT OF DATA VARIABLE. - INTEGER(I8P), INTENT(IN) :: X(1:,1:,1:) !< X COMPONENT OF DATA VARIABLE. - INTEGER(I8P), INTENT(IN) :: Y(1:,1:,1:) !< Y COMPONENT OF DATA VARIABLE. - INTEGER(I8P), INTENT(IN) :: Z(1:,1:,1:) !< Z COMPONENT OF DATA VARIABLE. - LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". - INTEGER(I4P) :: ERROR !< ERROR STATUS. - CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. - INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. - CHARACTER(LEN=:), ALLOCATABLE :: CODE !< DATA VARIABLE ENCODED, BINARY OR BASE64 CODEC. - - DATA_TYPE = 'Int64' - N_COMPONENTS = 6 - CODE = ENCODE_BINARY_DATAARRAY(U=U, V=V, W=W, X=X, Y=Y, Z=Z) - CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, & - IS_TUPLES=IS_TUPLES) - ERROR = SELF%ERROR - ENDFUNCTION W_DATA6_RANK3_I8P - - FUNCTION W_DATA6_RANK3_I4P(SELF, DATA_NAME, U, V, W, X, Y, Z, IS_TUPLES) RESULT(ERROR) - !< WRITE `<DATAARRAY... NumberOfComponents="3"...>...</DATAARRAY>` TAG (I4P). - CLASS(XML_WRITER_BINARY_LOCAL), INTENT(INOUT) :: SELF !< WRITER. - CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. - INTEGER(I4P), INTENT(IN) :: U(1:,1:,1:) !< U COMPONENT OF DATA VARIABLE. - INTEGER(I4P), INTENT(IN) :: V(1:,1:,1:) !< V COMPONENT OF DATA VARIABLE. - INTEGER(I4P), INTENT(IN) :: W(1:,1:,1:) !< W COMPONENT OF DATA VARIABLE. - INTEGER(I4P), INTENT(IN) :: X(1:,1:,1:) !< X COMPONENT OF DATA VARIABLE. - INTEGER(I4P), INTENT(IN) :: Y(1:,1:,1:) !< Y COMPONENT OF DATA VARIABLE. - INTEGER(I4P), INTENT(IN) :: Z(1:,1:,1:) !< Z COMPONENT OF DATA VARIABLE. - LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". - INTEGER(I4P) :: ERROR !< ERROR STATUS. - CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. - INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. - CHARACTER(LEN=:), ALLOCATABLE :: CODE !< DATA VARIABLE ENCODED, BINARY OR BASE64 CODEC. - - DATA_TYPE = 'Int32' - N_COMPONENTS = 6 - CODE = ENCODE_BINARY_DATAARRAY(U=U, V=V, W=W, X=X, Y=Y, Z=Z) - CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, & - IS_TUPLES=IS_TUPLES) - ERROR = SELF%ERROR - ENDFUNCTION W_DATA6_RANK3_I4P - - FUNCTION W_DATA6_RANK3_I2P(SELF, DATA_NAME, U, V, W, X, Y, Z, IS_TUPLES) RESULT(ERROR) - !< WRITE `<DATAARRAY... NumberOfComponents="3"...>...</DATAARRAY>` TAG (I2P). - CLASS(XML_WRITER_BINARY_LOCAL), INTENT(INOUT) :: SELF !< WRITER. - CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. - INTEGER(I2P), INTENT(IN) :: U(1:,1:,1:) !< U COMPONENT OF DATA VARIABLE. - INTEGER(I2P), INTENT(IN) :: V(1:,1:,1:) !< V COMPONENT OF DATA VARIABLE. - INTEGER(I2P), INTENT(IN) :: W(1:,1:,1:) !< W COMPONENT OF DATA VARIABLE. - INTEGER(I2P), INTENT(IN) :: X(1:,1:,1:) !< X COMPONENT OF DATA VARIABLE. - INTEGER(I2P), INTENT(IN) :: Y(1:,1:,1:) !< Y COMPONENT OF DATA VARIABLE. - INTEGER(I2P), INTENT(IN) :: Z(1:,1:,1:) !< Z COMPONENT OF DATA VARIABLE. - LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". - INTEGER(I4P) :: ERROR !< ERROR STATUS. - CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. - INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. - CHARACTER(LEN=:), ALLOCATABLE :: CODE !< DATA VARIABLE ENCODED, BINARY OR BASE64 CODEC. - - DATA_TYPE = 'Int16' - N_COMPONENTS = 6 - CODE = ENCODE_BINARY_DATAARRAY(U=U, V=V, W=W, X=X, Y=Y, Z=Z) - CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, & - IS_TUPLES=IS_TUPLES) - ERROR = SELF%ERROR - ENDFUNCTION W_DATA6_RANK3_I2P - - FUNCTION W_DATA6_RANK3_I1P(SELF, DATA_NAME, U, V, W, X, Y, Z, IS_TUPLES) RESULT(ERROR) - !< WRITE `<DATAARRAY... NumberOfComponents="3"...>...</DATAARRAY>` TAG (I1P). - CLASS(XML_WRITER_BINARY_LOCAL), INTENT(INOUT) :: SELF !< WRITER. - CHARACTER(*), INTENT(IN) :: DATA_NAME !< DATA NAME. - INTEGER(I1P), INTENT(IN) :: U(1:,1:,1:) !< U COMPONENT OF DATA VARIABLE. - INTEGER(I1P), INTENT(IN) :: V(1:,1:,1:) !< V COMPONENT OF DATA VARIABLE. - INTEGER(I1P), INTENT(IN) :: W(1:,1:,1:) !< W COMPONENT OF DATA VARIABLE. - INTEGER(I1P), INTENT(IN) :: X(1:,1:,1:) !< X COMPONENT OF DATA VARIABLE. - INTEGER(I1P), INTENT(IN) :: Y(1:,1:,1:) !< Y COMPONENT OF DATA VARIABLE. - INTEGER(I1P), INTENT(IN) :: Z(1:,1:,1:) !< Z COMPONENT OF DATA VARIABLE. - LOGICAL, INTENT(IN), OPTIONAL :: IS_TUPLES !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS". - INTEGER(I4P) :: ERROR !< ERROR STATUS. - CHARACTER(LEN=:), ALLOCATABLE :: DATA_TYPE !< DATA TYPE. - INTEGER(I4P) :: N_COMPONENTS !< NUMBER OF COMPONENTS. - CHARACTER(LEN=:), ALLOCATABLE :: CODE !< DATA VARIABLE ENCODED, BINARY OR BASE64 CODEC. - - DATA_TYPE = 'Int8' - N_COMPONENTS = 6 - CODE = ENCODE_BINARY_DATAARRAY(U=U, V=V, W=W, X=X, Y=Y, Z=Z) + N_COMPONENTS = 3 + CODE = ENCODE_BINARY_DATAARRAY(X=X, Y=Y, Z=Z) CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, & IS_TUPLES=IS_TUPLES) ERROR = SELF%ERROR - ENDFUNCTION W_DATA6_RANK3_I1P - + ENDFUNCTION W_DATA3_RANK1_I1P + SUBROUTINE W_DATA_APPENDED(SELF) !< DO NOTHING, BINARY LOCAL IS NOT APPENDED. CLASS(XML_WRITER_BINARY_LOCAL), INTENT(INOUT) :: SELF !< WRITER. @@ -18617,28 +12375,7 @@ MODULE VTK_FORTRAN PUBLIC :: PVTK_FILE PUBLIC :: VTK_FILE PUBLIC :: VTM_FILE -PUBLIC :: WRITE_XML_VOLATILE -CONTAINS - FUNCTION WRITE_XML_VOLATILE(XML_VOLATILE, FILENAME) RESULT(ERROR) - !< WRITE THE VOLATILE FILE INTO A REAL FILE. - !< THIS IS WHAT A MASTER PROCESS SHOULD DO INTO A PARALLEL SCENARIO WHERE IT BEING THE ONLY PROCESS ALLOWED TO ACCESS TO - !< FILESYSTEM: SLAVE PROCESSES CREATE XML VOLATILE FILE ECONDED INTO A CHARACTERS STRING AND MASTER PROCESS COLLECTS AND WRITES - !< THEM BY MEANS OF `WRITE_XML_VOLATILE`. - CHARACTER(*), INTENT(IN) :: XML_VOLATILE !< XML VOLATILE FILE. - CHARACTER(*), INTENT(IN) :: FILENAME !< XML FILE NAME. - INTEGER(I4P) :: ERROR !< STATUS ERROR. - INTEGER(I4P) :: XML_UNIT !< XML FILE UNIT. - - OPEN(NEWUNIT=XML_UNIT, & - FILE=TRIM(ADJUSTL(FILENAME)), & - FORM='UNFORMATTED', & - ACCESS='STREAM', & - ACTION='WRITE', & - STATUS='REPLACE', & - IOSTAT=ERROR) - WRITE(UNIT=XML_UNIT, IOSTAT=ERROR) XML_VOLATILE - ENDFUNCTION WRITE_XML_VOLATILE ENDMODULE VTK_FORTRAN @@ -18682,90 +12419,12 @@ MODULE VTK_FDS_INTERFACE IMPLICIT NONE (TYPE,EXTERNAL) PRIVATE -PUBLIC WRITE_VTK_SLICE_WRAPPER,BUILD_VTK_GAS_PHASE_GEOMETRY,BUILD_VTK_SOLID_PHASE_GEOMETRY,& +PUBLIC BUILD_VTK_GAS_PHASE_GEOMETRY,BUILD_VTK_SOLID_PHASE_GEOMETRY,& WRITE_VTK_SL3D_WRAPPER,WRITE_VTK_SM3D_WRAPPER,WRITE_VTK_BNDF_WRAPPER,& DEALLOCATE_VTK_GAS_PHASE_GEOMETRY,BUILD_VTK_GEOM_GEOMETRY CONTAINS -SUBROUTINE WRITE_VTK_SLICE_WRAPPER(T,NMESHES,MESH_TOPOLOGY) -INTEGER, INTENT(IN) :: NMESHES -CHARACTER(LEN=*), INTENT(IN) :: MESH_TOPOLOGY -REAL(EB), INTENT(IN) :: T -TYPE (SLICE_TYPE), POINTER :: SL -INTEGER :: I,NQT,I1,I2,J1,J2,K1,K2,IQ,ITM,ITM1 -REAL(FB) :: STIME -REAL(EB) :: TT -CHARACTER(200) :: TMP_FILE - -! Generate filename -STIME = REAL(T_BEGIN + (T-T_BEGIN)*TIME_SHRINK_FACTOR,FB) -TT = T_BEGIN + (T-T_BEGIN)*TIME_SHRINK_FACTOR -ITM = INT(TT) -ITM1 = NINT(ABS(TT-ITM)*100) -IF (ITM1==100) THEN - ITM = ITM+1 - ITM1 = 0 -ENDIF -WRITE(FN_SL3D_VTK(NMESHES+1),'(A,A,A,I8.8,I2.2,A)') "",TRIM(CHID),'_SL3D_',ITM,ITM1,'.pvtu' - -! First part of header before quantities -OPEN(LU_SL3D_VTK(NMESHES+1),FILE=FN_SL3D_VTK(NMESHES+1),FORM='FORMATTED') -WRITE(LU_SL3D_VTK(NMESHES+1),'(A)',ADVANCE='YES') '<?xml version="1.0"?>' -WRITE(LU_SL3D_VTK(NMESHES+1),'(A,A,A)',ADVANCE='YES') & - '<VTKFile type="',TRIM(MESH_TOPOLOGY),'" version="1.0" byte_order="LittleEndian">' -WRITE(LU_SL3D_VTK(NMESHES+1),'(A,A,A)',ADVANCE='YES') ' <',TRIM(MESH_TOPOLOGY),' GhostLevel="0">' -WRITE(LU_SL3D_VTK(NMESHES+1),'(A)',ADVANCE='YES') ' <PPointData>' - -! Add PointData arrays -NQT = MESHES(1)%N_SLCF -QUANTITY_LOOP2: DO IQ=1,NQT - SL => SLICE(IQ) - I1 = SL%I1 - I2 = SL%I2 - J1 = SL%J1 - J2 = SL%J2 - K1 = SL%K1 - K2 = SL%K2 - IF (I2-I1==0 .OR. J2-J1==0 .OR. K2-K1==0) CYCLE QUANTITY_LOOP2 - WRITE(LU_SL3D_VTK(NMESHES+1),'(A)',ADVANCE='NO') ' <PDataArray type="Float32" NumberOfComponents="1" Name=' - WRITE(LU_SL3D_VTK(NMESHES+1),'(A,A,A)',ADVANCE='NO') '"',TRIM(SL%SMOKEVIEW_LABEL(1:30)),'" format=' - IF (VTK_BINARY) THEN - WRITE(LU_SL3D_VTK(NMESHES+1),'(A)',ADVANCE='YES') '"binary"/>' - ELSE - WRITE(LU_SL3D_VTK(NMESHES+1),'(A)',ADVANCE='YES') '"ascii"/>' - ENDIF -ENDDO QUANTITY_LOOP2 - -! Close PointData -WRITE(LU_SL3D_VTK(NMESHES+1),'(A)',ADVANCE='YES') ' </PPointData>' - -! Add Point arrays -WRITE(LU_SL3D_VTK(NMESHES+1),'(A)',ADVANCE='YES') ' <PPoints>' -WRITE(LU_SL3D_VTK(NMESHES+1),'(A)',ADVANCE='NO') ' <PDataArray type="Float32" NumberOfComponents="3" Name="Points" format=' -IF (VTK_BINARY) THEN - WRITE(LU_SL3D_VTK(NMESHES+1),'(A)',ADVANCE='YES') '"binary"/>' -ELSE - WRITE(LU_SL3D_VTK(NMESHES+1),'(A)',ADVANCE='YES') '"ascii"/>' -ENDIF -WRITE(LU_SL3D_VTK(NMESHES+1),'(A)',ADVANCE='YES') ' </PPoints>' - -! Add CellData -WRITE(LU_SL3D_VTK(NMESHES+1),'(A)',ADVANCE='YES') ' <PCellData></PCellData>' - -! Write pieces -DO I=1,NMESHES - WRITE(TMP_FILE,'(A,A,I0,A,I8.8,I2.2,A)') TRIM(CHID),'_SL3D_',I,'_',ITM,ITM1,'.vtu' - WRITE(LU_SL3D_VTK(NMESHES+1),'(A,A,A)',ADVANCE='YES') ' <Piece Source="',TRIM(TMP_FILE),'"/>' -ENDDO - -! Finalize file -WRITE(LU_SL3D_VTK(NMESHES+1),'(A,A,A)',ADVANCE='YES') ' </',TRIM(MESH_TOPOLOGY),'>' -WRITE(LU_SL3D_VTK(NMESHES+1),'(A)',ADVANCE='YES') '</VTKFile>' -CLOSE(LU_SL3D_VTK(NMESHES+1)) -END SUBROUTINE WRITE_VTK_SLICE_WRAPPER - - SUBROUTINE WRITE_VTK_SL3D_WRAPPER(T,NMESHES,MESH_TOPOLOGY) INTEGER, INTENT(IN) :: NMESHES From 6740a6a24b665b37fd48663ae62b7b4d88dc2592 Mon Sep 17 00:00:00 2001 From: Jonathan Hodges <johodges@vt.edu> Date: Sat, 6 Jan 2024 15:07:23 -0500 Subject: [PATCH 28/31] add -ipo optimization back in for impi_intel_linux --- Build/makefile | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Build/makefile b/Build/makefile index 8f7de5a076e..7e3a86551a6 100644 --- a/Build/makefile +++ b/Build/makefile @@ -233,7 +233,7 @@ impi_intel_win_openmp_db : setup_win $(objwin_mpi) # Linux Intel Fortran Compiler and Intel MPI -impi_intel_linux : FFLAGS = -m64 -fc=$(I_IFORT) -O2 -no-wrap-margin $(GITINFO) $(INTELMPI_COMPINFO) $(FFLAGSMKL_INTEL) -DUSE_IFPORT +impi_intel_linux : FFLAGS = -m64 -fc=$(I_IFORT) -O2 -ipo -no-wrap-margin $(GITINFO) $(INTELMPI_COMPINFO) $(FFLAGSMKL_INTEL) -DUSE_IFPORT impi_intel_linux : LFLAGSMKL = $(LFLAGSMKL_INTEL) impi_intel_linux : FCOMPL = mpiifort impi_intel_linux : obj = fds_impi_intel_linux From f3148578f68743a4980024b18cdee79a3ee77668 Mon Sep 17 00:00:00 2001 From: Jonathan Hodges <johodges@vt.edu> Date: Sat, 6 Jan 2024 16:01:22 -0500 Subject: [PATCH 29/31] clean up unused variables for debug compilation --- Source/dump.f90 | 19 +++++------ Source/vtkf.f90 | 90 +++++++++++++++++++++++++++++++++++-------------- 2 files changed, 72 insertions(+), 37 deletions(-) diff --git a/Source/dump.f90 b/Source/dump.f90 index adfa36ee1ab..79173bab976 100644 --- a/Source/dump.f90 +++ b/Source/dump.f90 @@ -21,7 +21,7 @@ MODULE DUMP USE CC_SCALARS, ONLY : ADD_Q_DOT_CUTCELLS,GET_PRES_CFACE,GET_PRES_CFACE_TEST,GET_UVWGAS_CFACE,GET_MUDNS_CFACE USE VTK_FDS_INTERFACE, ONLY : BUILD_VTK_GAS_PHASE_GEOMETRY,BUILD_VTK_SOLID_PHASE_GEOMETRY,& WRITE_VTK_SM3D_WRAPPER,WRITE_VTK_SL3D_WRAPPER,WRITE_VTK_BNDF_WRAPPER,& - DEALLOCATE_VTK_GAS_PHASE_GEOMETRY,BUILD_VTK_GEOM_GEOMETRY + DEALLOCATE_VTK_GAS_PHASE_GEOMETRY,BUILD_VTK_GEOM_GEOMETRY USE VTK_FORTRAN, ONLY : VTK_FILE, PVTK_FILE IMPLICIT NONE (TYPE,EXTERNAL) @@ -137,7 +137,7 @@ SUBROUTINE DUMP_MESH_OUTPUTS(T,DT,NM) ! VTK 3-D slices IF (T>=SL3D_VTK_CLOCK(SL3D_VTK_COUNTER(NM)) .OR. STOP_STATUS==INSTABILITY_STOP) THEN IF (NM .EQ. 1) THEN - CALL WRITE_VTK_SL3D_WRAPPER(T,NMESHES,'PUnstructuredGrid') + CALL WRITE_VTK_SL3D_WRAPPER(T,NMESHES) ENDIF CALL DUMP_SLCF(T,DT,NM,3) DO WHILE(SL3D_VTK_COUNTER(NM)<SIZE(SL3D_VTK_CLOCK)-1) @@ -149,7 +149,7 @@ SUBROUTINE DUMP_MESH_OUTPUTS(T,DT,NM) ! VTK Smoke 3D slices IF (T>=SM3D_VTK_CLOCK(SM3D_VTK_COUNTER(NM)) .OR. STOP_STATUS==INSTABILITY_STOP) THEN IF (NM .EQ. 1) THEN - CALL WRITE_VTK_SM3D_WRAPPER(T,NMESHES,'PUnstructuredGrid') + CALL WRITE_VTK_SM3D_WRAPPER(T,NMESHES) ENDIF CALL DUMP_SMOKE3D(T,DT,NM,1) DO WHILE(SM3D_VTK_COUNTER(NM)<SIZE(SM3D_VTK_CLOCK)-1) @@ -162,7 +162,7 @@ SUBROUTINE DUMP_MESH_OUTPUTS(T,DT,NM) IF (T>=BNDF_VTK_CLOCK(BNDF_VTK_COUNTER(NM))) THEN IF (NM .EQ. 1) THEN - CALL WRITE_VTK_BNDF_WRAPPER(T,NMESHES,'PUnstructuredGrid') + CALL WRITE_VTK_BNDF_WRAPPER(T,NMESHES) ENDIF CALL DUMP_BNDF(T,DT,NM,1) DO WHILE(BNDF_VTK_COUNTER(NM)<SIZE(BNDF_VTK_CLOCK)-1) @@ -4314,7 +4314,6 @@ SUBROUTINE DUMP_SMOKE3D(T,DT,NM,IFRMT) REAL(FB), ALLOCATABLE, DIMENSION(:) :: QQ_PACK !INTEGER(IB8), ALLOCATABLE, DIMENSION(:) :: QQ_PACK_INT REAL(FB), ALLOCATABLE, DIMENSION(:) :: QQ_PACK_INT -CHARACTER(C_CHAR) :: C, MOLD REAL(FB), ALLOCATABLE, DIMENSION(:) :: X_PTS, Y_PTS, Z_PTS INTEGER(IB32), ALLOCATABLE, DIMENSION(:) :: CONNECT, OFFSETS INTEGER(IB8), ALLOCATABLE, DIMENSION(:) :: VTKC_TYPE @@ -4424,8 +4423,7 @@ SUBROUTINE DUMP_SMOKE3D(T,DT,NM,IFRMT) ELSE VTK_ERROR = A_VTK_FILE%INITIALIZE(FORMAT='ascii', FILENAME=FN_SMOKE3D_VTK(NM), MESH_TOPOLOGY='UnstructuredGrid') ENDIF ! do not change capitalization on mesh topology - CALL BUILD_VTK_GAS_PHASE_GEOMETRY(NM, 'UnstructuredGrid', & - NC, NP, X_PTS, Y_PTS, Z_PTS, CONNECT, OFFSETS, VTKC_TYPE) + CALL BUILD_VTK_GAS_PHASE_GEOMETRY(NM, NC, NP, X_PTS, Y_PTS, Z_PTS, CONNECT, OFFSETS, VTKC_TYPE) VTK_ERROR = A_VTK_FILE%XML_WRITER%WRITE_PIECE(NP=NP, NC=NC) VTK_ERROR = A_VTK_FILE%XML_WRITER%WRITE_GEO(NP=NP, NC=NC, X=X_PTS, Y=Y_PTS, Z=Z_PTS) VTK_ERROR = A_VTK_FILE%XML_WRITER%WRITE_CONNECTIVITY(NC=NC, CONNECTIVITY=CONNECT, OFFSET=OFFSETS, VTKC_TYPE=VTKC_TYPE) @@ -6132,8 +6130,7 @@ SUBROUTINE DUMP_SLCF(T,DT,NM,IFRMT) ELSE VTK_ERROR = A_VTK_FILE%INITIALIZE(FORMAT='ascii', FILENAME=FN_SL3D_VTK(NM), MESH_TOPOLOGY='UnstructuredGrid') ENDIF ! do not change capitalization on mesh topology - CALL BUILD_VTK_GAS_PHASE_GEOMETRY(NM, 'UnstructuredGrid', & - NC, NP, X_PTS, Y_PTS, Z_PTS, CONNECT, OFFSETS, VTKC_TYPE) + CALL BUILD_VTK_GAS_PHASE_GEOMETRY(NM, NC, NP, X_PTS, Y_PTS, Z_PTS, CONNECT, OFFSETS, VTKC_TYPE) VTK_ERROR = A_VTK_FILE%XML_WRITER%WRITE_PIECE(NP=NP, NC=NC) VTK_ERROR = A_VTK_FILE%XML_WRITER%WRITE_GEO(NP=NP, NC=NC, X=X_PTS, Y=Y_PTS, Z=Z_PTS) VTK_ERROR = A_VTK_FILE%XML_WRITER%WRITE_CONNECTIVITY(NC=NC, CONNECTIVITY=CONNECT, OFFSET=OFFSETS, VTKC_TYPE=VTKC_TYPE) @@ -10775,7 +10772,7 @@ SUBROUTINE DUMP_BNDF(T,DT,NM,IFRMT) TYPE(PATCH_TYPE), POINTER :: PA REAL(FB) BNDF_TIME, BNDF_VAL_MIN, BNDF_VAL_MAX INTEGER :: CHANGE_BOUND, IERROR -INTEGER :: NX, NY, NZ, NCELLS, NPOINTS +INTEGER :: NCELLS, NPOINTS INTEGER, ALLOCATABLE, DIMENSION(:) :: LOCATIONS,FACES,SURFIND,GEOMIND REAL(FB), ALLOCATABLE, DIMENSION(:) :: VALS, VERTS REAL(FB), ALLOCATABLE, DIMENSION(:) :: QQ_PACK @@ -10997,7 +10994,7 @@ SUBROUTINE DUMP_BNDF(T,DT,NM,IFRMT) PATCH_LOOP1: DO IP=1,N_PATCH PA => PATCH(IP) ! Initialize piece - CALL BUILD_VTK_SOLID_PHASE_GEOMETRY(NM, PA, 'UnstructuredGrid', NCELLS, NPOINTS, & + CALL BUILD_VTK_SOLID_PHASE_GEOMETRY(NM, PA, NCELLS, NPOINTS, & X_PTS, Y_PTS, Z_PTS, CONNECT, OFFSETS, VTKC_TYPE) VTK_ERROR = A_VTK_FILE%XML_WRITER%WRITE_PIECE(NP=NPOINTS, NC=NCELLS) VTK_ERROR = A_VTK_FILE%XML_WRITER%WRITE_GEO(NP=NPOINTS, NC=NCELLS, X=X_PTS, Y=Y_PTS, Z=Z_PTS) diff --git a/Source/vtkf.f90 b/Source/vtkf.f90 index 74db6a9bdc6..a8bb8d9a407 100644 --- a/Source/vtkf.f90 +++ b/Source/vtkf.f90 @@ -5955,6 +5955,8 @@ ELEMENTAL FUNCTION TO_INTEGER_I1P(SELF, KIND) RESULT(TO_NUMBER) IF (ALLOCATED(SELF%RAW)) THEN IF (SELF%IS_INTEGER()) READ(SELF%RAW, *) TO_NUMBER ENDIF + IF (KIND.EQ.-1) THEN + ENDIF ENDFUNCTION TO_INTEGER_I1P #ifndef _NVF @@ -5979,6 +5981,8 @@ ELEMENTAL FUNCTION TO_INTEGER_I2P(SELF, KIND) RESULT(TO_NUMBER) IF (ALLOCATED(SELF%RAW)) THEN IF (SELF%IS_INTEGER()) READ(SELF%RAW, *) TO_NUMBER ENDIF + IF (KIND.EQ.-1) THEN + ENDIF ENDFUNCTION TO_INTEGER_I2P #endif @@ -6003,6 +6007,8 @@ ELEMENTAL FUNCTION TO_INTEGER_I4P(SELF, KIND) RESULT(TO_NUMBER) IF (ALLOCATED(SELF%RAW)) THEN IF (SELF%IS_INTEGER()) READ(SELF%RAW, *) TO_NUMBER ENDIF + IF (KIND.EQ.-1) THEN + ENDIF ENDFUNCTION TO_INTEGER_I4P ELEMENTAL FUNCTION TO_INTEGER_I8P(SELF, KIND) RESULT(TO_NUMBER) @@ -6026,6 +6032,8 @@ ELEMENTAL FUNCTION TO_INTEGER_I8P(SELF, KIND) RESULT(TO_NUMBER) IF (ALLOCATED(SELF%RAW)) THEN IF (SELF%IS_INTEGER()) READ(SELF%RAW, *) TO_NUMBER ENDIF + IF (KIND.EQ.-1) THEN + ENDIF ENDFUNCTION TO_INTEGER_I8P ELEMENTAL FUNCTION TO_REAL_R4P(SELF, KIND) RESULT(TO_NUMBER) @@ -6049,6 +6057,8 @@ ELEMENTAL FUNCTION TO_REAL_R4P(SELF, KIND) RESULT(TO_NUMBER) IF (ALLOCATED(SELF%RAW)) THEN IF (SELF%IS_REAL()) READ(SELF%RAW, *) TO_NUMBER ENDIF + IF (KIND.EQ.-1) THEN + ENDIF ENDFUNCTION TO_REAL_R4P ELEMENTAL FUNCTION TO_REAL_R8P(SELF, KIND) RESULT(TO_NUMBER) @@ -6072,6 +6082,8 @@ ELEMENTAL FUNCTION TO_REAL_R8P(SELF, KIND) RESULT(TO_NUMBER) IF (ALLOCATED(SELF%RAW)) THEN IF (SELF%IS_REAL()) READ(SELF%RAW, *) TO_NUMBER ENDIF + IF (KIND.EQ.-1) THEN + ENDIF ENDFUNCTION TO_REAL_R8P ELEMENTAL FUNCTION TO_REAL_R16P(SELF, KIND) RESULT(TO_NUMBER) @@ -6095,6 +6107,8 @@ ELEMENTAL FUNCTION TO_REAL_R16P(SELF, KIND) RESULT(TO_NUMBER) IF (ALLOCATED(SELF%RAW)) THEN IF (SELF%IS_REAL()) READ(SELF%RAW, *) TO_NUMBER ENDIF + IF (KIND.EQ.-1) THEN + ENDIF ENDFUNCTION TO_REAL_R16P ELEMENTAL FUNCTION UNESCAPE(SELF, TO_UNESCAPE, UNESC) RESULT(UNESCAPED) @@ -7520,7 +7534,8 @@ SUBROUTINE READ_FORMATTED(DTV, UNIT, IOTYPE, V_LIST, IOSTAT, IOMSG) CHARACTER(LEN=LEN(IOMSG)) :: LOCAL_IOMSG !< LOCAL VARIANT OF IOMSG, SO IT DOESN'T GET INAPPROPRIATELY REDEFINED. CHARACTER(KIND=CK, LEN=1) :: DELIM !< STRING DELIMITER, IF ANY. CHARACTER(KIND=CK, LEN=100) :: TEMPORARY !< TEMPORARY STORAGE STRING. - + IF (V_LIST(1).EQ.0) THEN + ENDIF IF (IOTYPE == 'LISTDIRECTED') THEN CALL GET_NEXT_NON_BLANK_CHARACTER_ANY_RECORD(UNIT=UNIT, CH=DELIM, IOSTAT=IOSTAT, IOMSG=IOMSG) IF (IOSTAT/=0) RETURN @@ -7654,7 +7669,10 @@ SUBROUTINE WRITE_FORMATTED(DTV, UNIT, IOTYPE, V_LIST, IOSTAT, IOMSG) INTEGER, INTENT(IN) :: V_LIST(:) !< EDIT DESCRIPTOR LIST. INTEGER, INTENT(OUT) :: IOSTAT !< IO STATUS CODE. CHARACTER(KIND=CK, LEN=*), INTENT(INOUT) :: IOMSG !< IO STATUS MESSAGE. - + IF (IOTYPE=="") THEN + ENDIF + IF (V_LIST(1).EQ.0) THEN + ENDIF IF (ALLOCATED(DTV%RAW)) THEN WRITE(UNIT, "(A)", IOSTAT=IOSTAT, IOMSG=IOMSG)DTV%RAW ELSE @@ -8792,6 +8810,8 @@ ELEMENTAL SUBROUTINE SEARCH(SELF, TAG_NAME, SOURCE, TSTART, TEND) INTEGER(I4P) :: TEND_C !< STARTING INDEX OF TAG INSIDE THE CURRENT SLICE OF SOURCE. INTEGER(I4P) :: I + IF (I.EQ.-1) THEN + ENDIF CALL SELF%FREE SELF%TAG_NAME = TAG_NAME TSTART_ = 1 @@ -9478,10 +9498,11 @@ SUBROUTINE OPEN_XML_FILE(SELF, FILENAME) ENDIF ENDSUBROUTINE OPEN_XML_FILE - ELEMENTAL SUBROUTINE FREE(SELF, ERROR) + ELEMENTAL SUBROUTINE FREE(SELF) + !ELEMENTAL SUBROUTINE FREE(SELF, ERROR) !< FREE ALLOCATED MEMORY. CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT) :: SELF !< WRITER. - INTEGER(I4P), INTENT(OUT), OPTIONAL :: ERROR !< ERROR STATUS. + !INTEGER(I4P), INTENT(OUT), OPTIONAL :: ERROR !< ERROR STATUS. CALL SELF%FORMAT_CH%FREE CALL SELF%TOPOLOGY%FREE @@ -9495,11 +9516,12 @@ ELEMENTAL SUBROUTINE FREE(SELF, ERROR) CALL SELF%XML_VOLATILE%FREE ENDSUBROUTINE FREE - PURE SUBROUTINE GET_XML_VOLATILE(SELF, XML_VOLATILE, ERROR) + PURE SUBROUTINE GET_XML_VOLATILE(SELF, XML_VOLATILE) + !PURE SUBROUTINE GET_XML_VOLATILE(SELF, XML_VOLATILE, ERROR) !< RETURN THE EVENTUAL XML VOLATILE STRING FILE. CLASS(XML_WRITER_ABSTRACT), INTENT(IN) :: SELF !< WRITER. CHARACTER(LEN=:), INTENT(OUT), ALLOCATABLE :: XML_VOLATILE !< XML VOLATILE FILE. - INTEGER(I4P), INTENT(OUT), OPTIONAL :: ERROR !< ERROR STATUS. + !INTEGER(I4P), INTENT(OUT), OPTIONAL :: ERROR !< ERROR STATUS. IF (SELF%IS_VOLATILE) THEN XML_VOLATILE = SELF%XML_VOLATILE%RAW @@ -9923,6 +9945,8 @@ FUNCTION WRITE_GEO_UNST_DATA3_RANK1_R8P(SELF, NP, NC, X, Y, Z) RESULT(ERROR) SELF%ERROR = 1 RETURN ENDIF + IF (NC.EQ.-1) THEN + ENDIF CALL SELF%WRITE_START_TAG(NAME='Points') ERROR = SELF%W_DATA(DATA_NAME='Points', X=X, Y=Y, Z=Z) CALL SELF%WRITE_END_TAG(NAME='Points') @@ -9943,6 +9967,8 @@ FUNCTION WRITE_GEO_UNST_DATA3_RANK1_R4P(SELF, NP, NC, X, Y, Z) RESULT(ERROR) SELF%ERROR = 1 RETURN ENDIF + IF (NC.EQ.-1) THEN + ENDIF CALL SELF%WRITE_START_TAG(NAME='Points') ERROR = SELF%W_DATA(DATA_NAME='Points', X=X, Y=Y, Z=Z) CALL SELF%WRITE_END_TAG(NAME='Points') @@ -9964,6 +9990,8 @@ FUNCTION WRITE_GEO_POLY_DATA3_RANK1_R8P(SELF, NP, NC, X, Y, Z) RESULT(ERROR) SELF%ERROR = 1 RETURN ENDIF + IF (NC.EQ.-1) THEN + ENDIF CALL SELF%WRITE_START_TAG(NAME='Points') ERROR = SELF%W_DATA(DATA_NAME='Points', X=X, Y=Y, Z=Z) CALL SELF%WRITE_END_TAG(NAME='Points') @@ -9984,6 +10012,8 @@ FUNCTION WRITE_GEO_POLY_DATA3_RANK1_R4P(SELF, NP, NC, X, Y, Z) RESULT(ERROR) SELF%ERROR = 1 RETURN ENDIF + IF (NC.EQ.-1) THEN + ENDIF CALL SELF%WRITE_START_TAG(NAME='Points') ERROR = SELF%W_DATA(DATA_NAME='Points', X=X, Y=Y, Z=Z) CALL SELF%WRITE_END_TAG(NAME='Points') @@ -10057,7 +10087,9 @@ FUNCTION WRITE_CONNECTIVITY(SELF, NC, CONNECTIVITY, OFFSET, VTKC_TYPE, FACE, FAC ERROR = SELF%W_DATA(DATA_NAME='offsets', X=OFFSET) ERROR = SELF%W_DATA(DATA_NAME='types', X=VTKC_TYPE) CALL SELF%WRITE_END_TAG(NAME='Cells') - + + IF (NC.EQ.-1) THEN + ENDIF !< ADD FACES AND FACEOFFSETS TO THE CELL BLOCK FOR POLYHEDRA. IF THE CELL IS NOT A POLYHEDRON, ITS OFFSET MUST BE SET TO -1. IF(PRESENT(FACE).AND. PRESENT(FACEOFFSET)) THEN ERROR = SELF%W_DATA(DATA_NAME='Faces', X=FACE) @@ -10787,7 +10819,8 @@ FUNCTION INITIALIZE(SELF, FORMAT, FILENAME, MESH_TOPOLOGY, NX1, NX2, NY1, NY2, N CHARACTER(*), INTENT(IN), OPTIONAL :: MESH_KIND !< KIND OF MESH DATA: FLOAT64, FLOAT32, ECC. LOGICAL, INTENT(IN), OPTIONAL :: IS_VOLATILE !< FLAG TO CHECK VOLATILE WRITER. INTEGER(I4P) :: ERROR !< ERROR STATUS. - + IF (IS_VOLATILE) THEN + ENDIF SELF%TOPOLOGY = TRIM(ADJUSTL(MESH_TOPOLOGY)) SELF%FORMAT_CH = FORMAT SELF%FORMAT_CH = SELF%FORMAT_CH%LOWER() @@ -11052,6 +11085,8 @@ FUNCTION W_DATA3_RANK1_I1P(SELF, DATA_NAME, X, Y, Z, IS_TUPLES) RESULT(ERROR) SUBROUTINE W_DATA_APPENDED(SELF) !< DO NOTHING, ASCII DATA CANNOT BE APPENDED. CLASS(XML_WRITER_ASCII_LOCAL), INTENT(INOUT) :: SELF !< WRITER. + INTEGER(I4P) :: ERROR !< ERROR STATUS. + ERROR = SELF%ERROR ENDSUBROUTINE W_DATA_APPENDED ENDMODULE VTKF_FILE_XML_WRITER_ASCII_LOCAL @@ -11131,7 +11166,8 @@ FUNCTION INITIALIZE(SELF, FORMAT, FILENAME, MESH_TOPOLOGY, NX1, NX2, NY1, NY2, N CHARACTER(*), INTENT(IN), OPTIONAL :: MESH_KIND !< KIND OF MESH DATA: FLOAT64, FLOAT32, ECC. LOGICAL, INTENT(IN), OPTIONAL :: IS_VOLATILE !< FLAG TO CHECK VOLATILE WRITER. INTEGER(I4P) :: ERROR !< ERROR STATUS. - + IF (IS_VOLATILE) THEN + ENDIF SELF%TOPOLOGY = TRIM(ADJUSTL(MESH_TOPOLOGY)) SELF%FORMAT_CH = 'appended' SELF%ENCODING = FORMAT @@ -11436,7 +11472,8 @@ SUBROUTINE W_DATA_APPENDED(SELF) INTEGER(I4P), ALLOCATABLE :: DATAARRAY_I4P(:) !< DATAARRAY BUFFER OF I4P. INTEGER(I2P), ALLOCATABLE :: DATAARRAY_I2P(:) !< DATAARRAY BUFFER OF I2P. INTEGER(I1P), ALLOCATABLE :: DATAARRAY_I1P(:) !< DATAARRAY BUFFER OF I1P. - + IF(TAG_ATTRIBUTES=="") THEN + ENDIF CALL SELF%WRITE_START_TAG(NAME='AppendedData', ATTRIBUTES='encoding="'//SELF%ENCODING%CHARS()//'"') WRITE(UNIT=SELF%XML, IOSTAT=SELF%ERROR)'_' ENDFILE(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR) @@ -11967,6 +12004,8 @@ FUNCTION W_DATA3_RANK1_I1P(SELF, DATA_NAME, X, Y, Z, IS_TUPLES) RESULT(ERROR) SUBROUTINE W_DATA_APPENDED(SELF) !< DO NOTHING, BINARY LOCAL IS NOT APPENDED. CLASS(XML_WRITER_BINARY_LOCAL), INTENT(INOUT) :: SELF !< WRITER. + INTEGER(I4P) :: ERROR !< ERROR STATUS. + ERROR = SELF%ERROR ENDSUBROUTINE W_DATA_APPENDED ENDMODULE VTKF_FILE_XML_WRITER_BINARY_LOCAL @@ -12196,8 +12235,9 @@ PURE SUBROUTINE GET_XML_VOLATILE(SELF, XML_VOLATILE, ERROR) CLASS(VTK_FILE), INTENT(IN) :: SELF !< VTK FILE. CHARACTER(LEN=:), INTENT(OUT), ALLOCATABLE :: XML_VOLATILE !< XML VOLATILE FILE. INTEGER(I4P), INTENT(OUT), OPTIONAL :: ERROR !< ERROR STATUS. - - CALL SELF%XML_WRITER%GET_XML_VOLATILE(XML_VOLATILE=XML_VOLATILE, ERROR=ERROR) + IF (ERROR.EQ.-1) THEN + ENDIF + CALL SELF%XML_WRITER%GET_XML_VOLATILE(XML_VOLATILE=XML_VOLATILE) !, ERROR=ERROR) ENDSUBROUTINE GET_XML_VOLATILE FUNCTION INITIALIZE(SELF, FORMAT, FILENAME, MESH_TOPOLOGY, IS_VOLATILE, NX1, NX2, NY1, NY2, NZ1, NZ2) RESULT(ERROR) @@ -12272,14 +12312,17 @@ FUNCTION FINALIZE(SELF) RESULT(ERROR) ERROR = 1 IF (ALLOCATED(SELF%XML_WRITER)) ERROR = SELF%XML_WRITER%FINALIZE() + IF (XML_VOLATILE=="") THEN + ENDIF ENDFUNCTION FINALIZE ELEMENTAL SUBROUTINE FREE(SELF, ERROR) !< FREE ALLOCATED MEMORY. CLASS(VTK_FILE), INTENT(INOUT) :: SELF !< VTK FILE. INTEGER(I4P), INTENT(OUT), OPTIONAL :: ERROR !< ERROR STATUS. - - IF (ALLOCATED(SELF%XML_WRITER)) CALL SELF%XML_WRITER%FREE(ERROR=ERROR) + IF (ERROR.EQ.-1) THEN + ENDIF + IF (ALLOCATED(SELF%XML_WRITER)) CALL SELF%XML_WRITER%FREE() !ERROR=ERROR) ENDSUBROUTINE FREE ENDMODULE VTK_FORTRAN_VTK_FILE @@ -12426,9 +12469,8 @@ MODULE VTK_FDS_INTERFACE CONTAINS -SUBROUTINE WRITE_VTK_SL3D_WRAPPER(T,NMESHES,MESH_TOPOLOGY) +SUBROUTINE WRITE_VTK_SL3D_WRAPPER(T,NMESHES) INTEGER, INTENT(IN) :: NMESHES -CHARACTER(LEN=*), INTENT(IN) :: MESH_TOPOLOGY REAL(EB), INTENT(IN) :: T TYPE (SLICE_TYPE), POINTER :: SL INTEGER :: I,NQT,I1,I2,J1,J2,K1,K2,IQ,ITM,ITM1 @@ -12487,9 +12529,8 @@ END SUBROUTINE WRITE_VTK_SL3D_WRAPPER -SUBROUTINE WRITE_VTK_SM3D_WRAPPER(T,NMESHES,MESH_TOPOLOGY) +SUBROUTINE WRITE_VTK_SM3D_WRAPPER(T,NMESHES) INTEGER, INTENT(IN) :: NMESHES -CHARACTER(LEN=*), INTENT(IN) :: MESH_TOPOLOGY REAL(EB), INTENT(IN) :: T INTEGER :: I,ITM,ITM1,N REAL(FB) :: STIME @@ -12530,12 +12571,11 @@ END SUBROUTINE WRITE_VTK_SM3D_WRAPPER -SUBROUTINE WRITE_VTK_BNDF_WRAPPER(T,NMESHES,MESH_TOPOLOGY) +SUBROUTINE WRITE_VTK_BNDF_WRAPPER(T,NMESHES) INTEGER, INTENT(IN) :: NMESHES -CHARACTER(LEN=*), INTENT(IN) :: MESH_TOPOLOGY REAL(EB), INTENT(IN) :: T TYPE(BOUNDARY_FILE_TYPE), POINTER :: BF -INTEGER :: I,NQT,I1,I2,J1,J2,K1,K2,IQ,ITM,ITM1 +INTEGER :: I,IQ,ITM,ITM1 REAL(FB) :: STIME REAL(EB) :: TT TYPE(PVTK_FILE) :: A_PVTK_FILE !< A parallel (partioned) VTK file. @@ -12575,14 +12615,13 @@ END SUBROUTINE WRITE_VTK_BNDF_WRAPPER -SUBROUTINE BUILD_VTK_GAS_PHASE_GEOMETRY(NM, MESH_TOPOLOGY, & +SUBROUTINE BUILD_VTK_GAS_PHASE_GEOMETRY(NM, & NC, NP, X_PTS, Y_PTS, Z_PTS, CONNECT, OFFSETS, VTKC_TYPE) INTEGER :: NX, NY, NZ, NC, NP, I, J, K, IFACT, JFACT, KFACT REAL(FB), ALLOCATABLE, DIMENSION(:) :: X_PTS, Y_PTS, Z_PTS INTEGER(IB32), ALLOCATABLE, DIMENSION(:) :: CONNECT, OFFSETS INTEGER(IB8), ALLOCATABLE, DIMENSION(:) :: VTKC_TYPE -CHARACTER(LEN=*), INTENT(IN) :: MESH_TOPOLOGY INTEGER, INTENT(IN) :: NM NX = SIZE(MESHES(NM)%X) @@ -12639,14 +12678,13 @@ SUBROUTINE BUILD_VTK_GAS_PHASE_GEOMETRY(NM, MESH_TOPOLOGY, & ENDSUBROUTINE BUILD_VTK_GAS_PHASE_GEOMETRY -SUBROUTINE BUILD_VTK_SOLID_PHASE_GEOMETRY(NM, PA, MESH_TOPOLOGY, & +SUBROUTINE BUILD_VTK_SOLID_PHASE_GEOMETRY(NM, PA, & NCELLS, NPOINTS, X_PTS, Y_PTS, Z_PTS, CONNECT, OFFSETS, VTKC_TYPE) -INTEGER :: NX,NY,NZ,NCELLS,NPOINTS,I,J,K,IFACT,JFACT,KFACT,L,L1,L2,N,N1,N2 +INTEGER :: NX,NY,NZ,NCELLS,NPOINTS,I,J,K,IFACT,L1,L2,N1,N2 REAL(FB), ALLOCATABLE, DIMENSION(:) :: X_PTS, Y_PTS, Z_PTS INTEGER(IB32), ALLOCATABLE, DIMENSION(:) :: CONNECT, OFFSETS INTEGER(IB8), ALLOCATABLE, DIMENSION(:) :: VTKC_TYPE -CHARACTER(LEN=*), INTENT(IN) :: MESH_TOPOLOGY INTEGER, INTENT(IN) :: NM TYPE(PATCH_TYPE), POINTER, INTENT(IN) :: PA From 7e36630fe512687b5d4b46b4226525bdbe13fe3e Mon Sep 17 00:00:00 2001 From: Jonathan Hodges <johodges@vt.edu> Date: Mon, 8 Jan 2024 14:14:38 -0500 Subject: [PATCH 30/31] add vtk output for particles --- Source/cons.f90 | 3 +- Source/dump.f90 | 113 ++++++++++++++++++++++++++++++------------------ Source/vtkf.f90 | 46 ++++++++++++++++++++ 3 files changed, 120 insertions(+), 42 deletions(-) diff --git a/Source/cons.f90 b/Source/cons.f90 index 76b5c4dc9d6..bd07a746041 100644 --- a/Source/cons.f90 +++ b/Source/cons.f90 @@ -553,7 +553,8 @@ MODULE GLOBAL_CONSTANTS CHARACTER(80), ALLOCATABLE, DIMENSION(:) :: FN_VEG_OUT,FN_GEOM, FN_CFACE_GEOM CHARACTER(80), ALLOCATABLE, DIMENSION(:,:) :: FN_SLCF,FN_SLCF_GEOM,FN_BNDF,FN_BNDG, & FN_ISOF,FN_ISOF2,FN_SMOKE3D,FN_RADF -CHARACTER(200), ALLOCATABLE, DIMENSION(:) :: FN_SL3D_VTK,FN_SMOKE3D_VTK,FN_BNDF_VTK,FN_PART_VTK +CHARACTER(200), ALLOCATABLE, DIMENSION(:) :: FN_SL3D_VTK,FN_SMOKE3D_VTK,FN_BNDF_VTK +CHARACTER(200), ALLOCATABLE, DIMENSION(:,:):: FN_PART_VTK CHARACTER(9) :: FMT_R LOGICAL :: OUT_FILE_OPENED=.FALSE. diff --git a/Source/dump.f90 b/Source/dump.f90 index 79173bab976..e5e32979916 100644 --- a/Source/dump.f90 +++ b/Source/dump.f90 @@ -21,6 +21,7 @@ MODULE DUMP USE CC_SCALARS, ONLY : ADD_Q_DOT_CUTCELLS,GET_PRES_CFACE,GET_PRES_CFACE_TEST,GET_UVWGAS_CFACE,GET_MUDNS_CFACE USE VTK_FDS_INTERFACE, ONLY : BUILD_VTK_GAS_PHASE_GEOMETRY,BUILD_VTK_SOLID_PHASE_GEOMETRY,& WRITE_VTK_SM3D_WRAPPER,WRITE_VTK_SL3D_WRAPPER,WRITE_VTK_BNDF_WRAPPER,& + WRITE_VTK_PART_WRAPPER,& DEALLOCATE_VTK_GAS_PHASE_GEOMETRY,BUILD_VTK_GEOM_GEOMETRY USE VTK_FORTRAN, ONLY : VTK_FILE, PVTK_FILE @@ -95,7 +96,7 @@ SUBROUTINE DUMP_MESH_OUTPUTS(T,DT,NM) TNOW = CURRENT_TIME() IF (T>=PART_CLOCK(PART_COUNTER(NM)) .AND. PARTICLE_FILE) THEN - CALL DUMP_PART(T,NM) + CALL DUMP_PART(T,NM,0) DO WHILE(PART_COUNTER(NM)<SIZE(PART_CLOCK)-1) PART_COUNTER(NM) = PART_COUNTER(NM) + 1 IF (PART_CLOCK(PART_COUNTER(NM))>=T) EXIT @@ -174,9 +175,9 @@ SUBROUTINE DUMP_MESH_OUTPUTS(T,DT,NM) ! VTK Particle data IF (T>=PART_VTK_CLOCK(PART_VTK_COUNTER(NM)) .AND. PARTICLE_FILE) THEN IF (NM .EQ. 1) THEN - !CALL WRITE_VTK_PART_WRAPPER(T,NMESHES,'PPolyData') + CALL WRITE_VTK_PART_WRAPPER(T,NMESHES) ENDIF - !CALL DUMP_PART(T,NM) + CALL DUMP_PART(T,NM,1) DO WHILE(PART_VTK_COUNTER(NM)<SIZE(PART_VTK_CLOCK)-1) PART_VTK_COUNTER(NM) = PART_VTK_COUNTER(NM) + 1 IF (PART_VTK_CLOCK(PART_VTK_COUNTER(NM))>=T) EXIT @@ -422,7 +423,7 @@ SUBROUTINE ASSIGN_FILE_NAMES ALLOCATE(FN_SMOKE3D_VTK(NMESHES+1)) ALLOCATE(LU_SMOKE3D_VTK(NMESHES+1)) ALLOCATE(FN_BNDF_VTK(NMESHES+1)) -ALLOCATE(FN_PART_VTK(NMESHES+1)) +ALLOCATE(FN_PART_VTK(N_LAGRANGIAN_CLASSES,NMESHES+1)) MESH_LOOP: DO NM=1,NMESHES @@ -4037,15 +4038,16 @@ END SUBROUTINE WRITE_DIAGNOSTICS !> !> \param T Current simulation time (s) !> \param NM Mesh number +!> \param IFRMT PRT5 (IFRMT=0) or VTK (IFRMT=1) -SUBROUTINE DUMP_PART(T,NM) +SUBROUTINE DUMP_PART(T,NM,IFRMT) USE MEMORY_FUNCTIONS, ONLY: CHKMEMERR -INTEGER, INTENT(IN) :: NM +INTEGER, INTENT(IN) :: NM,IFRMT REAL(EB), INTENT(IN) :: T REAL(EB) :: STIME -INTEGER :: NPP,NPLIM,IP,N,NN,IZERO +INTEGER :: NPP,NPLIM,IP,N,NN,IZERO,ITM,ITM1 REAL(EB), ALLOCATABLE, DIMENSION(:) :: XP,YP,ZP REAL(EB), ALLOCATABLE, DIMENSION(:,:) :: QP INTEGER, ALLOCATABLE, DIMENSION(:) :: TA @@ -4053,15 +4055,25 @@ SUBROUTINE DUMP_PART(T,NM) REAL(FB) :: PFACTOR_FB INTEGER, PARAMETER :: PART_BOUNDFILE_VERSION=1 TYPE (BOUNDARY_COORD_TYPE), POINTER :: BC +TYPE(VTK_FILE) :: A_VTK_FILE ! A VTK file. +INTEGER(IB8) :: VTK_ERROR=0_IB8 !< IO Error status. CALL POINT_TO_MESH(NM) ! Write the current time to the prt5 file, then start looping through the particle classes STIME = T_BEGIN + (T-T_BEGIN)*TIME_SHRINK_FACTOR +ITM = INT(STIME) +ITM1 = NINT(ABS(STIME-ITM)*100) +IF (ITM1==100) THEN + ITM = ITM+1 + ITM1 = 0 +ENDIF -WRITE(LU_PART(NM)) REAL(STIME,FB) -WRITE(LU_PART(NM+NMESHES),'(ES13.6,1X,I4,1X,I4)')STIME, N_LAGRANGIAN_CLASSES, PART_BOUNDFILE_VERSION +IF (IFRMT.EQ.0) THEN + WRITE(LU_PART(NM)) REAL(STIME,FB) + WRITE(LU_PART(NM+NMESHES),'(ES13.6,1X,I4,1X,I4)')STIME, N_LAGRANGIAN_CLASSES, PART_BOUNDFILE_VERSION +ENDIF LAGRANGIAN_PARTICLE_CLASS_LOOP: DO N=1,N_LAGRANGIAN_CLASSES @@ -4101,43 +4113,62 @@ SUBROUTINE DUMP_PART(T,NM) Y_INDEX=LPC%QUANTITIES_Y_INDEX(NN),Z_INDEX=LPC%QUANTITIES_Z_INDEX(NN),MESH_NUMBER=NM) ENDDO ENDDO LOAD_LOOP + + IF (IFRMT.EQ.0) THEN + ! Dump particle data into the .prt5 file - ! Dump particle data into the .prt5 file - - WRITE(LU_PART(NM)) NPLIM - WRITE(LU_PART(NM)) (REAL(XP(IP),FB),IP=1,NPLIM),(REAL(YP(IP),FB),IP=1,NPLIM),(REAL(ZP(IP),FB),IP=1,NPLIM) - WRITE(LU_PART(NM)) (TA(IP),IP=1,NPLIM) - IF (LPC%DEBUG) THEN - PFACTOR = 0.0_EB - IF(NPLIM > 1) PFACTOR = 2.0_EB*STIME/REAL(NPLIM-1,FB) - IF (LPC%N_QUANTITIES > 0) THEN - PFACTOR_FB = REAL(PFACTOR,FB) - WRITE(LU_PART(NM)) ((REAL(-STIME,FB)+REAL(IP-1,FB)*PFACTOR_FB,IP=1,NPLIM),NN=1,LPC%N_QUANTITIES) - ENDIF - ELSE - IF (LPC%N_QUANTITIES > 0) WRITE(LU_PART(NM)) ((REAL(QP(IP,NN),FB),IP=1,NPLIM),NN=1,LPC%N_QUANTITIES) - ENDIF - - WRITE(LU_PART(NM+NMESHES),'(I4,1X,I7)')LPC%N_QUANTITIES, NPLIM - DO NN = 1, LPC%N_QUANTITIES + WRITE(LU_PART(NM)) NPLIM + WRITE(LU_PART(NM)) (REAL(XP(IP),FB),IP=1,NPLIM),(REAL(YP(IP),FB),IP=1,NPLIM),(REAL(ZP(IP),FB),IP=1,NPLIM) + WRITE(LU_PART(NM)) (TA(IP),IP=1,NPLIM) IF (LPC%DEBUG) THEN - PART_MIN = -STIME - PART_MAX = STIME + PFACTOR = 0.0_EB + IF(NPLIM > 1) PFACTOR = 2.0_EB*STIME/REAL(NPLIM-1,FB) + IF (LPC%N_QUANTITIES > 0) THEN + PFACTOR_FB = REAL(PFACTOR,FB) + WRITE(LU_PART(NM)) ((REAL(-STIME,FB)+REAL(IP-1,FB)*PFACTOR_FB,IP=1,NPLIM),NN=1,LPC%N_QUANTITIES) + ENDIF ELSE - IF (NPLIM > 0) THEN - PART_MAX = QP(1,NN) - PART_MIN = PART_MAX - DO IP = 2, NPLIM - PART_MIN = MIN(QP(IP,NN),PART_MIN) - PART_MAX = MAX(QP(IP,NN),PART_MAX) - ENDDO + IF (LPC%N_QUANTITIES > 0) WRITE(LU_PART(NM)) ((REAL(QP(IP,NN),FB),IP=1,NPLIM),NN=1,LPC%N_QUANTITIES) + ENDIF + + WRITE(LU_PART(NM+NMESHES),'(I4,1X,I7)')LPC%N_QUANTITIES, NPLIM + DO NN = 1, LPC%N_QUANTITIES + IF (LPC%DEBUG) THEN + PART_MIN = -STIME + PART_MAX = STIME ELSE - PART_MIN = 1.0_EB - PART_MAX = 0.0_EB + IF (NPLIM > 0) THEN + PART_MAX = QP(1,NN) + PART_MIN = PART_MAX + DO IP = 2, NPLIM + PART_MIN = MIN(QP(IP,NN),PART_MIN) + PART_MAX = MAX(QP(IP,NN),PART_MAX) + ENDDO + ELSE + PART_MIN = 1.0_EB + PART_MAX = 0.0_EB + ENDIF ENDIF - ENDIF - WRITE(LU_PART(NM+NMESHES),'(5X,ES13.6,1X,ES13.6)')PART_MIN, PART_MAX - ENDDO + WRITE(LU_PART(NM+NMESHES),'(5X,ES13.6,1X,ES13.6)')PART_MIN, PART_MAX + ENDDO + ELSEIF (IFRMT.EQ.1) THEN + WRITE(FN_PART_VTK(N,NM),'(A,A,A,A,A,I0,A,I8.8,I2.2,A)') "",TRIM(CHID),'_PART_',TRIM(LPC%ID),'_',NM,'_',ITM,ITM1,'.vtp' + IF (VTK_BINARY) THEN + VTK_ERROR = A_VTK_FILE%INITIALIZE(FORMAT='raw', FILENAME=FN_PART_VTK(N,NM), MESH_TOPOLOGY='PolyData') + ELSE + VTK_ERROR = A_VTK_FILE%INITIALIZE(FORMAT='ascii', FILENAME=FN_PART_VTK(N,NM), MESH_TOPOLOGY='PolyData') + ENDIF ! do not change capitalization on mesh topology + VTK_ERROR = A_VTK_FILE%XML_WRITER%WRITE_PIECE(NP=NPP, NC=0) + VTK_ERROR = A_VTK_FILE%XML_WRITER%WRITE_GEO(NP=NPP, NC=0, X=XP(1:NPP), Y=YP(1:NPP), Z=ZP(1:NPP)) + VTK_ERROR = A_VTK_FILE%XML_WRITER%W_DATA(LOCATION='NODE', ACTION='OPEN') + VTK_ERROR = A_VTK_FILE%XML_WRITER%W_DATA(DATA_NAME='TAG', X=TA) + DO NN=1,LPC%N_QUANTITIES + VTK_ERROR = A_VTK_FILE%XML_WRITER%W_DATA(DATA_NAME=LPC%SMOKEVIEW_LABEL(NN), X=QP(1:NPP,N)) + ENDDO + VTK_ERROR = A_VTK_FILE%XML_WRITER%W_DATA(LOCATION='NODE', ACTION='CLOSE') + VTK_ERROR = A_VTK_FILE%XML_WRITER%WRITE_PIECE() + VTK_ERROR = A_VTK_FILE%FINALIZE() + ENDIF DEALLOCATE(XP) DEALLOCATE(YP) diff --git a/Source/vtkf.f90 b/Source/vtkf.f90 index a8bb8d9a407..2b29962991e 100644 --- a/Source/vtkf.f90 +++ b/Source/vtkf.f90 @@ -12464,6 +12464,7 @@ MODULE VTK_FDS_INTERFACE PUBLIC BUILD_VTK_GAS_PHASE_GEOMETRY,BUILD_VTK_SOLID_PHASE_GEOMETRY,& WRITE_VTK_SL3D_WRAPPER,WRITE_VTK_SM3D_WRAPPER,WRITE_VTK_BNDF_WRAPPER,& + WRITE_VTK_PART_WRAPPER,& DEALLOCATE_VTK_GAS_PHASE_GEOMETRY,BUILD_VTK_GEOM_GEOMETRY CONTAINS @@ -12613,6 +12614,51 @@ END SUBROUTINE WRITE_VTK_BNDF_WRAPPER +SUBROUTINE WRITE_VTK_PART_WRAPPER(T,NMESHES) +INTEGER, INTENT(IN) :: NMESHES +REAL(EB), INTENT(IN) :: T +TYPE (LAGRANGIAN_PARTICLE_CLASS_TYPE), POINTER :: LPC +INTEGER :: I,IQ,ITM,ITM1,N,NN +REAL(FB) :: STIME +REAL(EB) :: TT +TYPE(PVTK_FILE) :: A_PVTK_FILE !< A parallel (partioned) VTK file. +INTEGER(IB8) :: VTK_ERROR=0_IB8 !< IO Error status. +CHARACTER(200) :: TMP_FILE + +! Generate filename +STIME = REAL(T_BEGIN + (T-T_BEGIN)*TIME_SHRINK_FACTOR,FB) +TT = T_BEGIN + (T-T_BEGIN)*TIME_SHRINK_FACTOR +ITM = INT(TT) +ITM1 = NINT(ABS(TT-ITM)*100) +IF (ITM1==100) THEN + ITM = ITM+1 + ITM1 = 0 +ENDIF + +DO N=1,N_LAGRANGIAN_CLASSES + LPC => LAGRANGIAN_PARTICLE_CLASS(N) + WRITE(FN_PART_VTK(N,NMESHES+1),'(A,A,A,A,A,I8.8,I2.2,A)') "",TRIM(CHID),'_PART_',TRIM(LPC%ID),'_',ITM,ITM1,'.pvtp' + VTK_ERROR = A_PVTK_FILE%INITIALIZE(FILENAME=FN_PART_VTK(N,NMESHES+1), MESH_TOPOLOGY='PPolyData',& + MESH_KIND='Float64') + VTK_ERROR = A_PVTK_FILE%XML_WRITER%W_DATA(LOCATION='NODE',ACTION='OPEN') + VTK_ERROR = A_PVTK_FILE%XML_WRITER%WRITE_PARALLEL_DATAARRAY(DATA_NAME="Tag", DATA_TYPE='Int32', NUMBER_OF_COMPONENTS=1) + ! Add PointData arrays + DO NN=1,LPC%N_QUANTITIES + VTK_ERROR = A_PVTK_FILE%XML_WRITER%WRITE_PARALLEL_DATAARRAY(DATA_NAME=TRIM(LPC%SMOKEVIEW_LABEL(NN)), & + DATA_TYPE='Float64', NUMBER_OF_COMPONENTS=1) + ENDDO + VTK_ERROR = A_PVTK_FILE%XML_WRITER%W_DATA(LOCATION='NODE',ACTION='CLOSE') + + DO I=1,NMESHES + WRITE(TMP_FILE,'(A,A,A,A,I0,A,I8.8,I2.2,A)') TRIM(CHID),'_PART_',TRIM(LPC%ID),'_',I,'_',ITM,ITM1,'.vtp' + VTK_ERROR = A_PVTK_FILE%XML_WRITER%WRITE_PARALLEL_GEO(SOURCE=TMP_FILE) + ENDDO + VTK_ERROR = A_PVTK_FILE%FINALIZE() +ENDDO + +END SUBROUTINE WRITE_VTK_PART_WRAPPER + + SUBROUTINE BUILD_VTK_GAS_PHASE_GEOMETRY(NM, & From 3c702f26d64243b2056030e71dd36fdf5be4d922 Mon Sep 17 00:00:00 2001 From: Jonathan Hodges <johodges@vt.edu> Date: Mon, 8 Jan 2024 14:20:23 -0500 Subject: [PATCH 31/31] Fix capitalization in vtk part TAG --- Source/vtkf.f90 | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Source/vtkf.f90 b/Source/vtkf.f90 index 2b29962991e..d9b56f897ad 100644 --- a/Source/vtkf.f90 +++ b/Source/vtkf.f90 @@ -12641,7 +12641,7 @@ SUBROUTINE WRITE_VTK_PART_WRAPPER(T,NMESHES) VTK_ERROR = A_PVTK_FILE%INITIALIZE(FILENAME=FN_PART_VTK(N,NMESHES+1), MESH_TOPOLOGY='PPolyData',& MESH_KIND='Float64') VTK_ERROR = A_PVTK_FILE%XML_WRITER%W_DATA(LOCATION='NODE',ACTION='OPEN') - VTK_ERROR = A_PVTK_FILE%XML_WRITER%WRITE_PARALLEL_DATAARRAY(DATA_NAME="Tag", DATA_TYPE='Int32', NUMBER_OF_COMPONENTS=1) + VTK_ERROR = A_PVTK_FILE%XML_WRITER%WRITE_PARALLEL_DATAARRAY(DATA_NAME="TAG", DATA_TYPE='Int32', NUMBER_OF_COMPONENTS=1) ! Add PointData arrays DO NN=1,LPC%N_QUANTITIES VTK_ERROR = A_PVTK_FILE%XML_WRITER%WRITE_PARALLEL_DATAARRAY(DATA_NAME=TRIM(LPC%SMOKEVIEW_LABEL(NN)), &