BLL2PS
The BLL2PS routine interpolates a budget-type scalar field from
a global latitude-longitude cylindrical grid (including the
poles) to a matched pair of Polar Stereographic grids centered
on the respective poles, where the orientation longitude
of the Southern Hemisphere grid is 180 degrees opposite
that of the Northern Hemisphere grid. This interpolation
is designed to approximate an area-average conserving
interpolation from fine to coarse resolution but to become
a bilinear interpolation from coarse to fine resolution.
This is accomplished by bilinearly interpolating to a much
finer Polar Stereographic grid and then area-averaging to
the output grid. The current configuration interpolates
to an extravagant 121 points in every output grid box.
This routine also would interpolate associated bitmaps.
This routine is configured only for (i,j,k) order grids.
This routine is fully vectorized and multitasked.
USAGE: CALL BLL2PS(IBM,IM,JM,KM,NPS,KB,TRUE,XMESH,ORIENT,
LB,B,LBN,BN,LBS,BS)
Input argument list:
IBM - INTEGER BITMAP IDENTIFIER
(0 FOR NO BITMAP, 1 TO INTERPOLATE BITMAP)
IM - INTEGER NUMBER OF INPUT LONGITUDES
JM - INTEGER NUMBER OF INPUT LATITUDES
KM - INTEGER NUMBER OF FIELDS TO INTERPOLATE
NPS - INTEGER ODD ORDER OF THE POLAR STEREOGRAPHIC GRIDS
(CENTER POINTS ARE THE POLE POINTS)
KB - INTEGER SKIP NUMBER BETWEEN INPUT FIELDS
TRUE - REAL LATITUDE AT WHICH PS GRID IS TRUE (USUALLY 60.)
XMESH - REAL GRID LENGTH AT TRUE LATITUDE (M)
ORIENT - REAL LONGITUDE AT BOTTOM OF NORTHERN PS GRID
(SOUTHERN PS GRID WILL HAVE OPPOSITE ORIENTATION.)
LB - LOGICAL (IM,JM,KM) BITMAP IF IBM=1
B - REAL (IM,JM,KM) SCALAR FIELD TO INTERPOLATE
Output argument list:
LBN - LOGICAL (NPS,NPS,KM) NORTHERN PS BITMAP IF IBM=1
BN - REAL (IM,JM,KM) INTERPOLATED NORTHERN PS FIELD
LBN - LOGICAL (NPS,NPS,KM) SOUTHERN PS BITMAP IF IBM=1
BN - REAL (IM,JM,KM) INTERPOLATED SOUTHERN PS FIELD
REMARKS: FORTRAN 90 EXTENSIONS ARE USED.
NCPUS
The NCPUS function designates the number of processors
over which to parallelize.
USAGE: NC=NCPUS()
Output arguments:
NCPUS INTEGER NUMBER OF CPUS
SPANALY
The SPANALY routine analyzes spectral coefficients from Fourier
coefficients for a latitude pair (Northern and Southern
Hemispheres). Vector components are multiplied by cosine
of latitude.
USAGE: CALL SPANALY(I,M,IM,IX,NC,NCTOP,KM,WGT,CLAT,PLN,PLNTOP,MP,
F,SPC,SPCTOP)
Input argument list:
I - INTEGER SPECTRAL DOMAIN SHAPE
(0 FOR TRIANGULAR, 1 FOR RHOMBOIDAL)
M - INTEGER SPECTRAL TRUNCATION
IM - INTEGER EVEN NUMBER OF FOURIER COEFFICIENTS
IX - INTEGER DIMENSION OF FOURIER COEFFICIENTS (IX>=IM+2)
NC - INTEGER DIMENSION OF SPECTRAL COEFFICIENTS
(NC>=(M+1)*((I+1)*M+2))
NCTOP - INTEGER DIMENSION OF SPECTRAL COEFFICIENTS OVER TOP
(NCTOP>=2*(M+1))
KM - INTEGER NUMBER OF FIELDS
WGT - REAL GAUSSIAN WEIGHT
CLAT - REAL COSINE OF LATITUDE
PLN - REAL ((M+1)*((I+1)*M+2)/2) LEGENDRE POLYNOMIALS
PLNTOP - REAL (M+1) LEGENDRE POLYNOMIAL OVER TOP
MP - INTEGER (KM) IDENTIFIERS (0 FOR SCALAR, 1 FOR VECTOR)
F - REAL (IX,2,KM) FOURIER COEFFICIENTS COMBINED
SPC - REAL (NC,KM) SPECTRAL COEFFICIENTS
SPCTOP - REAL (NCTOP,KM) SPECTRAL COEFFICIENTS OVER TOP
Output argument list:
SPC - REAL (NC,KM) SPECTRAL COEFFICIENTS
SPCTOP - REAL (NCTOP,KM) SPECTRAL COEFFICIENTS OVER TOP
SPDZ2UV
The SPDZ2UV routine computes the wind components from divergence
and vorticity in spectral space.
Subprogram SPEPS should be called already.
If l is the zonal wavenumber, n is the total wavenumber,
eps(l,n)=sqrt((n**2-l**2)/(4*n**2-1)) and a is earth radius,
then the zonal wind component u is computed as
U(L,N)=-I*L/(N*(N+1))*A*D(L,N)
+EPS(L,N+1)/(N+1)*A*Z(L,N+1)-EPS(L,N)/N*A*Z(L,N-1)
and the meridional wind component v is computed as
V(L,N)=-I*L/(N*(N+1))*A*Z(L,N)
-EPS(L,N+1)/(N+1)*A*D(L,N+1)+EPS(L,N)/N*A*D(L,N-1)
Where d is divergence and z is vorticity.
u and v are weighted by the cosine of latitude.
extra terms are computed over top of the spectral domain.
advantage is taken of the fact that eps(l,l)=0
in order to vectorize over the entire spectral domain.
USAGE: CALL SPDZ2UV(I,M,ENN1,ELONN1,EON,EONTOP,D,Z,U,V,UTOP,VTOP)
Input argument list:
I - INTEGER SPECTRAL DOMAIN SHAPE
(0 FOR TRIANGULAR, 1 FOR RHOMBOIDAL)
M - INTEGER SPECTRAL TRUNCATION
ENN1 - REAL ((M+1)*((I+1)*M+2)/2) N*(N+1)/A**2
ELONN1 - REAL ((M+1)*((I+1)*M+2)/2) L/(N*(N+1))*A
EON - REAL ((M+1)*((I+1)*M+2)/2) EPSILON/N*A
EONTOP - REAL (M+1) EPSILON/N*A OVER TOP
D - REAL ((M+1)*((I+1)*M+2)) DIVERGENCE
Z - REAL ((M+1)*((I+1)*M+2)) VORTICITY
Output argument list:
U - REAL ((M+1)*((I+1)*M+2)) ZONAL WIND (TIMES COSLAT)
V - REAL ((M+1)*((I+1)*M+2)) MERID WIND (TIMES COSLAT)
UTOP - REAL (2*(M+1)) ZONAL WIND (TIMES COSLAT) OVER TOP
VTOP - REAL (2*(M+1)) MERID WIND (TIMES COSLAT) OVER TOP
SPEPS
The SPEPS routine computes constant fields indexed in the
spectral domain in "IBM order" (zonal wavenumber is the
slower index).
If l is the zonal wavenumber and n is the total wavenumber
and a is the earth radius, then the fields returned are:
(1) Normalizing factor epsilon=sqrt((n**2-l**2)/(4*n**2-1))
(2) Laplacian factor n*(n+1)/a**2
(3) Zonal derivative/laplacian factor l/(n*(n+1))*a
(4) Meridional derivative/laplacian factor epsilon/n*a
USAGE: CALL SPEPS(I,M,EPS,EPSTOP,ENN1,ELONN1,EON,EONTOP)
Input argument list:
I - INTEGER SPECTRAL DOMAIN SHAPE
(0 FOR TRIANGULAR, 1 FOR RHOMBOIDAL)
M - INTEGER SPECTRAL TRUNCATION
Output argument list:
EPS - REAL ((M+1)*((I+1)*M+2)/2) SQRT((N**2-L**2)/(4*N**2-1))
EPSTOP - REAL (M+1) SQRT((N**2-L**2)/(4*N**2-1)) OVER TOP
ENN1 - REAL ((M+1)*((I+1)*M+2)/2) N*(N+1)/A**2
ELONN1 - REAL ((M+1)*((I+1)*M+2)/2) L/(N*(N+1))*A
EON - REAL ((M+1)*((I+1)*M+2)/2) EPSILON/N*A
EONTOP - REAL (M+1) EPSILON/N*A OVER TOP
SPFFT
The SPFFT routine performs multiple fast fourier transforms
between complex amplitudes in Fourier space and real values
in cyclic physical space.
Subprogram SPFFT must be invoked first with idir=0
to initialize trigonemetric data. Use subprogram SPFFT1
to perform an FFT without previous initialization.
This version invokes the IBM ESSL FFT.
USAGE: CALL SPFFT(IMAX,INCW,INCG,KMAX,W,G,IDIR)
Input argument list:
IMAX - INTEGER NUMBER OF VALUES IN THE CYCLIC PHYSICAL SPACE
(SEE LIMITATIONS ON IMAX IN REMARKS BELOW.)
INCW - INTEGER FIRST DIMENSION OF THE COMPLEX AMPLITUDE ARRAY
(INCW >= IMAX/2+1)
INCG - INTEGER FIRST DIMENSION OF THE REAL VALUE ARRAY
(INCG >= IMAX)
KMAX - INTEGER NUMBER OF TRANSFORMS TO PERFORM
W - COMPLEX(INCW,KMAX) COMPLEX AMPLITUDES IF IDIR>0
G - REAL(INCG,KMAX) REAL VALUES IF IDIR<0
IDIR - INTEGER DIRECTION FLAG
IDIR=0 TO INITIALIZE INTERNAL TRIGONOMETRIC DATA
IDIR>0 TO TRANSFORM FROM FOURIER TO PHYSICAL SPACE
IDIR<0 TO TRANSFORM FROM PHYSICAL TO FOURIER SPACE
Output argument list:
W - COMPLEX(INCW,KMAX) COMPLEX AMPLITUDES IF IDIR<0
G - REAL(INCG,KMAX) REAL VALUES IF IDIR>0
SPFFT1
The SPFFT1 routine performs multiple fast Fourier transforms
between complex amplitudes in Fourier space and real values
in cyclic physical space.
Subprogram spfft1 initializes trigonometric data each call.
use subprogram spfft to save time and initialize once.
This version invokes the IBM ESSL FFT.
USAGE: CALL SPFFT1(IMAX,INCW,INCG,KMAX,W,G,IDIR)
INPUT ARGUMENT LIST:
IMAX - INTEGER NUMBER OF VALUES IN THE CYCLIC PHYSICAL SPACE
(SEE LIMITATIONS ON IMAX IN REMARKS BELOW.)
INCW - INTEGER FIRST DIMENSION OF THE COMPLEX AMPLITUDE ARRAY
(INCW >= IMAX/2+1)
INCG - INTEGER FIRST DIMENSION OF THE REAL VALUE ARRAY
(INCG >= IMAX)
KMAX - INTEGER NUMBER OF TRANSFORMS TO PERFORM
W - COMPLEX(INCW,KMAX) COMPLEX AMPLITUDES IF IDIR>0
G - REAL(INCG,KMAX) REAL VALUES IF IDIR<0
IDIR - INTEGER DIRECTION FLAG
IDIR>0 TO TRANSFORM FROM FOURIER TO PHYSICAL SPACE
IDIR<0 TO TRANSFORM FROM PHYSICAL TO FOURIER SPACE
OUTPUT ARGUMENT LIST:
W - COMPLEX(INCW,KMAX) COMPLEX AMPLITUDES IF IDIR<0
G - REAL(INCG,KMAX) REAL VALUES IF IDIR>0
SPFFTE
The SPFFTE routine performs multiple fast Fourier transforms
between complex amplitudes in Fourier space and real values
in cyclic physical space.
Subprogram SPFFTE must be invoked first with idir=0
to initialize trigonemetric data. Use subprogram SPFFT1
to perform an FFT without previous initialization.
This version invokes the IBM ESSL FFT.
USAGE: CALL SPFFTE(IMAX,INCW,INCG,KMAX,W,G,IDIR,AFFT)
Input argument list:
IMAX - INTEGER NUMBER OF VALUES IN THE CYCLIC PHYSICAL SPACE
(SEE LIMITATIONS ON IMAX IN REMARKS BELOW.)
INCW - INTEGER FIRST DIMENSION OF THE COMPLEX AMPLITUDE ARRAY
(INCW >= IMAX/2+1)
INCG - INTEGER FIRST DIMENSION OF THE REAL VALUE ARRAY
(INCG >= IMAX)
KMAX - INTEGER NUMBER OF TRANSFORMS TO PERFORM
W - COMPLEX(INCW,KMAX) COMPLEX AMPLITUDES IF IDIR>0
G - REAL(INCG,KMAX) REAL VALUES IF IDIR<0
IDIR - INTEGER DIRECTION FLAG
IDIR=0 TO INITIALIZE TRIGONOMETRIC DATA
IDIR>0 TO TRANSFORM FROM FOURIER TO PHYSICAL SPACE
IDIR<0 TO TRANSFORM FROM PHYSICAL TO FOURIER SPACE
AFFT REAL(8) (50000+4*IMAX) AUXILIARY ARRAY IF IDIR<>0
Output argument list:
W - COMPLEX(INCW,KMAX) COMPLEX AMPLITUDES IF IDIR<0
G - REAL(INCG,KMAX) REAL VALUES IF IDIR>0
AFFT REAL(8) (50000+4*IMAX) AUXILIARY ARRAY IF IDIR=0
SPFFTPT
The SPFFTPT routine computes a slow Fourier Transform
from Fourier space to a set of gridpoints.
USAGE: CALL SPFFTPT(M,N,INCW,INCG,KMAX,RLON,W,G)
Input argument list:
M - INTEGER FOURIER WAVENUMBER TRUNCATION
N - INTEGER NUMBER OF GRIDPOINTS
INCW - INTEGER FIRST DIMENSION OF THE COMPLEX AMPLITUDE ARRAY
(INCW >= M+1)
INCG - INTEGER FIRST DIMENSION OF THE GRIDPOINT ARRAY
(INCG >= N)
KMAX - INTEGER NUMBER OF FOURIER FIELDS
RLON - REAL(N) GRID LONGITUDES IN DEGREES
W - COMPLEX(INCW,KMAX) FOURIER AMPLITUDES
Output argument list:
G - REAL(INCG,KMAX) GRIDPOINT VALUES
SPGRADQ
The SPGRADQ routine computes the horizontal vector gradient of
a scalar field in spectral space.
Subprogram SPEPS should be called already.
If l is the zonal wavenumber, n is the total wavenumber,
eps(l,n)=sqrt((n**2-l**2)/(4*n**2-1)) and a is earth radius,
then the zonal gradient of q(l,n) is simply i*l/a*q(l,n)
while the Meridional Gradient of q(l,n) is computed as
eps(l,n+1)*(n+2)/a*q(l,n+1)-eps(l,n+1)*(n-1)/a*q(l,n-1).
extra terms are computed over top of the spectral domain.
Advantage is taken of the fact that eps(l,l)=0 in
order to vectorize over the entire spectral domain.
USAGE: CALL SPGRADQ(I,M,ENN1,ELONN1,EON,EONTOP,Q,QDX,QDY,QDYTOP)
Input argument list:
I - INTEGER SPECTRAL DOMAIN SHAPE
(0 FOR TRIANGULAR, 1 FOR RHOMBOIDAL)
M - INTEGER SPECTRAL TRUNCATION
ENN1 - REAL ((M+1)*((I+1)*M+2)/2) N*(N+1)/A**2
ELONN1 - REAL ((M+1)*((I+1)*M+2)/2) L/(N*(N+1))*A
EON - REAL ((M+1)*((I+1)*M+2)/2) EPSILON/N*A
EONTOP - REAL (M+1) EPSILON/N*A OVER TOP
Q - REAL ((M+1)*((I+1)*M+2)) SCALAR FIELD
Output argument list:
QDX - REAL ((M+1)*((I+1)*M+2)) ZONAL GRADIENT (TIMES COSLAT)
QDY - REAL ((M+1)*((I+1)*M+2)) MERID GRADIENT (TIMES COSLAT)
QDYTOP - REAL (2*(M+1)) MERID GRADIENT (TIMES COSLAT) OVER TOP
SPGRADX
The SPGRADX routine computes the x-gradient of fields
in complex Fourier space.
In this case, the wavenumber 1 amplitudes are used
WX=CONJG(W)*L/RERTH
where l is the wavenumber and rerth is the earth radius,
So that the result is the x-gradient of the pseudo-vector.
The x-gradient of a scalar field W is:
WX=CONJG(W)*L/(RERTH*CLAT)
Where clat is the cosine of latitude.
At the pole this is undefined, so the way to get
The x-gradient at the pole is by passing both
The weighted wavenumber 0 and the unweighted wavenumber 1
amplitudes at the pole and setting MP=10.
In this case, the wavenumber 1 amplitudes are used
to compute the x-gradient and then zeroed out.
Input argument list:
M - INTEGER FOURIER WAVENUMBER TRUNCATION
INCW - INTEGER FIRST DIMENSION OF THE COMPLEX AMPLITUDE ARRAY
(INCW >= M+1)
KMAX - INTEGER NUMBER OF FOURIER FIELDS
MP - INTEGER (KM) IDENTIFIERS
(0 OR 10 FOR SCALAR, 1 FOR VECTOR)
CLAT - REAL COSINE OF LATITUDE
W - COMPLEX(INCW,KMAX) FOURIER AMPLITUDES
Output argument list:
W - COMPLEX(INCW,KMAX) FOURIER AMPLITUDES
CORRECTED WHEN MP=10 AND CLAT=0
WX - COMPLEX(INCW,KMAX) COMPLEX AMPLITUDES OF X-GRADIENTS
SPGRADY
The SPGRADY routine computes the horizontal vector y-gradient
of a scalar field in spectral space.
Subprogram speps should be called already.
If L is the zonal wavenumber, N is the total wavenumber,
EPS(L,N)=SQRT((N**2-L**2)/(4*N**2-1)) and a is earth radius,
then the meridional gradient of Q(L,N) is computed as
EPS(L,N+1)*(N+2)/A*Q(L,N+1)-EPS(L,N+1)*(N-1)/A*Q(L,N-1).
Extra terms are computed over top of the spectral domain.
advantage is taken of the fact that EPS(L,L)=0
In order to vectorize over the entire spectral domain.
USAGE: CALL SPGRADY(I,M,ENN1,EON,EONTOP,Q,QDY,QDYTOP)
Input argument list:
I - INTEGER SPECTRAL DOMAIN SHAPE
(0 FOR TRIANGULAR, 1 FOR RHOMBOIDAL)
M - INTEGER SPECTRAL TRUNCATION
ENN1 - REAL ((M+1)*((I+1)*M+2)/2) N*(N+1)/A**2
EON - REAL ((M+1)*((I+1)*M+2)/2) EPSILON/N*A
EONTOP - REAL (M+1) EPSILON/N*A OVER TOP
Q - REAL ((M+1)*((I+1)*M+2)) SCALAR FIELD
Output argument list:
QDY - REAL ((M+1)*((I+1)*M+2)) MERID GRADIENT (TIMES COSLAT)
QDYTOP - REAL (2*(M+1)) MERID GRADIENT (TIMES COSLAT) OVER TOP
SPLAPLAC
The SPLAPLAC routine computes the Laplacian or the inverse Laplacian
of a scalar field in spectral space.
Subprogram speps should be called already.
The Laplacian of q(l,n) is simply -n*(n+1)/a**2*q(l,n)
USAGE: CALL SPLAPLAC(I,M,ENN1,Q,QD2,IDIR)
Input argument list:
I - INTEGER SPECTRAL DOMAIN SHAPE
(0 FOR TRIANGULAR, 1 FOR RHOMBOIDAL)
M - INTEGER SPECTRAL TRUNCATION
ENN1 - REAL ((M+1)*((I+1)*M+2)/2) N*(N+1)/A**2
Q - IF IDIR > 0, REAL ((M+1)*((I+1)*M+2)) SCALAR FIELD
QD2 - IF IDIR < 0, REAL ((M+1)*((I+1)*M+2)) LAPLACIAN
IDIR - INTEGER FLAG
IDIR > 0 TO TAKE LAPLACIAN
IDIR < 0 TO TAKE INVERSE LAPLACIAN
Output argument list:
Q - IF IDIR < 0, REAL ((M+1)*((I+1)*M+2)) SCALAR FIELD
(Q(0,0) IS NOT COMPUTED)
QD2 - IF IDIR > 0, REAL ((M+1)*((I+1)*M+2)) LAPLACIAN
SPLAT
The SPLAT routine computes cosines of colatitude and gaussian weights
for one of the following specific global sets of latitudes.
Gaussian latitudes (idrt=4)
Equally-Spaced latitudes including poles (idrt=0)
Equally-Spaced latitudes excluding poles (idrt=256)
The Gaussian latitudes are located at the zeroes of the
legendre polynomial of the given order. These latitudes
are efficient for reversible transforms from spectral space.
(about twice as many equally-spaced latitudes are needed.)
The weights for the equally-spaced latitudes are based on
Ellsaesser (Jan,1966). (No weight is given the pole point.)
note that when analyzing grid to spectral in latitude pairs,
If an equator point exists, its weight should be halved.
This version invokes the IBM ESSL Matrix Solver.
USAGE: CALL SPLAT(IDRT,JMAX,SLAT,WLAT)
Input argument list:
IDRT - INTEGER GRID IDENTIFIER
(IDRT=4 FOR GAUSSIAN GRID,
IDRT=0 FOR EQUALLY-SPACED GRID INCLUDING POLES,
IDRT=256 FOR EQUALLY-SPACED GRID EXCLUDING POLES)
JMAX - INTEGER NUMBER OF LATITUDES.
Output argument list:
SLAT - REAL (JMAX) SINES OF LATITUDE.
WLAT - REAL (JMAX) GAUSSIAN WEIGHTS.
SPLEGEND
The SPLEGEND routine evaluates the Orthonormal associated
legendre Polynomials in the spectral domain at a
given latitude.
Subprogram SPLEGEND should be called already.
If l is the zonal wavenumber, n is the total wavenumber,
and eps(l,n)=sqrt((n**2-l**2)/(4*n**2-1)) then
The following bootstrapping formulas are used:
pln(0,0)=sqrt(0.5)
pln(l,l)=pln(l-1,l-1)*clat*sqrt(float(2*l+1)/float(2*l))
pln(l,n)=(slat*pln(l,n-1)-eps(l,n-1)*pln(l,n-2))/eps(l,n)
Synthesis at the pole needs only two zonal wavenumbers.
Scalar fields are synthesized with zonal wavenumber 0 while
vector fields are synthesized with zonal wavenumber 1.
(Thus polar vector fields are implicitly divided by clat.)
The following bootstrapping formulas are used at the pole:
pln(0,0)=sqrt(0.5)
pln(1,1)=sqrt(0.75)
pln(l,n)=(pln(l,n-1)-eps(l,n-1)*pln(l,n-2))/eps(l,n)
USAGE: CALL SPLEGEND(I,M,SLAT,CLAT,EPS,EPSTOP,PLN,PLNTOP)
Input argument list:
I - INTEGER SPECTRAL DOMAIN SHAPE
(0 FOR TRIANGULAR, 1 FOR RHOMBOIDAL)
M - INTEGER SPECTRAL TRUNCATION
SLAT - REAL SINE OF LATITUDE
CLAT - REAL COSINE OF LATITUDE
EPS - REAL ((M+1)*((I+1)*M+2)/2) SQRT((N**2-L**2)/(4*N**2-1))
EPSTOP - REAL (M+1) SQRT((N**2-L**2)/(4*N**2-1)) OVER TOP
Output argument list:
PLN - REAL ((M+1)*((I+1)*M+2)/2) LEGENDRE POLYNOMIAL
PLNTOP - REAL (M+1) LEGENDRE POLYNOMIAL OVER TOP
SPPAD
The SPPAD routine pads or truncates a spectral field.
USAGE: CALL SPPAD(I1,M1,Q1,I2,M2,Q2)
Input argument list:
I1 - INTEGER INPUT SPECTRAL DOMAIN SHAPE
(0 FOR TRIANGULAR, 1 FOR RHOMBOIDAL)
M1 - INTEGER INPUT SPECTRAL TRUNCATION
Q1 - REAL ((M+1)*((I+1)*M+2)) INPUT FIELD
I2 - INTEGER OUTPUT SPECTRAL DOMAIN SHAPE
(0 FOR TRIANGULAR, 1 FOR RHOMBOIDAL)
M2 - INTEGER OUTPUT SPECTRAL TRUNCATION
Output argument list:
Q2 - REAL ((M+1)*((I+1)*M+2)) OUTPUT FIELD
SPSYNTH
The SPSYNTH routine synthesizes Fourier coefficients from
spectral coefficients for a latitude pair (Northern and
Southern Hemispheres). Vector components are divided by
cosine of latitude.
USAGE: CALL SPSYNTH(I,M,IM,IX,NC,NCTOP,KM,CLAT,PLN,PLNTOP,MP,
SPC,SPCTOP,F)
Input argument list:
I - INTEGER SPECTRAL DOMAIN SHAPE
(0 FOR TRIANGULAR, 1 FOR RHOMBOIDAL)
M - INTEGER SPECTRAL TRUNCATION
IM - INTEGER EVEN NUMBER OF FOURIER COEFFICIENTS
IX - INTEGER DIMENSION OF FOURIER COEFFICIENTS (IX>=IM+2)
NC - INTEGER DIMENSION OF SPECTRAL COEFFICIENTS
(NC>=(M+1)*((I+1)*M+2))
NCTOP - INTEGER DIMENSION OF SPECTRAL COEFFICIENTS OVER TOP
(NCTOP>=2*(M+1))
KM - INTEGER NUMBER OF FIELDS
CLAT - REAL COSINE OF LATITUDE
PLN - REAL ((M+1)*((I+1)*M+2)/2) LEGENDRE POLYNOMIAL
PLNTOP - REAL (M+1) LEGENDRE POLYNOMIAL OVER TOP
SPC - REAL (NC,KM) SPECTRAL COEFFICIENTS
SPCTOP - REAL (NCTOP,KM) SPECTRAL COEFFICIENTS OVER TOP
MP - INTEGER (KM) IDENTIFIERS (0 FOR SCALAR, 1 FOR VECTOR)
Output argument list:
F - REAL (IX,2,KM) FOURIER COEFFICIENTS FOR LATITUDE PAIR
SPTEZ
The SPTEZ routine performs a Spherical transform between
spectral coefficients of a scalar quantity and a field
on a global cylindrical grid.
The wave-space can be either Triangular or Rhomboidal.
The grid-space can be either an equally-spaced grid
(with or without pole points) or a Gaussian grid.
The wave field is in sequential 'IBM order'.
The grid field is indexed East to West, then North to South.
For more flexibility and efficiency, call SPTRAN.
Subprogram can be called from a multiprocessing environment.
USAGE: CALL SPTEZ(IROMB,MAXWV,IDRT,IMAX,JMAX,WAVE,GRID,IDIR)
Input arguments:
IROMB - INTEGER SPECTRAL DOMAIN SHAPE
(0 FOR TRIANGULAR, 1 FOR RHOMBOIDAL)
MAXWV - INTEGER SPECTRAL TRUNCATION
IDRT - INTEGER GRID IDENTIFIER
(IDRT=4 FOR GAUSSIAN GRID,
IDRT=0 FOR EQUALLY-SPACED GRID INCLUDING POLES,
IDRT=256 FOR EQUALLY-SPACED GRID EXCLUDING POLES)
IMAX - INTEGER EVEN NUMBER OF LONGITUDES.
JMAX - INTEGER NUMBER OF LATITUDES.
WAVE - REAL (2*MX) WAVE FIELD IF IDIR>0
WHERE MX=(MAXWV+1)*((IROMB+1)*MAXWV+2)/2
GRID - REAL (IMAX,JMAX) GRID FIELD (E->W,N->S) IF IDIR<0
IDIR - INTEGER TRANSFORM FLAG
(IDIR>0 FOR WAVE TO GRID, IDIR<0 FOR GRID TO WAVE)
Output arguments:
WAVE - REAL (2*MX) WAVE FIELD IF IDIR<0
WHERE MX=(MAXWV+1)*((IROMB+1)*MAXWV+2)/2
GRID - REAL (IMAX,JMAX) GRID FIELD (E->W,N->S) IF IDIR>0
REMARKS:
MINIMUM GRID DIMENSIONS FOR UNALIASED TRANSFORMS TO SPECTRAL:
DIMENSION LINEAR QUADRATIC
----------------------- --------- -------------
IMAX 2*MAXWV+2 3*MAXWV/2*2+2
JMAX (IDRT=4,IROMB=0) 1*MAXWV+1 3*MAXWV/2+1
JMAX (IDRT=4,IROMB=1) 2*MAXWV+1 5*MAXWV/2+1
JMAX (IDRT=0,IROMB=0) 2*MAXWV+3 3*MAXWV/2*2+3
JMAX (IDRT=0,IROMB=1) 4*MAXWV+3 5*MAXWV/2*2+3
JMAX (IDRT=256,IROMB=0) 2*MAXWV+1 3*MAXWV/2*2+1
JMAX (IDRT=256,IROMB=1) 4*MAXWV+1 5*MAXWV/2*2+1
SPTEZD
The SPTEZD routine performs a spherical transform
between spectral coefficients of a scalar field
and its mean and gradient on a global cylindrical grid.
The wave-space can be either Triangular or Rhomboidal.
The grid-space can be either an equally-spaced grid
(with or without pole points) or a Gaussian grid.
The wave field is in sequential 'IBM order'.
The grid fiels is indexed East to West, then North to South.
For more flexibility and efficiency, call SPTRAN.
Subprogram can be called from a multiprocessing environment.
USAGE: CALL SPTEZD(IROMB,MAXWV,IDRT,IMAX,JMAX,
WAVE,GRIDMN,GRIDX,GRIDY,IDIR)
Input arguments:
IROMB - INTEGER SPECTRAL DOMAIN SHAPE
(0 FOR TRIANGULAR, 1 FOR RHOMBOIDAL)
MAXWV - INTEGER SPECTRAL TRUNCATION
IDRT - INTEGER GRID IDENTIFIER
(IDRT=4 FOR GAUSSIAN GRID,
IDRT=0 FOR EQUALLY-SPACED GRID INCLUDING POLES,
IDRT=256 FOR EQUALLY-SPACED GRID EXCLUDING POLES)
IMAX - INTEGER EVEN NUMBER OF LONGITUDES.
JMAX - INTEGER NUMBER OF LATITUDES.
WAVE - REAL (*) WAVE FIELD IF IDIR>0
GRIDMN - REAL GLOBAL MEAN IF IDIR<0
GRIDX - REAL (IMAX,JMAX) GRID X-GRADIENTS (E->W,N->S) IF IDIR<0
GRIDY - REAL (IMAX,JMAX) GRID Y-GRADIENTS (E->W,N->S) IF IDIR<0
IDIR - INTEGER TRANSFORM FLAG
(IDIR>0 FOR WAVE TO GRID, IDIR<0 FOR GRID TO WAVE)
Output arguments:
WAVE - REAL (*) WAVE FIELD IF IDIR<0
GRIDMN - REAL GLOBAL MEAN IF IDIR>0
GRIDX - REAL (IMAX,JMAX) GRID X-GRADIENTS (E->W,N->S) IF IDIR>0
GRIDY - REAL (IMAX,JMAX) GRID Y-GRADIENTS (E->W,N->S) IF IDIR>0
REMARKS:
MINIMUM GRID DIMENSIONS FOR UNALIASED TRANSFORMS TO SPECTRAL:
DIMENSION LINEAR QUADRATIC
----------------------- --------- -------------
IMAX 2*MAXWV+2 3*MAXWV/2*2+2
JMAX (IDRT=4,IROMB=0) 1*MAXWV+1 3*MAXWV/2+1
JMAX (IDRT=4,IROMB=1) 2*MAXWV+1 5*MAXWV/2+1
JMAX (IDRT=0,IROMB=0) 2*MAXWV+3 3*MAXWV/2*2+3
JMAX (IDRT=0,IROMB=1) 4*MAXWV+3 5*MAXWV/2*2+3
JMAX (IDRT=256,IROMB=0) 2*MAXWV+1 3*MAXWV/2*2+1
JMAX (IDRT=256,IROMB=1) 4*MAXWV+1 5*MAXWV/2*2+1
SPTEZM
The SPTEZM routine performs spherical transforms
between spectral coefficients of scalar quantities
and fields on a global cylindrical grid.
The wave-space can be either Triangular or Rhomboidal.
The grid-space can be either an equally-spaced grid
(with or without pole points) or a Gaussian grid.
wave fields are in sequential 'IBM order'.
Grid fields are indexed East to West, Then North to South.
For more flexibility and efficiency, call SPTRAN.
Subprogram can be called from a multiprocessing environment.
USAGE: CALL SPTEZM(IROMB,MAXWV,IDRT,IMAX,JMAX,KMAX,WAVE,GRID,IDIR)
Input arguments:
IROMB - INTEGER SPECTRAL DOMAIN SHAPE
(0 FOR TRIANGULAR, 1 FOR RHOMBOIDAL)
MAXWV - INTEGER SPECTRAL TRUNCATION
IDRT - INTEGER GRID IDENTIFIER
(IDRT=4 FOR GAUSSIAN GRID,
IDRT=0 FOR EQUALLY-SPACED GRID INCLUDING POLES,
IDRT=256 FOR EQUALLY-SPACED GRID EXCLUDING POLES)
IMAX - INTEGER EVEN NUMBER OF LONGITUDES
JMAX - INTEGER NUMBER OF LATITUDES
KMAX - INTEGER NUMBER OF FIELDS TO TRANSFORM
WAVE - REAL (2*MX,KMAX) WAVE FIELD IF IDIR>0
WHERE MX=(MAXWV+1)*((IROMB+1)*MAXWV+2)/2
GRID - REAL (IMAX,JMAX,KMAX) GRID FIELD (E->W,N->S) IF IDIR<0
IDIR - INTEGER TRANSFORM FLAG
(IDIR>0 FOR WAVE TO GRID, IDIR<0 FOR GRID TO WAVE)
Output arguments:
WAVE - REAL (2*MX,KMAX) WAVE FIELD IF IDIR<0
WHERE MX=(MAXWV+1)*((IROMB+1)*MAXWV+2)/2
GRID - REAL (IMAX,JMAX,KMAX) GRID FIELD (E->W,N->S) IF IDIR>0
REMARKS:
MINIMUM GRID DIMENSIONS FOR UNALIASED TRANSFORMS TO SPECTRAL:
DIMENSION LINEAR QUADRATIC
----------------------- --------- -------------
IMAX 2*MAXWV+2 3*MAXWV/2*2+2
JMAX (IDRT=4,IROMB=0) 1*MAXWV+1 3*MAXWV/2+1
JMAX (IDRT=4,IROMB=1) 2*MAXWV+1 5*MAXWV/2+1
JMAX (IDRT=0,IROMB=0) 2*MAXWV+3 3*MAXWV/2*2+3
JMAX (IDRT=0,IROMB=1) 4*MAXWV+3 5*MAXWV/2*2+3
JMAX (IDRT=256,IROMB=0) 2*MAXWV+1 3*MAXWV/2*2+1
JMAX (IDRT=256,IROMB=1) 4*MAXWV+1 5*MAXWV/2*2+1
SPTEZMD
The SPTEZMD routine performs spherical transforms
between spectral coefficients of scalar fields
and their means and gradients on a global cylindrical
grid. The wave-space can be either Triangular or Rhomboidal.
The grid-space can be either an equally-spaced grid
(with or without pole points) or a Gaussian grid.
The wave fields are in sequential 'IBM order'.
The grid fields are indexed East to West, then North to South.
For more flexibility and efficiency, call SPTRAN.
Subprogram can be called from a multiprocessing environment.
USAGE: CALL SPTEZMD(IROMB,MAXWV,IDRT,IMAX,JMAX,KMAX,
WAVE,GRIDMN,GRIDX,GRIDY,IDIR)
Input arguments:
IROMB - INTEGER SPECTRAL DOMAIN SHAPE
(0 FOR TRIANGULAR, 1 FOR RHOMBOIDAL)
MAXWV - INTEGER SPECTRAL TRUNCATION
IDRT - INTEGER GRID IDENTIFIER
(IDRT=4 FOR GAUSSIAN GRID,
IDRT=0 FOR EQUALLY-SPACED GRID INCLUDING POLES,
IDRT=256 FOR EQUALLY-SPACED GRID EXCLUDING POLES)
IMAX - INTEGER EVEN NUMBER OF LONGITUDES.
JMAX - INTEGER NUMBER OF LATITUDES.
WAVE - REAL (MX,KMAX) WAVE FIELD IF IDIR>0
WHERE MX=(MAXWV+1)*((IROMB+1)*MAXWV+2)
GRIDMN - REAL (KMAX) GLOBAL MEAN IF IDIR<0
GRIDX - REAL (IMAX,JMAX,KMAX) GRID X-GRADIENTS (E->W,N->S) IF IDIR<0
GRIDY - REAL (IMAX,JMAX,KMAX) GRID Y-GRADIENTS (E->W,N->S) IF IDIR<0
IDIR - INTEGER TRANSFORM FLAG
(IDIR>0 FOR WAVE TO GRID, IDIR<0 FOR GRID TO WAVE)
Output arguments:
WAVE - REAL (MX,KMAX) WAVE FIELD IF IDIR<0
WHERE MX=(MAXWV+1)*((IROMB+1)*MAXWV+2)
GRIDMN - REAL (KMAX) GLOBAL MEAN IF IDIR>0
GRIDX - REAL (IMAX,JMAX,KMAX) GRID X-GRADIENTS (E->W,N->S) IF IDIR>0
GRIDY - REAL (IMAX,JMAX,KMAX) GRID Y-GRADIENTS (E->W,N->S) IF IDIR>0
REMARKS:
MINIMUM GRID DIMENSIONS FOR UNALIASED TRANSFORMS TO SPECTRAL:
DIMENSION LINEAR QUADRATIC
----------------------- --------- -------------
IMAX 2*MAXWV+2 3*MAXWV/2*2+2
JMAX (IDRT=4,IROMB=0) 1*MAXWV+1 3*MAXWV/2+1
JMAX (IDRT=4,IROMB=1) 2*MAXWV+1 5*MAXWV/2+1
JMAX (IDRT=0,IROMB=0) 2*MAXWV+3 3*MAXWV/2*2+3
JMAX (IDRT=0,IROMB=1) 4*MAXWV+3 5*MAXWV/2*2+3
JMAX (IDRT=256,IROMB=0) 2*MAXWV+1 3*MAXWV/2*2+1
JMAX (IDRT=256,IROMB=1) 4*MAXWV+1 5*MAXWV/2*2+1
SPTEZMV
The SPTEZMV routine performs Spherical transforms
between spectral coefficients of divergence and curl
and vector fields on a global cylindrical grid.
The wave-space can be either Triangular or Rhomboidal.
The grid-space can be either an equally-spaced grid
(with or without pole points) or a Gaussian grid.
wave fields are in sequential 'IBM order'.
Grid fields are indexed East to West, then North to South.
For more flexibility and efficiency, call SPTRAN.
Subprogram can be called from a multiprocessing environment.
USAGE: CALL SPTEZMV(IROMB,MAXWV,IDRT,IMAX,JMAX,KMAX,
WAVED,WAVEZ,GRIDU,GRIDV,IDIR)
Input arguments:
IROMB - INTEGER SPECTRAL DOMAIN SHAPE
(0 FOR TRIANGULAR, 1 FOR RHOMBOIDAL)
MAXWV - INTEGER SPECTRAL TRUNCATION
IDRT - INTEGER GRID IDENTIFIER
(IDRT=4 FOR GAUSSIAN GRID,
IDRT=0 FOR EQUALLY-SPACED GRID INCLUDING POLES,
IDRT=256 FOR EQUALLY-SPACED GRID EXCLUDING POLES)
IMAX - INTEGER EVEN NUMBER OF LONGITUDES
JMAX - INTEGER NUMBER OF LATITUDES
KMAX - INTEGER NUMBER OF FIELDS TO TRANSFORM
WAVED - REAL (2*MX,KMAX) WAVE DIVERGENCE FIELD IF IDIR>0
WHERE MX=(MAXWV+1)*((IROMB+1)*MAXWV+2)/2
WAVEZ - REAL (2*MX,KMAX) WAVE VORTICITY FIELD IF IDIR>0
WHERE MX=(MAXWV+1)*((IROMB+1)*MAXWV+2)/2
GRIDU - REAL (IMAX,JMAX,KMAX) GRID U-WIND (E->W,N->S) IF IDIR<0
GRIDV - REAL (IMAX,JMAX,KMAX) GRID V-WIND (E->W,N->S) IF IDIR<0
IDIR - INTEGER TRANSFORM FLAG
(IDIR>0 FOR WAVE TO GRID, IDIR<0 FOR GRID TO WAVE)
Output arguments:
WAVED - REAL (2*MX,KMAX) WAVE DIVERGENCE FIELD IF IDIR<0
WHERE MX=(MAXWV+1)*((IROMB+1)*MAXWV+2)/2
WAVEZ - REAL (2*MX,KMAX) WAVE VORTICITY FIELD IF IDIR>0
WHERE MX=(MAXWV+1)*((IROMB+1)*MAXWV+2)/2
GRIDU - REAL (IMAX,JMAX,KMAX) GRID U-WIND (E->W,N->S) IF IDIR>0
GRIDV - REAL (IMAX,JMAX,KMAX) GRID V-WIND (E->W,N->S) IF IDIR>0
REMARKS:
MINIMUM GRID DIMENSIONS FOR UNALIASED TRANSFORMS TO SPECTRAL:
DIMENSION LINEAR QUADRATIC
----------------------- --------- -------------
IMAX 2*MAXWV+2 3*MAXWV/2*2+2
JMAX (IDRT=4,IROMB=0) 1*MAXWV+1 3*MAXWV/2+1
JMAX (IDRT=4,IROMB=1) 2*MAXWV+1 5*MAXWV/2+1
JMAX (IDRT=0,IROMB=0) 2*MAXWV+3 3*MAXWV/2*2+3
JMAX (IDRT=0,IROMB=1) 4*MAXWV+3 5*MAXWV/2*2+3
JMAX (IDRT=256,IROMB=0) 2*MAXWV+1 3*MAXWV/2*2+1
JMAX (IDRT=256,IROMB=1) 4*MAXWV+1 5*MAXWV/2*2+1
SPTEZV
The SPTEZV routine performs a Spherical transform
between spectral coefficients of divergence and curl
and a vector field on a global cylindrical grid.
The wave-space can be either Triangular or Rhomboidal.
The grid-space can be either an equally-spaced grid
(with or without pole points) or a Gaussian grid.
The wave field is in sequential 'IBM order'.
The grid fiels is indexed East to West, then North to South.
For more flexibility and efficiency, call SPTRAN.
Subprogram can be called from a multiprocessing environment.
USAGE: CALL SPTEZV(IROMB,MAXWV,IDRT,IMAX,JMAX,
WAVED,WAVEZ,GRIDU,GRIDV,IDIR)
Input arguments:
IROMB - INTEGER SPECTRAL DOMAIN SHAPE
(0 FOR TRIANGULAR, 1 FOR RHOMBOIDAL)
MAXWV - INTEGER SPECTRAL TRUNCATION
IDRT - INTEGER GRID IDENTIFIER
(IDRT=4 FOR GAUSSIAN GRID,
IDRT=0 FOR EQUALLY-SPACED GRID INCLUDING POLES,
IDRT=256 FOR EQUALLY-SPACED GRID EXCLUDING POLES)
IMAX - INTEGER EVEN NUMBER OF LONGITUDES.
JMAX - INTEGER NUMBER OF LATITUDES.
WAVED - REAL (2*MX) WAVE DIVERGENCE FIELD IF IDIR>0
WHERE MX=(MAXWV+1)*((IROMB+1)*MAXWV+2)/2
WAVEZ - REAL (2*MX) WAVE VORTICITY FIELD IF IDIR>0
WHERE MX=(MAXWV+1)*((IROMB+1)*MAXWV+2)/2
GRIDU - REAL (IMAX,JMAX) GRID U-WIND (E->W,N->S) IF IDIR<0
GRIDV - REAL (IMAX,JMAX) GRID V-WIND (E->W,N->S) IF IDIR<0
IDIR - INTEGER TRANSFORM FLAG
(IDIR>0 FOR WAVE TO GRID, IDIR<0 FOR GRID TO WAVE)
Output arguments:
WAVED - REAL (2*MX) WAVE DIVERGENCE FIELD IF IDIR<0
WHERE MX=(MAXWV+1)*((IROMB+1)*MAXWV+2)/2
WAVEZ - REAL (2*MX) WAVE VORTICITY FIELD IF IDIR>0
WHERE MX=(MAXWV+1)*((IROMB+1)*MAXWV+2)/2
GRIDU - REAL (IMAX,JMAX) GRID U-WIND (E->W,N->S) IF IDIR>0
GRIDV - REAL (IMAX,JMAX) GRID V-WIND (E->W,N->S) IF IDIR>0
REMARKS:
MINIMUM GRID DIMENSIONS FOR UNALIASED TRANSFORMS TO SPECTRAL:
DIMENSION LINEAR QUADRATIC
----------------------- --------- -------------
IMAX 2*MAXWV+2 3*MAXWV/2*2+2
JMAX (IDRT=4,IROMB=0) 1*MAXWV+1 3*MAXWV/2+1
JMAX (IDRT=4,IROMB=1) 2*MAXWV+1 5*MAXWV/2+1
JMAX (IDRT=0,IROMB=0) 2*MAXWV+3 3*MAXWV/2*2+3
JMAX (IDRT=0,IROMB=1) 4*MAXWV+3 5*MAXWV/2*2+3
JMAX (IDRT=256,IROMB=0) 2*MAXWV+1 3*MAXWV/2*2+1
JMAX (IDRT=256,IROMB=1) 4*MAXWV+1 5*MAXWV/2*2+1
SPTGPM
The SPTGPM routine performs a spherical transform
from spectral coefficients of scalar quantities
to scalar fields on a Mercator grid.
The wave-space can be either Triangular or Rhomboidal.
The wave and grid fields may have general indexing,
but each wave field is in sequential 'IBM order',
i.e. with zonal wavenumber as the slower index.
The Mercator grid is identified by the location
of its first point and by its respective increments.
The transforms are all multiprocessed over sector points.
Transform several fields at a time to improve vectorization.
Subprogram can be called from a multiprocessing environment.
USAGE: CALL SPTGPM(IROMB,MAXWV,KMAX,MI,MJ,
KWSKIP,KGSKIP,NISKIP,NJSKIP,
RLAT1,RLON1,DLAT,DLON,WAVE,GM)
Input arguments:
IROMB - INTEGER SPECTRAL DOMAIN SHAPE
(0 FOR TRIANGULAR, 1 FOR RHOMBOIDAL)
MAXWV - INTEGER SPECTRAL TRUNCATION
KMAX - INTEGER NUMBER OF FIELDS TO TRANSFORM.
MI - INTEGER NUMBER OF POINTS IN THE FASTER ZONAL DIRECTION
MJ - INTEGER NUMBER OF POINTS IN THE SLOWER MERID DIRECTION
KWSKIP - INTEGER SKIP NUMBER BETWEEN WAVE FIELDS
(DEFAULTS TO (MAXWV+1)*((IROMB+1)*MAXWV+2) IF KWSKIP=0)
KGSKIP - INTEGER SKIP NUMBER BETWEEN GRID FIELDS
(DEFAULTS TO MI*MJ IF KGSKIP=0)
NISKIP - INTEGER SKIP NUMBER BETWEEN GRID I-POINTS
(DEFAULTS TO 1 IF NISKIP=0)
NJSKIP - INTEGER SKIP NUMBER BETWEEN GRID J-POINTS
(DEFAULTS TO MI IF NJSKIP=0)
RLAT1 - REAL LATITUDE OF THE FIRST GRID POINT IN DEGREES
RLON1 - REAL LONGITUDE OF THE FIRST GRID POINT IN DEGREES
DLAT - REAL LATITUDE INCREMENT IN DEGREES SUCH THAT
D(PHI)/D(J)=DLAT*COS(PHI) WHERE J IS MERIDIONAL INDEX.
DLAT IS NEGATIVE FOR GRIDS INDEXED SOUTHWARD.
(IN TERMS OF GRID INCREMENT DY VALID AT LATITUDE RLATI,
THE LATITUDE INCREMENT DLAT IS DETERMINED AS
DLAT=DPR*DY/(RERTH*COS(RLATI/DPR))
WHERE DPR=180/PI AND RERTH IS EARTH'S RADIUS)
DLON - REAL LONGITUDE INCREMENT IN DEGREES SUCH THAT
D(LAMBDA)/D(I)=DLON WHERE I IS ZONAL INDEX.
DLON IS NEGATIVE FOR GRIDS INDEXED WESTWARD.
WAVE - REAL (*) WAVE FIELDS
Output arguments:
GM - REAL (*) MERCATOR FIELDS
SPTGPMD
The SPTGPMD routine performs a Spherical transform
from spectral coefficients of scalar fields
to gradient fields on a Mercator grid.
The wave-space can be either Triangular or Rhomboidal.
The wave and grid fields may have general indexing,
but each wave field is in sequential 'IBM order',
i.e. with zonal wavenumber as the slower index.
The Mercator grid is identified by the location
of its first point and by its respective increments.
The transforms are all multiprocessed over sector points.
transform several fields at a time to improve vectorization.
Subprogram can be called from a multiprocessing environment.
USAGE: CALL SPTGPMD(IROMB,MAXWV,KMAX,MI,MJ,
KWSKIP,KGSKIP,NISKIP,NJSKIP,
RLAT1,RLON1,DLAT,DLON,WAVE,XM,YM)
Input arguments:
IROMB - INTEGER SPECTRAL DOMAIN SHAPE
(0 FOR TRIANGULAR, 1 FOR RHOMBOIDAL)
MAXWV - INTEGER SPECTRAL TRUNCATION
KMAX - INTEGER NUMBER OF FIELDS TO TRANSFORM.
MI - INTEGER NUMBER OF POINTS IN THE FASTER ZONAL DIRECTION
MJ - INTEGER NUMBER OF POINTS IN THE SLOWER MERID DIRECTION
KWSKIP - INTEGER SKIP NUMBER BETWEEN WAVE FIELDS
(DEFAULTS TO (MAXWV+1)*((IROMB+1)*MAXWV+2) IF KWSKIP=0)
KGSKIP - INTEGER SKIP NUMBER BETWEEN GRID FIELDS
(DEFAULTS TO MI*MJ IF KGSKIP=0)
NISKIP - INTEGER SKIP NUMBER BETWEEN GRID I-POINTS
(DEFAULTS TO 1 IF NISKIP=0)
NJSKIP - INTEGER SKIP NUMBER BETWEEN GRID J-POINTS
(DEFAULTS TO MI IF NJSKIP=0)
RLAT1 - REAL LATITUDE OF THE FIRST GRID POINT IN DEGREES
RLON1 - REAL LONGITUDE OF THE FIRST GRID POINT IN DEGREES
DLAT - REAL LATITUDE INCREMENT IN DEGREES SUCH THAT
D(PHI)/D(J)=DLAT*COS(PHI) WHERE J IS MERIDIONAL INDEX.
DLAT IS NEGATIVE FOR GRIDS INDEXED SOUTHWARD.
(IN TERMS OF GRID INCREMENT DY VALID AT LATITUDE RLATI,
THE LATITUDE INCREMENT DLAT IS DETERMINED AS
DLAT=DPR*DY/(RERTH*COS(RLATI/DPR))
WHERE DPR=180/PI AND RERTH IS EARTH'S RADIUS)
DLON - REAL LONGITUDE INCREMENT IN DEGREES SUCH THAT
D(LAMBDA)/D(I)=DLON WHERE I IS ZONAL INDEX.
DLON IS NEGATIVE FOR GRIDS INDEXED WESTWARD.
WAVE - REAL (*) WAVE FIELDS
Output arguments:
XM - REAL (*) MERCATOR X-GRADIENTS
YM - REAL (*) MERCATOR Y-GRADIENTS
SPTGPMV
The SPTGPMV routine performs a Spherical transform
from spectral coefficients of divergences and curls
to vector fields on a Mercator grid.
The wave-space can be either Triangular or Rhomboidal.
The wave and grid fields may have general indexing,
but each wave field is in sequential 'IBM order',
i.e. with zonal wavenumber as the slower index.
The Mercator grid is identified by the location
of its first point and by its respective increments.
The transforms are all multiprocessed over sector points.
transform several fields at a time to improve vectorization.
Subprogram can be called from a multiprocessing environment.
USAGE: CALL SPTGPMV(IROMB,MAXWV,KMAX,MI,MJ,
KWSKIP,KGSKIP,NISKIP,NJSKIP,
RLAT1,RLON1,DLAT,DLON,WAVED,WAVEZ,UM,VM)
Input arguments:
IROMB - INTEGER SPECTRAL DOMAIN SHAPE
(0 FOR TRIANGULAR, 1 FOR RHOMBOIDAL)
MAXWV - INTEGER SPECTRAL TRUNCATION
KMAX - INTEGER NUMBER OF FIELDS TO TRANSFORM.
MI - INTEGER NUMBER OF POINTS IN THE FASTER ZONAL DIRECTION
MJ - INTEGER NUMBER OF POINTS IN THE SLOWER MERID DIRECTION
KWSKIP - INTEGER SKIP NUMBER BETWEEN WAVE FIELDS
(DEFAULTS TO (MAXWV+1)*((IROMB+1)*MAXWV+2) IF KWSKIP=0)
KGSKIP - INTEGER SKIP NUMBER BETWEEN GRID FIELDS
(DEFAULTS TO MI*MJ IF KGSKIP=0)
NISKIP - INTEGER SKIP NUMBER BETWEEN GRID I-POINTS
(DEFAULTS TO 1 IF NISKIP=0)
NJSKIP - INTEGER SKIP NUMBER BETWEEN GRID J-POINTS
(DEFAULTS TO MI IF NJSKIP=0)
RLAT1 - REAL LATITUDE OF THE FIRST GRID POINT IN DEGREES
RLON1 - REAL LONGITUDE OF THE FIRST GRID POINT IN DEGREES
DLAT - REAL LATITUDE INCREMENT IN DEGREES SUCH THAT
D(PHI)/D(J)=DLAT*COS(PHI) WHERE J IS MERIDIONAL INDEX.
DLAT IS NEGATIVE FOR GRIDS INDEXED SOUTHWARD.
(IN TERMS OF GRID INCREMENT DY VALID AT LATITUDE RLATI,
THE LATITUDE INCREMENT DLAT IS DETERMINED AS
DLAT=DPR*DY/(RERTH*COS(RLATI/DPR))
WHERE DPR=180/PI AND RERTH IS EARTH'S RADIUS)
DLON - REAL LONGITUDE INCREMENT IN DEGREES SUCH THAT
D(LAMBDA)/D(I)=DLON WHERE I IS ZONAL INDEX.
DLON IS NEGATIVE FOR GRIDS INDEXED WESTWARD.
WAVED - REAL (*) WAVE DIVERGENCE FIELDS
WAVEZ - REAL (*) WAVE VORTICITY FIELDS
Output arguments:
UM - REAL (*) MERCATOR U-WINDS
VM - REAL (*) MERCATOR V-WINDS
SPTGPS
The SPTGPS routine performs a Spherical transform
from spectral coefficients of scalar quantities
to scalar fields on a pair of Polar Stereographic grids.
The wave-space can be either Triangular or Rhomboidal.
The wave and grid fields may have general indexing,
But each wave field is in sequential 'IBM order',
i.e. with zonal wavenumber as the slower index.
The two square Polar Stereographic grids are centered
on the respective poles, with the orientation longitude
of the Southern Hemisphere grid 180 degrees opposite
that of the Northern Hemisphere grid.
The transform is made efficient \ 4 | 5 /
by combining points in eight sectors \ | /
of each Polar Stereographic grid, 3 \ | / 6
numbered as in the diagram at right. \|/
The pole and the sector boundaries ----+----
are treated specially in the code. /|\
unfortunately, this approach induces 2 / | \ 7
some hairy indexing and code loquacity, / | \
For which the developer apologizes. / 1 | 8 \
The transforms are all multiprocessed over sector points.
transform several fields at a time to improve vectorization.
Subprogram can be called from a multiprocessing environment.
USAGE: CALL SPTGPS(IROMB,MAXWV,KMAX,NPS,
KWSKIP,KGSKIP,NISKIP,NJSKIP,
TRUE,XMESH,ORIENT,WAVE,GN,GS)
Input arguments:
IROMB - INTEGER SPECTRAL DOMAIN SHAPE
(0 FOR TRIANGULAR, 1 FOR RHOMBOIDAL)
MAXWV - INTEGER SPECTRAL TRUNCATION
KMAX - INTEGER NUMBER OF FIELDS TO TRANSFORM.
NPS - INTEGER ODD ORDER OF THE POLAR STEREOGRAPHIC GRIDS
KWSKIP - INTEGER SKIP NUMBER BETWEEN WAVE FIELDS
(DEFAULTS TO (MAXWV+1)*((IROMB+1)*MAXWV+2) IF KWSKIP=0)
KGSKIP - INTEGER SKIP NUMBER BETWEEN GRID FIELDS
(DEFAULTS TO NPS*NPS IF KGSKIP=0)
NISKIP - INTEGER SKIP NUMBER BETWEEN GRID I-POINTS
(DEFAULTS TO 1 IF NISKIP=0)
NJSKIP - INTEGER SKIP NUMBER BETWEEN GRID J-POINTS
(DEFAULTS TO NPS IF NJSKIP=0)
TRUE - REAL LATITUDE AT WHICH PS GRID IS TRUE (USUALLY 60.)
XMESH - REAL GRID LENGTH AT TRUE LATITUDE (M)
ORIENT - REAL LONGITUDE AT BOTTOM OF NORTHERN PS GRID
(SOUTHERN PS GRID WILL HAVE OPPOSITE ORIENTATION.)
WAVE - REAL (*) WAVE FIELDS
Output arguments:
GN - REAL (*) NORTHERN POLAR STEREOGRAPHIC FIELDS
GS - REAL (*) SOUTHERN POLAR STEREOGRAPHIC FIELDS
SPTGPSD
The SPTGPSD routine performs a Spherical transform
from spectral coefficients of scalar fields
to gradient fields on a pair of Polar Stereographic grids.
The wave-space can be either Triangular or Rhomboidal.
The wave and grid fields may have general indexing,
but each wave field is in sequential 'IBM order',
i.e. with zonal wavenumber as the slower index.
The two square Polar Stereographic grids are centered
on the respective poles, with the orientation longitude
of the Southern Hemisphere grid 180 degrees opposite
that of the Northern Hemisphere grid.
The vectors are automatically rotated to be resolved
relative to the respective Polar Stereographic grids.
The transform is made efficient \ 4 | 5 /
by combining points in eight sectors \ | /
of each Polar Stereographic grid, 3 \ | / 6
numbered as in the diagram at right. \|/
The pole and the sector boundaries ----+----
are treated specially in the code. /|\
unfortunately, this approach induces 2 / | \ 7
some hairy indexing and code loquacity, / | \
For which the developer apologizes. / 1 | 8 \
The transforms are all multiprocessed over sector points.
transform several fields at a time to improve vectorization.
Subprogram can be called from a multiprocessing environment.
USAGE: CALL SPTGPSD(IROMB,MAXWV,KMAX,NPS,
KWSKIP,KGSKIP,NISKIP,NJSKIP,
TRUE,XMESH,ORIENT,WAVE,XP,YP)
Input arguments:
IROMB - INTEGER SPECTRAL DOMAIN SHAPE
(0 FOR TRIANGULAR, 1 FOR RHOMBOIDAL)
MAXWV - INTEGER SPECTRAL TRUNCATION
KMAX - INTEGER NUMBER OF FIELDS TO TRANSFORM.
NPS - INTEGER ODD ORDER OF THE POLAR STEREOGRAPHIC GRIDS
KWSKIP - INTEGER SKIP NUMBER BETWEEN WAVE FIELDS
(DEFAULTS TO (MAXWV+1)*((IROMB+1)*MAXWV+2) IF KWSKIP=0)
KGSKIP - INTEGER SKIP NUMBER BETWEEN GRID FIELDS
(DEFAULTS TO NPS*NPS IF KGSKIP=0)
NISKIP - INTEGER SKIP NUMBER BETWEEN GRID I-POINTS
(DEFAULTS TO 1 IF NISKIP=0)
NJSKIP - INTEGER SKIP NUMBER BETWEEN GRID J-POINTS
(DEFAULTS TO NPS IF NJSKIP=0)
TRUE - REAL LATITUDE AT WHICH PS GRID IS TRUE (USUALLY 60.)
XMESH - REAL GRID LENGTH AT TRUE LATITUDE (M)
ORIENT - REAL LONGITUDE AT BOTTOM OF NORTHERN PS GRID
(SOUTHERN PS GRID WILL HAVE OPPOSITE ORIENTATION.)
WAVE - REAL (*) WAVE FIELDS
Output arguments:
XN - REAL (*) NORTHERN POLAR STEREOGRAPHIC X-GRADIENTS
YN - REAL (*) NORTHERN POLAR STEREOGRAPHIC Y-GRADIENTS
XS - REAL (*) SOUTHERN POLAR STEREOGRAPHIC X-GRADIENTS
YS - REAL (*) SOUTHERN POLAR STEREOGRAPHIC Y-GRADIENTS
SPTGPSV
The SPTGPSV routine performs a Spherical transform
from spectral coefficients of divergences and curls
to vector fields on a pair of Polar Stereographic grids.
The wave-space can be either Triangular or Rhomboidal.
The wave and grid fields may have general indexing,
but each wave field is in sequential 'IBM order',
i.e. with zonal wavenumber as the slower index.
The two square Polar Stereographic grids are centered
on the respective poles, with the orientation longitude
of the Southern Hemisphere grid 180 degrees opposite
that of the Northern Hemisphere grid.
The vectors are automatically rotated to be resolved
relative to the respective Polar Stereographic grids.
The transform is made efficient \ 4 | 5 /
by combining points in eight sectors \ | /
of each Polar Stereographic grid, 3 \ | / 6
numbered as in the diagram at right. \|/
The pole and the sector boundaries ----+----
are treated specially in the code. /|\
unfortunately, this approach induces 2 / | \ 7
some hairy indexing and code loquacity, / | \
For which the developer apologizes. / 1 | 8 \
The transforms are all multiprocessed over sector points.
transform several fields at a time to improve vectorization.
Subprogram can be called from a multiprocessing environment.
USAGE: CALL SPTGPSV(IROMB,MAXWV,KMAX,NPS,
KWSKIP,KGSKIP,NISKIP,NJSKIP,
TRUE,XMESH,ORIENT,WAVED,WAVEZ,UN,VN,US,VS)
Input arguments:
IROMB - INTEGER SPECTRAL DOMAIN SHAPE
(0 FOR TRIANGULAR, 1 FOR RHOMBOIDAL)
MAXWV - INTEGER SPECTRAL TRUNCATION
KMAX - INTEGER NUMBER OF FIELDS TO TRANSFORM.
NPS - INTEGER ODD ORDER OF THE POLAR STEREOGRAPHIC GRIDS
KWSKIP - INTEGER SKIP NUMBER BETWEEN WAVE FIELDS
(DEFAULTS TO (MAXWV+1)*((IROMB+1)*MAXWV+2) IF KWSKIP=0)
KGSKIP - INTEGER SKIP NUMBER BETWEEN GRID FIELDS
(DEFAULTS TO NPS*NPS IF KGSKIP=0)
NISKIP - INTEGER SKIP NUMBER BETWEEN GRID I-POINTS
(DEFAULTS TO 1 IF NISKIP=0)
NJSKIP - INTEGER SKIP NUMBER BETWEEN GRID J-POINTS
(DEFAULTS TO NPS IF NJSKIP=0)
TRUE - REAL LATITUDE AT WHICH PS GRID IS TRUE (USUALLY 60.)
XMESH - REAL GRID LENGTH AT TRUE LATITUDE (M)
ORIENT - REAL LONGITUDE AT BOTTOM OF NORTHERN PS GRID
(SOUTHERN PS GRID WILL HAVE OPPOSITE ORIENTATION.)
WAVED - REAL (*) WAVE DIVERGENCE FIELDS
WAVEZ - REAL (*) WAVE VORTICITY FIELDS
Output arguments:
UN - REAL (*) NORTHERN POLAR STEREOGRAPHIC U-WINDS
VN - REAL (*) NORTHERN POLAR STEREOGRAPHIC V-WINDS
US - REAL (*) SOUTHERN POLAR STEREOGRAPHIC U-WINDS
VS - REAL (*) SOUTHERN POLAR STEREOGRAPHIC V-WINDS
SPTGPT
The SPTGPT routine performs a spherical transform
from spectral coefficients of scalar quantities
to specified sets of station points on the globe.
The wave-space can be either Triangular or Rhomboidal.
The wave and point fields may have general indexing,
but each wave field is in sequential 'IBM order',
i.e. with zonal wavenumber as the slower index.
The transforms are all multiprocessed over stations.
transform several fields at a time to improve vectorization.
Subprogram can be called from a multiprocessing environment.
USAGE: CALL SPTGPT(IROMB,MAXWV,KMAX,NMAX,
KWSKIP,KGSKIP,NRSKIP,NGSKIP,
RLAT,RLON,WAVE,GP)
Input arguments:
IROMB - INTEGER SPECTRAL DOMAIN SHAPE
(0 FOR TRIANGULAR, 1 FOR RHOMBOIDAL)
MAXWV - INTEGER SPECTRAL TRUNCATION
KMAX - INTEGER NUMBER OF FIELDS TO TRANSFORM.
NMAX - INTEGER NUMBER OF STATION POINTS TO RETURN
KWSKIP - INTEGER SKIP NUMBER BETWEEN WAVE FIELDS
(DEFAULTS TO (MAXWV+1)*((IROMB+1)*MAXWV+2) IF KWSKIP=0)
KGSKIP - INTEGER SKIP NUMBER BETWEEN STATION POINT SETS
(DEFAULTS TO NMAX IF KGSKIP=0)
NRSKIP - INTEGER SKIP NUMBER BETWEEN STATION LATS AND LONS
(DEFAULTS TO 1 IF NRSKIP=0)
NGSKIP - INTEGER SKIP NUMBER BETWEEN STATION POINTS
(DEFAULTS TO 1 IF NGSKIP=0)
RLAT - REAL (*) STATION LATITUDES IN DEGREES
RLON - REAL (*) STATION LONGITUDES IN DEGREES
WAVE - REAL (*) WAVE FIELDS
Output arguments:
GP - REAL (*) STATION POINT SETS
SPTGPTD
The SPTGPTD routine performs a spherical transform
from spectral coefficients of scalar fields
to specified sets of station point gradients on the globe.
The wave-space can be either Triangular or Rhomboidal.
The wave and point fields may have general indexing,
but each wave field is in sequential 'IBM order',
i.e. with zonal wavenumber as the slower index.
The transforms are all multiprocessed over stations.
transform several fields at a time to improve vectorization.
Subprogram can be called from a multiprocessing environment.
USAGE: CALL SPTGPTD(IROMB,MAXWV,KMAX,NMAX,
KWSKIP,KGSKIP,NRSKIP,NGSKIP,
RLAT,RLON,WAVE,XP,YP)
Input arguments:
IROMB - INTEGER SPECTRAL DOMAIN SHAPE
(0 FOR TRIANGULAR, 1 FOR RHOMBOIDAL)
MAXWV - INTEGER SPECTRAL TRUNCATION
KMAX - INTEGER NUMBER OF FIELDS TO TRANSFORM.
NMAX - INTEGER NUMBER OF STATION POINTS TO RETURN
KWSKIP - INTEGER SKIP NUMBER BETWEEN WAVE FIELDS
(DEFAULTS TO (MAXWV+1)*((IROMB+1)*MAXWV+2) IF KWSKIP=0)
KGSKIP - INTEGER SKIP NUMBER BETWEEN STATION POINT SETS
(DEFAULTS TO NMAX IF KGSKIP=0)
NRSKIP - INTEGER SKIP NUMBER BETWEEN STATION LATS AND LONS
(DEFAULTS TO 1 IF NRSKIP=0)
NGSKIP - INTEGER SKIP NUMBER BETWEEN STATION POINTS
(DEFAULTS TO 1 IF NGSKIP=0)
RLAT - REAL (*) STATION LATITUDES IN DEGREES
RLON - REAL (*) STATION LONGITUDES IN DEGREES
WAVE - REAL (*) WAVE FIELDS
Output arguments:
XP - REAL (*) STATION POINT X-GRADIENT SETS
YP - REAL (*) STATION POINT Y-GRADIENT SETS
SPTGPTSD
The SPTGPTSD routine performs a Spherical transform
From Spectral coefficients of scalar quantities
to specified sets of station point values
and their gradients on the globe.
The wave-space can be either Triangular or Rhomboidal.
The wave and point fields may have general indexing,
but each wave field is in sequential 'IBM order',
i.e. with zonal wavenumber as the slower index.
The transforms are all multiprocessed over stations.
transform several fields at a time to improve vectorization.
Subprogram can be called from a multiprocessing environment.
USAGE: CALL SPTGPTSD(IROMB,MAXWV,KMAX,NMAX,
KWSKIP,KGSKIP,NRSKIP,NGSKIP,
RLAT,RLON,WAVE,GP,XP,YP)
Input arguments:
IROMB - INTEGER SPECTRAL DOMAIN SHAPE
(0 FOR TRIANGULAR, 1 FOR RHOMBOIDAL)
MAXWV - INTEGER SPECTRAL TRUNCATION
KMAX - INTEGER NUMBER OF FIELDS TO TRANSFORM.
NMAX - INTEGER NUMBER OF STATION POINTS TO RETURN
KWSKIP - INTEGER SKIP NUMBER BETWEEN WAVE FIELDS
(DEFAULTS TO (MAXWV+1)*((IROMB+1)*MAXWV+2) IF KWSKIP=0)
KGSKIP - INTEGER SKIP NUMBER BETWEEN STATION POINT SETS
(DEFAULTS TO NMAX IF KGSKIP=0)
NRSKIP - INTEGER SKIP NUMBER BETWEEN STATION LATS AND LONS
(DEFAULTS TO 1 IF NRSKIP=0)
NGSKIP - INTEGER SKIP NUMBER BETWEEN STATION POINTS
(DEFAULTS TO 1 IF NGSKIP=0)
RLAT - REAL (*) STATION LATITUDES IN DEGREES
RLON - REAL (*) STATION LONGITUDES IN DEGREES
WAVE - REAL (*) WAVE FIELDS
Output arguments:
GP - REAL (*) STATION POINT SETS
XP - REAL (*) STATION POINT X-GRADIENT SETS
YP - REAL (*) STATION POINT Y-GRADIENT SETS
SPTGPTV
The SPTGPTV routine performs a spherical transform
from spectral coefficients of divergences and curls
to specified sets of station point vectors on the globe.
The wave-space can be either Triangular or Rhomboidal.
The wave and point fields may have general indexing,
but each wave field is in sequential 'IBM order',
i.e. with zonal wavenumber as the slower index.
The transforms are all multiprocessed over stations.
transform several fields at a time to improve vectorization.
Subprogram can be called from a multiprocessing environment.
USAGE: CALL SPTGPTV(IROMB,MAXWV,KMAX,NMAX,
KWSKIP,KGSKIP,NRSKIP,NGSKIP,
RLAT,RLON,WAVED,WAVEZ,UP,VP)
Input arguments:
IROMB - INTEGER SPECTRAL DOMAIN SHAPE
(0 FOR TRIANGULAR, 1 FOR RHOMBOIDAL)
MAXWV - INTEGER SPECTRAL TRUNCATION
KMAX - INTEGER NUMBER OF FIELDS TO TRANSFORM.
NMAX - INTEGER NUMBER OF STATION POINTS TO RETURN
KWSKIP - INTEGER SKIP NUMBER BETWEEN WAVE FIELDS
(DEFAULTS TO (MAXWV+1)*((IROMB+1)*MAXWV+2) IF KWSKIP=0)
KGSKIP - INTEGER SKIP NUMBER BETWEEN STATION POINT SETS
(DEFAULTS TO NMAX IF KGSKIP=0)
NRSKIP - INTEGER SKIP NUMBER BETWEEN STATION LATS AND LONS
(DEFAULTS TO 1 IF NRSKIP=0)
NGSKIP - INTEGER SKIP NUMBER BETWEEN STATION POINTS
(DEFAULTS TO 1 IF NGSKIP=0)
RLAT - REAL (*) STATION LATITUDES IN DEGREES
RLON - REAL (*) STATION LONGITUDES IN DEGREES
WAVED - REAL (*) WAVE DIVERGENCE FIELDS
WAVEZ - REAL (*) WAVE VORTICITY FIELDS
Output arguments:
UP - REAL (*) STATION POINT U-WIND SETS
VP - REAL (*) STATION POINT V-WIND SETS
SPTGPTVD
The SPTGPTVD routine performs a Spherical Transform
from Spectral coefficients of divergences and curls
to specified sets of station point vectors and their
gradients on the globe.
DP=(D(UP)/DLON+D(VP*CLAT)/DLAT)/(R*CLAT)
ZP=(D(VP)/DLON-D(UP*CLAT)/DLAT)/(R*CLAT)
UXP=D(UP*CLAT)/DLON/(R*CLAT)
VXP=D(VP*CLAT)/DLON/(R*CLAT)
UYP=D(UP*CLAT)/DLAT/R
VYP=D(VP*CLAT)/DLAT/R
The wave-space can be either Triangular or Rhomboidal.
The wave and point fields may have general indexing,
but each wave field is in sequential 'IBM order',
i.e. with zonal wavenumber as the slower index.
The Transforms are all multiprocessed over stations.
Transform several fields at a time to improve vectorization.
Subprogram can be called from a multiprocessing environment.
USAGE: CALL SPTGPTVD(IROMB,MAXWV,KMAX,NMAX,
KWSKIP,KGSKIP,NRSKIP,NGSKIP,
RLAT,RLON,WAVED,WAVEZ,
DP,ZP,UP,VP,UXP,VXP,UYP,VYP)
Input arguments:
IROMB - INTEGER SPECTRAL DOMAIN SHAPE
(0 FOR TRIANGULAR, 1 FOR RHOMBOIDAL)
MAXWV - INTEGER SPECTRAL TRUNCATION
KMAX - INTEGER NUMBER OF FIELDS TO TRANSFORM.
NMAX - INTEGER NUMBER OF STATION POINTS TO RETURN
KWSKIP - INTEGER SKIP NUMBER BETWEEN WAVE FIELDS
(DEFAULTS TO (MAXWV+1)*((IROMB+1)*MAXWV+2) IF KWSKIP=0)
KGSKIP - INTEGER SKIP NUMBER BETWEEN STATION POINT SETS
(DEFAULTS TO NMAX IF KGSKIP=0)
NRSKIP - INTEGER SKIP NUMBER BETWEEN STATION LATS AND LONS
(DEFAULTS TO 1 IF NRSKIP=0)
NGSKIP - INTEGER SKIP NUMBER BETWEEN STATION POINTS
(DEFAULTS TO 1 IF NGSKIP=0)
RLAT - REAL (*) STATION LATITUDES IN DEGREES
RLON - REAL (*) STATION LONGITUDES IN DEGREES
WAVED - REAL (*) WAVE DIVERGENCE FIELDS
WAVEZ - REAL (*) WAVE VORTICITY FIELDS
Output arguments:
DP - REAL (*) STATION POINT DIVERGENCE SETS
ZP - REAL (*) STATION POINT VORTICITY SETS
UP - REAL (*) STATION POINT U-WIND SETS
VP - REAL (*) STATION POINT V-WIND SETS
UXP - REAL (*) STATION POINT U-WIND X-GRADIENT SETS
VXP - REAL (*) STATION POINT V-WIND X-GRADIENT SETS
UYP - REAL (*) STATION POINT U-WIND Y-GRADIENT SETS
VYP - REAL (*) STATION POINT V-WIND Y-GRADIENT SETS
SPTRAN
The SPTRAN routine performs a spherical transform
between spectral coefficients of scalar quantities
and fields on a global cylindrical grid.
The wave-space can be either Triangular or Rhomboidal.
The grid-space can be either an equally-spaced grid
(with or without pole points) or a Gaussian grid.
The wave and grid fields may have general indexing,
but each wave field is in sequential 'IBM order',
i.e. with zonal wavenumber as the slower index.
Transforms are done in latitude pairs for efficiency;
Thus grid arrays for each hemisphere must be passed.
If so requested, just a subset of the latitude pairs
may be transformed in each invocation of the subprogram.
The transforms are all multiprocessed over latitude except
The transform from Fourier to spectral is multiprocessed
over zonal wavenumber to ensure reproducibility.
Transform several fields at a time to improve vectorization.
Subprogram can be called from a multiprocessing environment.
USAGE: CALL SPTRAN(IROMB,MAXWV,IDRT,IMAX,JMAX,KMAX,
IPRIME,ISKIP,JNSKIP,JSSKIP,KWSKIP,KGSKIP,
JBEG,JEND,JCPU,
WAVE,GRIDN,GRIDS,IDIR)
Input arguments:
IROMB - INTEGER SPECTRAL DOMAIN SHAPE
(0 FOR TRIANGULAR, 1 FOR RHOMBOIDAL)
MAXWV - INTEGER SPECTRAL TRUNCATION
IDRT - INTEGER GRID IDENTIFIER
(IDRT=4 FOR GAUSSIAN GRID,
IDRT=0 FOR EQUALLY-SPACED GRID INCLUDING POLES,
IDRT=256 FOR EQUALLY-SPACED GRID EXCLUDING POLES)
IMAX - INTEGER EVEN NUMBER OF LONGITUDES.
JMAX - INTEGER NUMBER OF LATITUDES.
KMAX - INTEGER NUMBER OF FIELDS TO TRANSFORM.
IPRIME - INTEGER LONGITUDE INDEX FOR THE PRIME MERIDIAN.
(DEFAULTS TO 1 IF IPRIME=0)
ISKIP - INTEGER SKIP NUMBER BETWEEN LONGITUDES
(DEFAULTS TO 1 IF ISKIP=0)
JNSKIP - INTEGER SKIP NUMBER BETWEEN N.H. LATITUDES FROM NORTH
(DEFAULTS TO IMAX IF JNSKIP=0)
JSSKIP - INTEGER SKIP NUMBER BETWEEN S.H. LATITUDES FROM SOUTH
(DEFAULTS TO -IMAX IF JSSKIP=0)
KWSKIP - INTEGER SKIP NUMBER BETWEEN WAVE FIELDS
(DEFAULTS TO (MAXWV+1)*((IROMB+1)*MAXWV+2) IF KWSKIP=0)
KGSKIP - INTEGER SKIP NUMBER BETWEEN GRID FIELDS
(DEFAULTS TO IMAX*JMAX IF KGSKIP=0)
JBEG - INTEGER LATITUDE INDEX (FROM POLE) TO BEGIN TRANSFORM
(DEFAULTS TO 1 IF JBEG=0)
(IF JBEG=0 AND IDIR<0, WAVE IS ZEROED BEFORE TRANSFORM)
JEND - INTEGER LATITUDE INDEX (FROM POLE) TO END TRANSFORM
(DEFAULTS TO (JMAX+1)/2 IF JEND=0)
JCPU - INTEGER NUMBER OF CPUS OVER WHICH TO MULTIPROCESS
WAVE - REAL (*) WAVE FIELDS IF IDIR>0
GRIDN - REAL (*) N.H. GRID FIELDS (STARTING AT JBEG) IF IDIR<0
GRIDS - REAL (*) S.H. GRID FIELDS (STARTING AT JBEG) IF IDIR<0
IDIR - INTEGER TRANSFORM FLAG
(IDIR>0 FOR WAVE TO GRID, IDIR<0 FOR GRID TO WAVE)
Output arguments:
WAVE - REAL (*) WAVE FIELDS IF IDIR<0
GRIDN - REAL (*) N.H. GRID FIELDS (STARTING AT JBEG) IF IDIR>0
GRIDS - REAL (*) S.H. GRID FIELDS (STARTING AT JBEG) IF IDIR>0
SPTRAND
The SPTRAND routine performs a spherical transform
between spectral coefficients of scalar fields
and their means and gradients on a global cylindrical grid.
The wave-space can be either Triangular or Rhomboidal.
The grid-space can be either an equally-spaced grid
(with or without pole points) or a Gaussian grid.
The wave and grid fields may have general indexing,
but each wave field is in sequential 'IBM order',
i.e. with zonal wavenumber as the slower index.
Transforms are done in latitude pairs for efficiency;
thus grid arrays for each hemisphere must be passed.
If so requested, just a subset of the latitude pairs
may be transformed in each invocation of the subprogram.
The transforms are all multiprocessed over latitude except
The transform from Fourier to spectral is multiprocessed
over zonal wavenumber to ensure reproducibility.
Transform several fields at a time to improve vectorization.
Subprogram can be called from a multiprocessing environment.
USAGE: CALL SPTRAND(IROMB,MAXWV,IDRT,IMAX,JMAX,KMAX,
IPRIME,ISKIP,JNSKIP,JSSKIP,KWSKIP,KGSKIP,
JBEG,JEND,JCPU,
WAVE,GRIDMN,GRIDXN,GRIDXS,GRIDYN,GRIDYS,IDIR)
Input arguments:
IROMB - INTEGER SPECTRAL DOMAIN SHAPE
(0 FOR TRIANGULAR, 1 FOR RHOMBOIDAL)
MAXWV - INTEGER SPECTRAL TRUNCATION
IDRT - INTEGER GRID IDENTIFIER
(IDRT=4 FOR GAUSSIAN GRID,
IDRT=0 FOR EQUALLY-SPACED GRID INCLUDING POLES,
IDRT=256 FOR EQUALLY-SPACED GRID EXCLUDING POLES)
IMAX - INTEGER EVEN NUMBER OF LONGITUDES.
JMAX - INTEGER NUMBER OF LATITUDES.
KMAX - INTEGER NUMBER OF FIELDS TO TRANSFORM.
IPRIME - INTEGER LONGITUDE INDEX FOR THE PRIME MERIDIAN.
(DEFAULTS TO 1 IF IPRIME=0)
ISKIP - INTEGER SKIP NUMBER BETWEEN LONGITUDES
(DEFAULTS TO 1 IF ISKIP=0)
JNSKIP - INTEGER SKIP NUMBER BETWEEN N.H. LATITUDES FROM NORTH
(DEFAULTS TO IMAX IF JNSKIP=0)
JSSKIP - INTEGER SKIP NUMBER BETWEEN S.H. LATITUDES FROM SOUTH
(DEFAULTS TO -IMAX IF JSSKIP=0)
KWSKIP - INTEGER SKIP NUMBER BETWEEN WAVE FIELDS
(DEFAULTS TO (MAXWV+1)*((IROMB+1)*MAXWV+2) IF KWSKIP=0)
KGSKIP - INTEGER SKIP NUMBER BETWEEN GRID FIELDS
(DEFAULTS TO IMAX*JMAX IF KGSKIP=0)
JBEG - INTEGER LATITUDE INDEX (FROM POLE) TO BEGIN TRANSFORM
(DEFAULTS TO 1 IF JBEG=0)
(IF JBEG=0 AND IDIR<0, WAVE IS ZEROED BEFORE TRANSFORM)
JEND - INTEGER LATITUDE INDEX (FROM POLE) TO END TRANSFORM
(DEFAULTS TO (JMAX+1)/2 IF JEND=0)
JCPU - INTEGER NUMBER OF CPUS OVER WHICH TO MULTIPROCESS
WAVE - REAL (*) WAVE FIELDS IF IDIR>0
GRIDMN - REAL (KMAX) GLOBAL MEANS IF IDIR<0
GRIDXN - REAL (*) N.H. X-GRADIENTS (STARTING AT JBEG) IF IDIR<0
GRIDXS - REAL (*) S.H. X-GRADIENTS (STARTING AT JBEG) IF IDIR<0
GRIDYN - REAL (*) N.H. Y-GRADIENTS (STARTING AT JBEG) IF IDIR<0
GRIDYS - REAL (*) S.H. Y-GRADIENTS (STARTING AT JBEG) IF IDIR<0
IDIR - INTEGER TRANSFORM FLAG
(IDIR>0 FOR WAVE TO GRID, IDIR<0 FOR GRID TO WAVE)
Output arguments:
WAVE - REAL (*) WAVE FIELDS IF IDIR<0
GRIDMN - REAL (KMAX) GLOBAL MEANS IF IDIR>0
GRIDXN - REAL (*) N.H. X-GRADIENTS (STARTING AT JBEG) IF IDIR>0
GRIDXS - REAL (*) S.H. X-GRADIENTS (STARTING AT JBEG) IF IDIR>0
[GRIDX=(D(WAVE)/DLAM)/(CLAT*RERTH)]
GRIDYN - REAL (*) N.H. Y-GRADIENTS (STARTING AT JBEG) IF IDIR>0
GRIDYS - REAL (*) S.H. Y-GRADIENTS (STARTING AT JBEG) IF IDIR>0
[GRIDY=(D(WAVE)/DPHI)/RERTH]
REMARKS:
MINIMUM GRID DIMENSIONS FOR UNALIASED TRANSFORMS TO SPECTRAL:
DIMENSION LINEAR QUADRATIC
----------------------- --------- -------------
IMAX 2*MAXWV+2 3*MAXWV/2*2+2
JMAX (IDRT=4,IROMB=0) 1*MAXWV+1 3*MAXWV/2+1
JMAX (IDRT=4,IROMB=1) 2*MAXWV+1 5*MAXWV/2+1
JMAX (IDRT=0,IROMB=0) 2*MAXWV+3 3*MAXWV/2*2+3
JMAX (IDRT=0,IROMB=1) 4*MAXWV+3 5*MAXWV/2*2+3
JMAX (IDRT=256,IROMB=0) 2*MAXWV+1 3*MAXWV/2*2+1
JMAX (IDRT=256,IROMB=1) 4*MAXWV+1 5*MAXWV/2*2+1
SPTRANF
The SPTRANF routine performs a spherical transform
between spectral coefficients of scalar quantities
and fields on a global cylindrical grid.
The wave-space can be either Triangular or Rhomboidal.
The grid-space can be either an equally-spaced grid
(with or without pole points) or a Gaussian grid.
The wave and grid fields may have general indexing,
but each wave field is in sequential 'IBM order',
i.e. with zonal wavenumber as the slower index.
Transforms are done in latitude pairs for efficiency;
Thus grid arrays for each hemisphere must be passed.
If so requested, just a subset of the latitude pairs
may be transformed in each invocation of the subprogram.
The transforms are all multiprocessed over latitude except
The transform from Fourier to spectral is multiprocessed
over zonal wavenumber to ensure reproducibility.
Transform several fields at a time to improve vectorization.
Subprogram can be called from a multiprocessing environment.
USAGE: CALL SPTRANF(IROMB,MAXWV,IDRT,IMAX,JMAX,KMAX,
IP,IS,JN,JS,KW,KG,JB,JE,JC,
WAVE,GRIDN,GRIDS,IDIR)
Input arguments:
IROMB - INTEGER SPECTRAL DOMAIN SHAPE
(0 FOR TRIANGULAR, 1 FOR RHOMBOIDAL)
MAXWV - INTEGER SPECTRAL TRUNCATION
IDRT - INTEGER GRID IDENTIFIER
(IDRT=4 FOR GAUSSIAN GRID,
IDRT=0 FOR EQUALLY-SPACED GRID INCLUDING POLES,
IDRT=256 FOR EQUALLY-SPACED GRID EXCLUDING POLES)
IMAX - INTEGER EVEN NUMBER OF LONGITUDES.
JMAX - INTEGER NUMBER OF LATITUDES.
KMAX - INTEGER NUMBER OF FIELDS TO TRANSFORM.
IP - INTEGER LONGITUDE INDEX FOR THE PRIME MERIDIAN
IS - INTEGER SKIP NUMBER BETWEEN LONGITUDES
JN - INTEGER SKIP NUMBER BETWEEN N.H. LATITUDES FROM NORTH
JS - INTEGER SKIP NUMBER BETWEEN S.H. LATITUDES FROM SOUTH
KW - INTEGER SKIP NUMBER BETWEEN WAVE FIELDS
KG - INTEGER SKIP NUMBER BETWEEN GRID FIELDS
JB - INTEGER LATITUDE INDEX (FROM POLE) TO BEGIN TRANSFORM
JE - INTEGER LATITUDE INDEX (FROM POLE) TO END TRANSFORM
JC - INTEGER NUMBER OF CPUS OVER WHICH TO MULTIPROCESS
WAVE - REAL (*) WAVE FIELDS IF IDIR>0
GRIDN - REAL (*) N.H. GRID FIELDS (STARTING AT JB) IF IDIR<0
GRIDS - REAL (*) S.H. GRID FIELDS (STARTING AT JB) IF IDIR<0
IDIR - INTEGER TRANSFORM FLAG
(IDIR>0 FOR WAVE TO GRID, IDIR<0 FOR GRID TO WAVE)
Output arguments:
WAVE - REAL (*) WAVE FIELDS IF IDIR<0
GRIDN - REAL (*) N.H. GRID FIELDS (STARTING AT JB) IF IDIR>0
GRIDS - REAL (*) S.H. GRID FIELDS (STARTING AT JB) IF IDIR>0
SPTRANF0
The SPTRANF0 routine performs an initialization for
Subprogram SPTRANF. Use this subprogram outside
the SPTRANF family context at your own risk.
USAGE: CALL SPTRANF0(IROMB,MAXWV,IDRT,IMAX,JMAX,JB,JE,
EPS,EPSTOP,ENN1,ELONN1,EON,EONTOP,
AFFT,CLAT,SLAT,WLAT,PLN,PLNTOP)
Input arguments:
IROMB - INTEGER SPECTRAL DOMAIN SHAPE
(0 FOR TRIANGULAR, 1 FOR RHOMBOIDAL)
MAXWV - INTEGER SPECTRAL TRUNCATION
IDRT - INTEGER GRID IDENTIFIER
(IDRT=4 FOR GAUSSIAN GRID,
IDRT=0 FOR EQUALLY-SPACED GRID INCLUDING POLES,
IDRT=256 FOR EQUALLY-SPACED GRID EXCLUDING POLES)
IMAX - INTEGER EVEN NUMBER OF LONGITUDES
JMAX - INTEGER NUMBER OF LATITUDES
JB - INTEGER LATITUDE INDEX (FROM POLE) TO BEGIN TRANSFORM
JE - INTEGER LATITUDE INDEX (FROM POLE) TO END TRANSFORM
Output arguments:
EPS - REAL ((MAXWV+1)*((IROMB+1)*MAXWV+2)/2)
EPSTOP - REAL (MAXWV+1)
ENN1 - REAL ((MAXWV+1)*((IROMB+1)*MAXWV+2)/2)
ELONN1 - REAL ((MAXWV+1)*((IROMB+1)*MAXWV+2)/2)
EON - REAL ((MAXWV+1)*((IROMB+1)*MAXWV+2)/2)
EONTOP - REAL (MAXWV+1)
AFFT - REAL(8) (50000+4*IMAX) AUXILIARY ARRAY IF IDIR=0
CLAT - REAL (JB:JE) COSINES OF LATITUDE
SLAT - REAL (JB:JE) SINES OF LATITUDE
WLAT - REAL (JB:JE) GAUSSIAN WEIGHTS
PLN - REAL ((MAXWV+1)*((IROMB+1)*MAXWV+2)/2,JB:JE)
LEGENDRE POLYNOMIALS
PLNTOP - REAL (MAXWV+1,JB:JE) LEGENDRE POLYNOMIAL OVER TOP
SPTRANF1
The SPTRANF1 routine performs an single latitude transform for
subprogram SPTRANF. Use this subprogram outside
the SPTRANF family context at your own risk.
USAGE: CALL SPTRANF1(IROMB,MAXWV,IDRT,IMAX,JMAX,JB,JE,
EPS,EPSTOP,ENN1,ELONN1,EON,EONTOP,
AFFT,CLAT,SLAT,WLAT,PLN,PLNTOP,MP,
W,WTOP,G,IDIR)
Input arguments:
IROMB - INTEGER SPECTRAL DOMAIN SHAPE
(0 FOR TRIANGULAR, 1 FOR RHOMBOIDAL)
MAXWV - INTEGER SPECTRAL TRUNCATION
IDRT - INTEGER GRID IDENTIFIER
(IDRT=4 FOR GAUSSIAN GRID,
IDRT=0 FOR EQUALLY-SPACED GRID INCLUDING POLES,
IDRT=256 FOR EQUALLY-SPACED GRID EXCLUDING POLES)
IMAX - INTEGER EVEN NUMBER OF LONGITUDES
JMAX - INTEGER NUMBER OF LATITUDES
JB - INTEGER LATITUDE INDEX (FROM POLE) TO BEGIN TRANSFORM
JE - INTEGER LATITUDE INDEX (FROM POLE) TO END TRANSFORM
EPS - REAL ((MAXWV+1)*((IROMB+1)*MAXWV+2)/2)
EPSTOP - REAL (MAXWV+1)
ENN1 - REAL ((MAXWV+1)*((IROMB+1)*MAXWV+2)/2)
ELONN1 - REAL ((MAXWV+1)*((IROMB+1)*MAXWV+2)/2)
EON - REAL ((MAXWV+1)*((IROMB+1)*MAXWV+2)/2)
EONTOP - REAL (MAXWV+1)
CLAT - REAL (JB:JE) COSINES OF LATITUDE
SLAT - REAL (JB:JE) SINES OF LATITUDE
WLAT - REAL (JB:JE) GAUSSIAN WEIGHTS
AFFT - REAL(8) (50000+4*IMAX) AUXILIARY ARRAY IF IDIR=0
PLN - REAL ((M+1)*((I+1)*M+2)/2,JB:JE) LEGENDRE POLYNOMIALS
PLNTOP - REAL (M+1,JB:JE) LEGENDRE POLYNOMIAL OVER TOP
MP - INTEGER IDENTIFIER (0 FOR SCALAR, 1 FOR VECTOR)
W - REAL (*) WAVE FIELD IF IDIR>0
WTOP - REAL (*) WAVE FIELD OVER TOP IF IDIR>0
G - REAL (IMAX,2,JB:JE) GRID FIELD IF IDIR<0
IDIR - INTEGER TRANSFORM FLAG
(IDIR>0 FOR WAVE TO GRID, IDIR<0 FOR GRID TO WAVE)
Output arguments:
W - REAL (*) WAVE FIELD IF IDIR<0
WTOP - REAL (*) WAVE FIELD OVER TOP IF IDIR<0
G - REAL (IMAX,2,JB:JE) GRID FIELD IF IDIR>0
SPTRANFV
The SPTRANFV routine performs a spherical transform
between spectral coefficients of divergences and curls
and vector fields on a global cylindrical grid.
The wave-space can be either Triangular or Rhomboidal.
The grid-space can be either an equally-spaced grid
(with or without pole points) or a Gaussian grid.
The wave and grid fields may have general indexing,
but each wave field is in sequential 'IBM order',
i.e. with zonal wavenumber as the slower index.
Transforms are done in latitude pairs for efficiency;
Thus grid arrays for each hemisphere must be passed.
If so requested, just a subset of the latitude pairs
may be transformed in each invocation of the subprogram.
The transforms are all multiprocessed over latitude except
the transform from Fourier to spectral is multiprocessed
over zonal wavenumber to ensure reproducibility.
Transform several fields at a time to improve vectorization.
Subprogram can be called from a multiprocessing environment.
USAGE: CALL SPTRANFV(IROMB,MAXWV,IDRT,IMAX,JMAX,KMAX,
IP,IS,JN,JS,KW,KG,JB,JE,JC,
WAVED,WAVEZ,GRIDUN,GRIDUS,GRIDVN,GRIDVS,IDIR)
Input arguments:
IROMB - INTEGER SPECTRAL DOMAIN SHAPE
(0 FOR TRIANGULAR, 1 FOR RHOMBOIDAL)
MAXWV - INTEGER SPECTRAL TRUNCATION
IDRT - INTEGER GRID IDENTIFIER
(IDRT=4 FOR GAUSSIAN GRID,
IDRT=0 FOR EQUALLY-SPACED GRID INCLUDING POLES,
IDRT=256 FOR EQUALLY-SPACED GRID EXCLUDING POLES)
IMAX - INTEGER EVEN NUMBER OF LONGITUDES.
JMAX - INTEGER NUMBER OF LATITUDES.
KMAX - INTEGER NUMBER OF FIELDS TO TRANSFORM.
IP - INTEGER LONGITUDE INDEX FOR THE PRIME MERIDIAN
IS - INTEGER SKIP NUMBER BETWEEN LONGITUDES
JN - INTEGER SKIP NUMBER BETWEEN N.H. LATITUDES FROM NORTH
JS - INTEGER SKIP NUMBER BETWEEN S.H. LATITUDES FROM SOUTH
KW - INTEGER SKIP NUMBER BETWEEN WAVE FIELDS
KG - INTEGER SKIP NUMBER BETWEEN GRID FIELDS
JB - INTEGER LATITUDE INDEX (FROM POLE) TO BEGIN TRANSFORM
JE - INTEGER LATITUDE INDEX (FROM POLE) TO END TRANSFORM
JC - INTEGER NUMBER OF CPUS OVER WHICH TO MULTIPROCESS
WAVED - REAL (*) WAVE DIVERGENCE FIELDS IF IDIR>0
WAVEZ - REAL (*) WAVE VORTICITY FIELDS IF IDIR>0
GRIDUN - REAL (*) N.H. GRID U-WINDS (STARTING AT JB) IF IDIR<0
GRIDUS - REAL (*) S.H. GRID U-WINDS (STARTING AT JB) IF IDIR<0
GRIDVN - REAL (*) N.H. GRID V-WINDS (STARTING AT JB) IF IDIR<0
GRIDVS - REAL (*) S.H. GRID V-WINDS (STARTING AT JB) IF IDIR<0
IDIR - INTEGER TRANSFORM FLAG
(IDIR>0 FOR WAVE TO GRID, IDIR<0 FOR GRID TO WAVE)
Output arguments:
WAVED - REAL (*) WAVE DIVERGENCE FIELDS IF IDIR<0
[WAVED=(D(GRIDU)/DLAM+D(CLAT*GRIDV)/DPHI)/(CLAT*RERTH)]
WAVEZ - REAL (*) WAVE VORTICITY FIELDS IF IDIR<0
C [WAVEZ=(D(GRIDV)/DLAM-D(CLAT*GRIDU)/DPHI)/(CLAT*RERTH)]
C GRIDUN - REAL (*) N.H. GRID U-WINDS (STARTING AT JB) IF IDIR>0
GRIDUS - REAL (*) S.H. GRID U-WINDS (STARTING AT JB) IF IDIR>0
GRIDVN - REAL (*) N.H. GRID V-WINDS (STARTING AT JB) IF IDIR>0
GRIDVS - REAL (*) S.H. GRID V-WINDS (STARTING AT JB) IF IDIR>0
REMARKS:
MINIMUM GRID DIMENSIONS FOR UNALIASED TRANSFORMS TO SPECTRAL:
DIMENSION LINEAR QUADRATIC
----------------------- --------- -------------
IMAX 2*MAXWV+2 3*MAXWV/2*2+2
JMAX (IDRT=4,IROMB=0) 1*MAXWV+1 3*MAXWV/2+1
JMAX (IDRT=4,IROMB=1) 2*MAXWV+1 5*MAXWV/2+1
JMAX (IDRT=0,IROMB=0) 2*MAXWV+3 3*MAXWV/2*2+3
JMAX (IDRT=0,IROMB=1) 4*MAXWV+3 5*MAXWV/2*2+3
JMAX (IDRT=256,IROMB=0) 2*MAXWV+1 3*MAXWV/2*2+1
JMAX (IDRT=256,IROMB=1) 4*MAXWV+1 5*MAXWV/2*2+1
SPTRANV
The SPTRANV routine performs a spherical transform
between spectral coefficients of divergences and curls
and vector fields on a global cylindrical grid.
The wave-space can be either Triangular or Rhomboidal.
The grid-space can be either an equally-spaced grid
(with or without pole points) or a Gaussian grid.
The wave and grid fields may have general indexing,
but each wave field is in sequential 'IBM order',
i.e. with zonal wavenumber as the slower index.
Transforms are done in latitude pairs for efficiency;
Thus grid arrays for each hemisphere must be passed.
If so requested, just a subset of the latitude pairs
may be transformed in each invocation of the subprogram.
The transforms are all multiprocessed over latitude except
The transform from Fourier to spectral is multiprocessed
over zonal wavenumber to ensure reproducibility.
Transform several fields at a time to improve vectorization.
Subprogram can be called from a multiprocessing environment.
USAGE: CALL SPTRANV(IROMB,MAXWV,IDRT,IMAX,JMAX,KMAX,
IPRIME,ISKIP,JNSKIP,JSSKIP,KWSKIP,KGSKIP,
JBEG,JEND,JCPU,
WAVED,WAVEZ,GRIDUN,GRIDUS,GRIDVN,GRIDVS,IDIR)
Input arguments:
IROMB - INTEGER SPECTRAL DOMAIN SHAPE
(0 FOR TRIANGULAR, 1 FOR RHOMBOIDAL)
MAXWV - INTEGER SPECTRAL TRUNCATION
IDRT - INTEGER GRID IDENTIFIER
(IDRT=4 FOR GAUSSIAN GRID,
IDRT=0 FOR EQUALLY-SPACED GRID INCLUDING POLES,
IDRT=256 FOR EQUALLY-SPACED GRID EXCLUDING POLES)
IMAX - INTEGER EVEN NUMBER OF LONGITUDES.
JMAX - INTEGER NUMBER OF LATITUDES.
KMAX - INTEGER NUMBER OF FIELDS TO TRANSFORM.
IPRIME - INTEGER LONGITUDE INDEX FOR THE PRIME MERIDIAN.
(DEFAULTS TO 1 IF IPRIME=0)
ISKIP - INTEGER SKIP NUMBER BETWEEN LONGITUDES
(DEFAULTS TO 1 IF ISKIP=0)
JNSKIP - INTEGER SKIP NUMBER BETWEEN N.H. LATITUDES FROM NORTH
(DEFAULTS TO IMAX IF JNSKIP=0)
JSSKIP - INTEGER SKIP NUMBER BETWEEN S.H. LATITUDES FROM SOUTH
(DEFAULTS TO -IMAX IF JSSKIP=0)
KWSKIP - INTEGER SKIP NUMBER BETWEEN WAVE FIELDS
(DEFAULTS TO (MAXWV+1)*((IROMB+1)*MAXWV+2) IF KWSKIP=0)
KGSKIP - INTEGER SKIP NUMBER BETWEEN GRID FIELDS
(DEFAULTS TO IMAX*JMAX IF KGSKIP=0)
JBEG - INTEGER LATITUDE INDEX (FROM POLE) TO BEGIN TRANSFORM
(DEFAULTS TO 1 IF JBEG=0)
(IF JBEG=0 AND IDIR<0, WAVE IS ZEROED BEFORE TRANSFORM)
JEND - INTEGER LATITUDE INDEX (FROM POLE) TO END TRANSFORM
(DEFAULTS TO (JMAX+1)/2 IF JEND=0)
JCPU - INTEGER NUMBER OF CPUS OVER WHICH TO MULTIPROCESS
WAVED - REAL (*) WAVE DIVERGENCE FIELDS IF IDIR>0
WAVEZ - REAL (*) WAVE VORTICITY FIELDS IF IDIR>0
GRIDUN - REAL (*) N.H. GRID U-WINDS (STARTING AT JBEG) IF IDIR<0
GRIDUS - REAL (*) S.H. GRID U-WINDS (STARTING AT JBEG) IF IDIR<0
GRIDVN - REAL (*) N.H. GRID V-WINDS (STARTING AT JBEG) IF IDIR<0
GRIDVS - REAL (*) S.H. GRID V-WINDS (STARTING AT JBEG) IF IDIR<0
IDIR - INTEGER TRANSFORM FLAG
(IDIR>0 FOR WAVE TO GRID, IDIR<0 FOR GRID TO WAVE)
Output arguments:
WAVED - REAL (*) WAVE DIVERGENCE FIELDS IF IDIR<0
[WAVED=(D(GRIDU)/DLAM+D(CLAT*GRIDV)/DPHI)/(CLAT*RERTH)]
WAVEZ - REAL (*) WAVE VORTICITY FIELDS IF IDIR<0
[WAVEZ=(D(GRIDV)/DLAM-D(CLAT*GRIDU)/DPHI)/(CLAT*RERTH)]
GRIDUN - REAL (*) N.H. GRID U-WINDS (STARTING AT JBEG) IF IDIR>0
GRIDUS - REAL (*) S.H. GRID U-WINDS (STARTING AT JBEG) IF IDIR>0
GRIDVN - REAL (*) N.H. GRID V-WINDS (STARTING AT JBEG) IF IDIR>0
GRIDVS - REAL (*) S.H. GRID V-WINDS (STARTING AT JBEG) IF IDIR>0
REMARKS:
MINIMUM GRID DIMENSIONS FOR UNALIASED TRANSFORMS TO SPECTRAL:
DIMENSION LINEAR QUADRATIC
----------------------- --------- -------------
IMAX 2*MAXWV+2 3*MAXWV/2*2+2
JMAX (IDRT=4,IROMB=0) 1*MAXWV+1 3*MAXWV/2+1
JMAX (IDRT=4,IROMB=1) 2*MAXWV+1 5*MAXWV/2+1
JMAX (IDRT=0,IROMB=0) 2*MAXWV+3 3*MAXWV/2*2+3
JMAX (IDRT=0,IROMB=1) 4*MAXWV+3 5*MAXWV/2*2+3
JMAX (IDRT=256,IROMB=0) 2*MAXWV+1 3*MAXWV/2*2+1
JMAX (IDRT=256,IROMB=1) 4*MAXWV+1 5*MAXWV/2*2+1
SPTRUN
The SPTRUN routine spectrally truncates scalar fields
on a global cylindrical grid, returning the fields
to a possibly different global cylindrical grid.
The wave-space can be either Triangular or Rhomboidal.
either grid-space can be either an equally-spaced grid
(with or without pole points) or a Gaussian grid.
The grid fields may have general indexing.
The transforms are all multiprocessed.
Transform several fields at a time to improve vectorization.
Subprogram can be called from a multiprocessing environment.
USAGE: CALL SPTRUN(IROMB,MAXWV,IDRTI,IMAXI,JMAXI,IDRTO,IMAXO,JMAXO,
KMAX,IPRIME,ISKIPI,JSKIPI,KSKIPI,
ISKIPO,JSKIPO,KSKIPO,JCPU,GRIDI,GRIDO)
Input arguments:
IROMB - INTEGER SPECTRAL DOMAIN SHAPE
(0 FOR TRIANGULAR, 1 FOR RHOMBOIDAL)
MAXWV - INTEGER SPECTRAL TRUNCATION
IDRTI - INTEGER INPUT GRID IDENTIFIER
(IDRTI=4 FOR GAUSSIAN GRID,
IDRTI=0 FOR EQUALLY-SPACED GRID INCLUDING POLES,
IDRTI=256 FOR EQUALLY-SPACED GRID EXCLUDING POLES)
IMAXI - INTEGER EVEN NUMBER OF INPUT LONGITUDES.
JMAXI - INTEGER NUMBER OF INPUT LATITUDES.
IDRTO - INTEGER OUTPUT GRID IDENTIFIER
(IDRTO=4 FOR GAUSSIAN GRID,
IDRTO=0 FOR EQUALLY-SPACED GRID INCLUDING POLES,
IDRTO=256 FOR EQUALLY-SPACED GRID EXCLUDING POLES)
IMAXO - INTEGER EVEN NUMBER OF OUTPUT LONGITUDES.
JMAXO - INTEGER NUMBER OF OUTPUT LATITUDES.
KMAX - INTEGER NUMBER OF FIELDS TO TRANSFORM.
IPRIME - INTEGER INPUT LONGITUDE INDEX FOR THE PRIME MERIDIAN.
(DEFAULTS TO 1 IF IPRIME=0)
(OUTPUT LONGITUDE INDEX FOR PRIME MERIDIAN ASSUMED 1.)
ISKIPI - INTEGER SKIP NUMBER BETWEEN INPUT LONGITUDES
(DEFAULTS TO 1 IF ISKIPI=0)
JSKIPI - INTEGER SKIP NUMBER BETWEEN INPUT LATITUDES FROM SOUTH
(DEFAULTS TO -IMAXI IF JSKIPI=0)
KSKIPI - INTEGER SKIP NUMBER BETWEEN INPUT GRID FIELDS
(DEFAULTS TO IMAXI*JMAXI IF KSKIPI=0)
ISKIPO - INTEGER SKIP NUMBER BETWEEN OUTPUT LONGITUDES
(DEFAULTS TO 1 IF ISKIPO=0)
JSKIPO - INTEGER SKIP NUMBER BETWEEN OUTPUT LATITUDES FROM SOUTH
(DEFAULTS TO -IMAXO IF JSKIPO=0)
KSKIPO - INTEGER SKIP NUMBER BETWEEN OUTPUT GRID FIELDS
(DEFAULTS TO IMAXO*JMAXO IF KSKIPO=0)
JCPU - INTEGER NUMBER OF CPUS OVER WHICH TO MULTIPROCESS
(DEFAULTS TO ENVIRONMENT NCPUS IF JCPU=0)
GRIDI - REAL (*) INPUT GRID FIELDS
Output arguments:
GRIDO - REAL (*) OUTPUT GRID FIELDS
(MAY OVERLAY INPUT FIELDS IF GRID SHAPE IS APPROPRIATE)
REMARKS:
MINIMUM GRID DIMENSIONS FOR UNALIASED TRANSFORMS TO SPECTRAL:
DIMENSION LINEAR QUADRATIC
----------------------- --------- -------------
IMAX 2*MAXWV+2 3*MAXWV/2*2+2
JMAX (IDRT=4,IROMB=0) 1*MAXWV+1 3*MAXWV/2+1
JMAX (IDRT=4,IROMB=1) 2*MAXWV+1 5*MAXWV/2+1
JMAX (IDRT=0,IROMB=0) 2*MAXWV+3 3*MAXWV/2*2+3
JMAX (IDRT=0,IROMB=1) 4*MAXWV+3 5*MAXWV/2*2+3
JMAX (IDRT=256,IROMB=0) 2*MAXWV+1 3*MAXWV/2*2+1
JMAX (IDRT=256,IROMB=1) 4*MAXWV+1 5*MAXWV/2*2+1
SPTRUND
The SPTRUND routine spectrally truncates scalar fields
on a global cylindrical grid, returning their means and
gradients to a possibly different global cylindrical grid.
The wave-space can be either Triangular or Rhomboidal.
Either grid-space can be either an equally-spaced grid
(with or without pole points) or a Gaussian grid.
The grid fields may have general indexing.
The transforms are all multiprocessed.
Over zonal wavenumber to ensure reproducibility.
Transform several fields at a time to improve vectorization.
Subprogram can be called from a multiprocessing environment.
USAGE: CALL SPTRUND(IROMB,MAXWV,IDRTI,IMAXI,JMAXI,
IDRTO,IMAXO,JMAXO,KMAX,
IPRIME,ISKIPI,JSKIPI,KSKIPI,
ISKIPO,JSKIPO,KSKIPO,JCPU,GRID,
GRIDMN,GRIDX,GRIDY)
Input arguments:
IROMB - INTEGER SPECTRAL DOMAIN SHAPE
(0 FOR TRIANGULAR, 1 FOR RHOMBOIDAL)
MAXWV - INTEGER SPECTRAL TRUNCATION
IDRTI - INTEGER INPUT GRID IDENTIFIER
(IDRTI=4 FOR GAUSSIAN GRID,
IDRTI=0 FOR EQUALLY-SPACED GRID INCLUDING POLES,
IDRTI=256 FOR EQUALLY-SPACED GRID EXCLUDING POLES)
IMAXI - INTEGER EVEN NUMBER OF INPUT LONGITUDES.
JMAXI - INTEGER NUMBER OF INPUT LATITUDES.
IDRTO - INTEGER OUTPUT GRID IDENTIFIER
(IDRTO=4 FOR GAUSSIAN GRID,
IDRTO=0 FOR EQUALLY-SPACED GRID INCLUDING POLES,
IDRTO=256 FOR EQUALLY-SPACED GRID EXCLUDING POLES)
IMAXO - INTEGER EVEN NUMBER OF OUTPUT LONGITUDES.
JMAXO - INTEGER NUMBER OF OUTPUT LATITUDES.
KMAX - INTEGER NUMBER OF FIELDS TO TRANSFORM.
IPRIME - INTEGER INPUT LONGITUDE INDEX FOR THE PRIME MERIDIAN.
(DEFAULTS TO 1 IF IPRIME=0)
(OUTPUT LONGITUDE INDEX FOR PRIME MERIDIAN ASSUMED 1.)
ISKIPI - INTEGER SKIP NUMBER BETWEEN INPUT LONGITUDES
(DEFAULTS TO 1 IF ISKIPI=0)
JSKIPI - INTEGER SKIP NUMBER BETWEEN INPUT LATITUDES FROM SOUTH
(DEFAULTS TO -IMAXI IF JSKIPI=0)
KSKIPI - INTEGER SKIP NUMBER BETWEEN INPUT GRID FIELDS
(DEFAULTS TO IMAXI*JMAXI IF KSKIPI=0)
ISKIPO - INTEGER SKIP NUMBER BETWEEN OUTPUT LONGITUDES
(DEFAULTS TO 1 IF ISKIPO=0)
JSKIPO - INTEGER SKIP NUMBER BETWEEN OUTPUT LATITUDES FROM SOUTH
(DEFAULTS TO -IMAXO IF JSKIPO=0)
KSKIPO - INTEGER SKIP NUMBER BETWEEN OUTPUT GRID FIELDS
(DEFAULTS TO IMAXO*JMAXO IF KSKIPO=0)
JCPU - INTEGER NUMBER OF CPUS OVER WHICH TO MULTIPROCESS
(DEFAULTS TO ENVIRONMENT NCPUS IF JCPU=0)
GRID - REAL (*) INPUT GRID FIELDS
Output arguments:
GRIDMN - REAL (KMAX) OUTPUT GLOBAL MEANS
GRIDX - REAL (*) OUTPUT X-GRADIENTS
GRIDY - REAL (*) OUTPUT Y-GRADIENTS
REMARKS:
MINIMUM GRID DIMENSIONS FOR UNALIASED TRANSFORMS TO SPECTRAL:
DIMENSION LINEAR QUADRATIC
----------------------- --------- -------------
IMAX 2*MAXWV+2 3*MAXWV/2*2+2
JMAX (IDRT=4,IROMB=0) 1*MAXWV+1 3*MAXWV/2+1
JMAX (IDRT=4,IROMB=1) 2*MAXWV+1 5*MAXWV/2+1
JMAX (IDRT=0,IROMB=0) 2*MAXWV+3 3*MAXWV/2*2+3
JMAX (IDRT=0,IROMB=1) 4*MAXWV+3 5*MAXWV/2*2+3
JMAX (IDRT=256,IROMB=0) 2*MAXWV+1 3*MAXWV/2*2+1
JMAX (IDRT=256,IROMB=1) 4*MAXWV+1 5*MAXWV/2*2+1
SPTRUNG
The SPTRUNG routine spectrally truncates scalar fields
on a global cylindrical grid, returning the fields
to specified sets of station points on the globe.
The wave-space can be either Triangular or Rhomboidal.
The grid-space can be either an equally-spaced grid
(with or without pole points) or a Gaussian grid.
The grid and point fields may have general indexing.
The transforms are all multiprocessed.
Transform several fields at a time to improve vectorization.
Subprogram can be called from a multiprocessing environment.
USAGE: CALL SPTRUNG(IROMB,MAXWV,IDRTI,IMAXI,JMAXI,KMAX,NMAX,
IPRIME,ISKIPI,JSKIPI,KSKIPI,KGSKIP,
NRSKIP,NGSKIP,JCPU,RLAT,RLON,GRIDI,GP)
Input arguments:
IROMB - INTEGER SPECTRAL DOMAIN SHAPE
(0 FOR TRIANGULAR, 1 FOR RHOMBOIDAL)
MAXWV - INTEGER SPECTRAL TRUNCATION
IDRTI - INTEGER INPUT GRID IDENTIFIER
(IDRTI=4 FOR GAUSSIAN GRID,
IDRTI=0 FOR EQUALLY-SPACED GRID INCLUDING POLES,
IDRTI=256 FOR EQUALLY-SPACED GRID EXCLUDING POLES)
IMAXI - INTEGER EVEN NUMBER OF INPUT LONGITUDES.
JMAXI - INTEGER NUMBER OF INPUT LATITUDES.
KMAX - INTEGER NUMBER OF FIELDS TO TRANSFORM.
NMAX - INTEGER NUMBER OF STATION POINTS TO RETURN
IPRIME - INTEGER INPUT LONGITUDE INDEX FOR THE PRIME MERIDIAN.
(DEFAULTS TO 1 IF IPRIME=0)
(OUTPUT LONGITUDE INDEX FOR PRIME MERIDIAN ASSUMED 1.)
ISKIPI - INTEGER SKIP NUMBER BETWEEN INPUT LONGITUDES
(DEFAULTS TO 1 IF ISKIPI=0)
JSKIPI - INTEGER SKIP NUMBER BETWEEN INPUT LATITUDES FROM SOUTH
(DEFAULTS TO -IMAXI IF JSKIPI=0)
KSKIPI - INTEGER SKIP NUMBER BETWEEN INPUT GRID FIELDS
(DEFAULTS TO IMAXI*JMAXI IF KSKIPI=0)
KGSKIP - INTEGER SKIP NUMBER BETWEEN STATION POINT SETS
(DEFAULTS TO NMAX IF KGSKIP=0)
NRSKIP - INTEGER SKIP NUMBER BETWEEN STATION LATS AND LONS
(DEFAULTS TO 1 IF NRSKIP=0)
NGSKIP - INTEGER SKIP NUMBER BETWEEN STATION POINTS
(DEFAULTS TO 1 IF NGSKIP=0)
RLAT - REAL (*) STATION LATITUDES IN DEGREES
RLON - REAL (*) STATION LONGITUDES IN DEGREES
JCPU - INTEGER NUMBER OF CPUS OVER WHICH TO MULTIPROCESS
(DEFAULTS TO ENVIRONMENT NCPUS IF JCPU=0)
GRIDI - REAL (*) INPUT GRID FIELDS
Output arguments:
GP - REAL (*) STATION POINT SETS
REMARKS:
MINIMUM GRID DIMENSIONS FOR UNALIASED TRANSFORMS TO SPECTRAL:
DIMENSION LINEAR QUADRATIC
----------------------- --------- -------------
IMAX 2*MAXWV+2 3*MAXWV/2*2+2
JMAX (IDRT=4,IROMB=0) 1*MAXWV+1 3*MAXWV/2+1
JMAX (IDRT=4,IROMB=1) 2*MAXWV+1 5*MAXWV/2+1
JMAX (IDRT=0,IROMB=0) 2*MAXWV+3 3*MAXWV/2*2+3
JMAX (IDRT=0,IROMB=1) 4*MAXWV+3 5*MAXWV/2*2+3
JMAX (IDRT=256,IROMB=0) 2*MAXWV+1 3*MAXWV/2*2+1
JMAX (IDRT=256,IROMB=1) 4*MAXWV+1 5*MAXWV/2*2+1
SPTRUNGV
The SPTRUNGV routine spectrally truncates vectors fields
on a global cylindrical grid, returning the fields
to specified sets of station points on the globe.
The wave-space can be either Triangular or Rhomboidal.
The grid-space can be either an equally-spaced grid
(with or without pole points) or a Gaussian grid.
The grid and point fields may have general indexing.
The transforms are all multiprocessed.
Transform several fields at a time to improve vectorization.
Subprogram can be called from a multiprocessing environment.
USAGE: CALL SPTRUNGV(IROMB,MAXWV,IDRTI,IMAXI,JMAXI,KMAX,NMAX,
IPRIME,ISKIPI,JSKIPI,KSKIPI,KGSKIP,
NRSKIP,NGSKIP,JCPU,RLAT,RLON,GRIDUI,GRIDVI,
LUV,UP,VP,LDZ,DP,ZP,LPS,PP,SP)
Input arguments:
IROMB - INTEGER SPECTRAL DOMAIN SHAPE
(0 FOR TRIANGULAR, 1 FOR RHOMBOIDAL)
MAXWV - INTEGER SPECTRAL TRUNCATION
IDRTI - INTEGER INPUT GRID IDENTIFIER
(IDRTI=4 FOR GAUSSIAN GRID,
IDRTI=0 FOR EQUALLY-SPACED GRID INCLUDING POLES,
IDRTI=256 FOR EQUALLY-SPACED GRID EXCLUDING POLES)
IMAXI - INTEGER EVEN NUMBER OF INPUT LONGITUDES.
JMAXI - INTEGER NUMBER OF INPUT LATITUDES.
KMAX - INTEGER NUMBER OF FIELDS TO TRANSFORM.
NMAX - INTEGER NUMBER OF STATION POINTS TO RETURN
IPRIME - INTEGER INPUT LONGITUDE INDEX FOR THE PRIME MERIDIAN.
(DEFAULTS TO 1 IF IPRIME=0)
(OUTPUT LONGITUDE INDEX FOR PRIME MERIDIAN ASSUMED 1.)
ISKIPI - INTEGER SKIP NUMBER BETWEEN INPUT LONGITUDES
(DEFAULTS TO 1 IF ISKIPI=0)
JSKIPI - INTEGER SKIP NUMBER BETWEEN INPUT LATITUDES FROM SOUTH
(DEFAULTS TO -IMAXI IF JSKIPI=0)
KSKIPI - INTEGER SKIP NUMBER BETWEEN INPUT GRID FIELDS
(DEFAULTS TO IMAXI*JMAXI IF KSKIPI=0)
KGSKIP - INTEGER SKIP NUMBER BETWEEN STATION POINT SETS
(DEFAULTS TO NMAX IF KGSKIP=0)
NRSKIP - INTEGER SKIP NUMBER BETWEEN STATION LATS AND LONS
(DEFAULTS TO 1 IF NRSKIP=0)
NGSKIP - INTEGER SKIP NUMBER BETWEEN STATION POINTS
(DEFAULTS TO 1 IF NGSKIP=0)
RLAT - REAL (*) STATION LATITUDES IN DEGREES
RLON - REAL (*) STATION LONGITUDES IN DEGREES
JCPU - INTEGER NUMBER OF CPUS OVER WHICH TO MULTIPROCESS
(DEFAULTS TO ENVIRONMENT NCPUS IF JCPU=0)
GRIDUI - REAL (*) INPUT GRID U-WINDS
GRIDVI - REAL (*) INPUT GRID V-WINDS
LUV - LOGICAL FLAG WHETHER TO RETURN WINDS
LDZ - LOGICAL FLAG WHETHER TO RETURN DIVERGENCE AND VORTICITY
LPS - LOGICAL FLAG WHETHER TO RETURN POTENTIAL AND STREAMFCN
Output arguments:
UP - REAL (*) STATION U-WINDS IF LUV
VP - REAL (*) STATION V-WINDS IF LUV
DP - REAL (*) STATION DIVERGENCES IF LDZ
ZP - REAL (*) STATION VORTICITIES IF LDZ
PP - REAL (*) STATION POTENTIALS IF LPS
SP - REAL (*) STATION STREAMFCNS IF LPS
REMARKS:
MINIMUM GRID DIMENSIONS FOR UNALIASED TRANSFORMS TO SPECTRAL:
DIMENSION LINEAR QUADRATIC
----------------------- --------- -------------
IMAX 2*MAXWV+2 3*MAXWV/2*2+2
JMAX (IDRT=4,IROMB=0) 1*MAXWV+1 3*MAXWV/2+1
JMAX (IDRT=4,IROMB=1) 2*MAXWV+1 5*MAXWV/2+1
JMAX (IDRT=0,IROMB=0) 2*MAXWV+3 3*MAXWV/2*2+3
JMAX (IDRT=0,IROMB=1) 4*MAXWV+3 5*MAXWV/2*2+3
JMAX (IDRT=256,IROMB=0) 2*MAXWV+1 3*MAXWV/2*2+1
JMAX (IDRT=256,IROMB=1) 4*MAXWV+1 5*MAXWV/2*2+1
SPTRUNL
The SPTRUNL routine spectrally truncates scalar fields
on a global cylindrical grid, returning their LaplaciaN
or Inverse to a possibly different global cylindrical grid.
The wave-space can be either Triangular or Rhomboidal.
either grid-space can be either an equally-spaced grid
(with or without pole points) or a Gaussian grid.
The grid fields may have general indexing.
The transforms are all multiprocessed.
over zonal wavenumber to ensure reproducibility.
Transform several fields at a time to improve vectorization.
Subprogram can be called from a multiprocessing environment.
USAGE: CALL SPTRUNL(IROMB,MAXWV,IDRTI,IMAXI,JMAXI,
IDRTO,IMAXO,JMAXO,KMAX,
IPRIME,ISKIPI,JSKIPI,KSKIPI,
ISKIPO,JSKIPO,KSKIPO,JCPU,IDIR,GRIDI,GRIDO)
Input arguments:
IROMB - INTEGER SPECTRAL DOMAIN SHAPE
(0 FOR TRIANGULAR, 1 FOR RHOMBOIDAL)
MAXWV - INTEGER SPECTRAL TRUNCATION
IDRTI - INTEGER INPUT GRID IDENTIFIER
(IDRTI=4 FOR GAUSSIAN GRID,
IDRTI=0 FOR EQUALLY-SPACED GRID INCLUDING POLES,
IDRTI=256 FOR EQUALLY-SPACED GRID EXCLUDING POLES)
IMAXI - INTEGER EVEN NUMBER OF INPUT LONGITUDES.
JMAXI - INTEGER NUMBER OF INPUT LATITUDES.
IDRTO - INTEGER OUTPUT GRID IDENTIFIER
(IDRTO=4 FOR GAUSSIAN GRID,
IDRTO=0 FOR EQUALLY-SPACED GRID INCLUDING POLES,
IDRTO=256 FOR EQUALLY-SPACED GRID EXCLUDING POLES)
IMAXO - INTEGER EVEN NUMBER OF OUTPUT LONGITUDES.
JMAXO - INTEGER NUMBER OF OUTPUT LATITUDES.
KMAX - INTEGER NUMBER OF FIELDS TO TRANSFORM.
IPRIME - INTEGER INPUT LONGITUDE INDEX FOR THE PRIME MERIDIAN.
(DEFAULTS TO 1 IF IPRIME=0)
(OUTPUT LONGITUDE INDEX FOR PRIME MERIDIAN ASSUMED 1.)
ISKIPI - INTEGER SKIP NUMBER BETWEEN INPUT LONGITUDES
(DEFAULTS TO 1 IF ISKIPI=0)
JSKIPI - INTEGER SKIP NUMBER BETWEEN INPUT LATITUDES FROM SOUTH
(DEFAULTS TO -IMAXI IF JSKIPI=0)
KSKIPI - INTEGER SKIP NUMBER BETWEEN INPUT GRID FIELDS
(DEFAULTS TO IMAXI*JMAXI IF KSKIPI=0)
ISKIPO - INTEGER SKIP NUMBER BETWEEN OUTPUT LONGITUDES
(DEFAULTS TO 1 IF ISKIPO=0)
JSKIPO - INTEGER SKIP NUMBER BETWEEN OUTPUT LATITUDES FROM SOUTH
(DEFAULTS TO -IMAXO IF JSKIPO=0)
KSKIPO - INTEGER SKIP NUMBER BETWEEN OUTPUT GRID FIELDS
(DEFAULTS TO IMAXO*JMAXO IF KSKIPO=0)
JCPU - INTEGER NUMBER OF CPUS OVER WHICH TO MULTIPROCESS
(DEFAULTS TO ENVIRONMENT NCPUS IF JCPU=0)
IDIR - INTEGER FLAG
IDIR > 0 TO TAKE LAPLACIAN
IDIR < 0 TO TAKE INVERSE LAPLACIAN
GRIDI - REAL (*) INPUT GRID FIELDS
Output arguments:
GRIDO - REAL (*) OUTPUT GRID FIELDS
(MAY OVERLAY INPUT FIELDS IF GRID SHAPE IS APPROPRIATE)
REMARKS:
MINIMUM GRID DIMENSIONS FOR UNALIASED TRANSFORMS TO SPECTRAL:
DIMENSION LINEAR QUADRATIC
----------------------- --------- -------------
IMAX 2*MAXWV+2 3*MAXWV/2*2+2
JMAX (IDRT=4,IROMB=0) 1*MAXWV+1 3*MAXWV/2+1
JMAX (IDRT=4,IROMB=1) 2*MAXWV+1 5*MAXWV/2+1
JMAX (IDRT=0,IROMB=0) 2*MAXWV+3 3*MAXWV/2*2+3
JMAX (IDRT=0,IROMB=1) 4*MAXWV+3 5*MAXWV/2*2+3
JMAX (IDRT=256,IROMB=0) 2*MAXWV+1 3*MAXWV/2*2+1
JMAX (IDRT=256,IROMB=1) 4*MAXWV+1 5*MAXWV/2*2+1
SPTRUNM
The SPTRUNM routine spectrally truncates scalar fields
on a global cylindrical grid, returning the fields
to a Mercator grid.
The wave-space can be either Triangular or Rhomboidal.
The grid-space can be either an equally-spaced grid
(with or without pole points) or a Gaussian grid.
The grid fields may have general indexing.
The transforms are all multiprocessed.
Transform several fields at a time to improve vectorization.
Subprogram can be called from a multiprocessing environment.
USAGE: CALL SPTRUNM(IROMB,MAXWV,IDRTI,IMAXI,JMAXI,KMAX,MI,MJ,
IPRIME,ISKIPI,JSKIPI,KSKIPI,KGSKIP,
NISKIP,NJSKIP,JCPU,RLAT1,RLON1,DLAT,DLON,
GRIDI,GM)
Input arguments:
IROMB - INTEGER SPECTRAL DOMAIN SHAPE
(0 FOR TRIANGULAR, 1 FOR RHOMBOIDAL)
MAXWV - INTEGER SPECTRAL TRUNCATION
IDRTI - INTEGER INPUT GRID IDENTIFIER
(IDRTI=4 FOR GAUSSIAN GRID,
IDRTI=0 FOR EQUALLY-SPACED GRID INCLUDING POLES,
IDRTI=256 FOR EQUALLY-SPACED GRID EXCLUDING POLES)
IMAXI - INTEGER EVEN NUMBER OF INPUT LONGITUDES.
JMAXI - INTEGER NUMBER OF INPUT LATITUDES.
KMAX - INTEGER NUMBER OF FIELDS TO TRANSFORM.
MI - INTEGER NUMBER OF POINTS IN THE FASTER ZONAL DIRECTION
MJ - INTEGER NUMBER OF POINTS IN THE SLOWER MERID DIRECTION
IPRIME - INTEGER INPUT LONGITUDE INDEX FOR THE PRIME MERIDIAN.
(DEFAULTS TO 1 IF IPRIME=0)
(OUTPUT LONGITUDE INDEX FOR PRIME MERIDIAN ASSUMED 1.)
ISKIPI - INTEGER SKIP NUMBER BETWEEN INPUT LONGITUDES
(DEFAULTS TO 1 IF ISKIPI=0)
JSKIPI - INTEGER SKIP NUMBER BETWEEN INPUT LATITUDES FROM SOUTH
(DEFAULTS TO -IMAXI IF JSKIPI=0)
KSKIPI - INTEGER SKIP NUMBER BETWEEN INPUT GRID FIELDS
(DEFAULTS TO IMAXI*JMAXI IF KSKIPI=0)
KGSKIP - INTEGER SKIP NUMBER BETWEEN GRID FIELDS
(DEFAULTS TO NPS*NPS IF KGSKIP=0)
NISKIP - INTEGER SKIP NUMBER BETWEEN GRID I-POINTS
(DEFAULTS TO 1 IF NISKIP=0)
NJSKIP - INTEGER SKIP NUMBER BETWEEN GRID J-POINTS
(DEFAULTS TO NPS IF NJSKIP=0)
JCPU - INTEGER NUMBER OF CPUS OVER WHICH TO MULTIPROCESS
(DEFAULTS TO ENVIRONMENT NCPUS IF JCPU=0)
RLAT1 - REAL LATITUDE OF THE FIRST GRID POINT IN DEGREES
RLON1 - REAL LONGITUDE OF THE FIRST GRID POINT IN DEGREES
DLAT - REAL LATITUDE INCREMENT IN DEGREES SUCH THAT
D(PHI)/D(J)=DLAT*COS(PHI) WHERE J IS MERIDIONAL INDEX.
DLAT IS NEGATIVE FOR GRIDS INDEXED SOUTHWARD.
(IN TERMS OF GRID INCREMENT DY VALID AT LATITUDE RLATI,
THE LATITUDE INCREMENT DLAT IS DETERMINED AS
DLAT=DPR*DY/(RERTH*COS(RLATI/DPR))
WHERE DPR=180/PI AND RERTH IS EARTH'S RADIUS)
DLON - REAL LONGITUDE INCREMENT IN DEGREES SUCH THAT
D(LAMBDA)/D(I)=DLON WHERE I IS ZONAL INDEX.
DLON IS NEGATIVE FOR GRIDS INDEXED WESTWARD.
GRIDI - REAL (*) INPUT GRID FIELDS
Output arguments:
GM - REAL (*) MERCATOR FIELDS
REMARKS:
MINIMUM GRID DIMENSIONS FOR UNALIASED TRANSFORMS TO SPECTRAL:
DIMENSION LINEAR QUADRATIC
----------------------- --------- -------------
IMAX 2*MAXWV+2 3*MAXWV/2*2+2
JMAX (IDRT=4,IROMB=0) 1*MAXWV+1 3*MAXWV/2+1
JMAX (IDRT=4,IROMB=1) 2*MAXWV+1 5*MAXWV/2+1
JMAX (IDRT=0,IROMB=0) 2*MAXWV+3 3*MAXWV/2*2+3
JMAX (IDRT=0,IROMB=1) 4*MAXWV+3 5*MAXWV/2*2+3
JMAX (IDRT=256,IROMB=0) 2*MAXWV+1 3*MAXWV/2*2+1
JMAX (IDRT=256,IROMB=1) 4*MAXWV+1 5*MAXWV/2*2+1
SPTRUNMV
The SPTRUNMV routine spectrally truncates vector fields
on a global cylindrical grid, returning the fields
to a Mercator grid.
The wave-space can be either triangular or rhomboidal.
The grid-space can be either an equally-spaced grid
(with or without pole points) or a Gaussian grid.
The grid fields may have general indexing.
The transforms are all multiprocessed.
Transform several fields at a time to improve vectorization.
Subprogram can be called from a multiprocessing environment.
USAGE: CALL SPTRUNMV(IROMB,MAXWV,IDRTI,IMAXI,JMAXI,KMAX,MI,MJ,
IPRIME,ISKIPI,JSKIPI,KSKIPI,KGSKIP,
NISKIP,NJSKIP,JCPU,RLAT1,RLON1,DLAT,DLON,
GRIDUI,GRIDVI,LUV,UM,VM,LDZ,DM,ZM,LPS,PM,SM)
Input arguments:
IROMB - INTEGER SPECTRAL DOMAIN SHAPE
(0 FOR TRIANGULAR, 1 FOR RHOMBOIDAL)
MAXWV - INTEGER SPECTRAL TRUNCATION
IDRTI - INTEGER INPUT GRID IDENTIFIER
(IDRTI=4 FOR GAUSSIAN GRID,
IDRTI=0 FOR EQUALLY-SPACED GRID INCLUDING POLES,
IDRTI=256 FOR EQUALLY-SPACED GRID EXCLUDING POLES)
IMAXI - INTEGER EVEN NUMBER OF INPUT LONGITUDES.
JMAXI - INTEGER NUMBER OF INPUT LATITUDES.
KMAX - INTEGER NUMBER OF FIELDS TO TRANSFORM.
MI - INTEGER NUMBER OF POINTS IN THE FASTER ZONAL DIRECTION
MJ - INTEGER NUMBER OF POINTS IN THE SLOWER MERID DIRECTION
IPRIME - INTEGER INPUT LONGITUDE INDEX FOR THE PRIME MERIDIAN.
(DEFAULTS TO 1 IF IPRIME=0)
(OUTPUT LONGITUDE INDEX FOR PRIME MERIDIAN ASSUMED 1.)
ISKIPI - INTEGER SKIP NUMBER BETWEEN INPUT LONGITUDES
(DEFAULTS TO 1 IF ISKIPI=0)
JSKIPI - INTEGER SKIP NUMBER BETWEEN INPUT LATITUDES FROM SOUTH
(DEFAULTS TO -IMAXI IF JSKIPI=0)
KSKIPI - INTEGER SKIP NUMBER BETWEEN INPUT GRID FIELDS
(DEFAULTS TO IMAXI*JMAXI IF KSKIPI=0)
KGSKIP - INTEGER SKIP NUMBER BETWEEN GRID FIELDS
(DEFAULTS TO MI*MJ IF KGSKIP=0)
NISKIP - INTEGER SKIP NUMBER BETWEEN GRID I-POINTS
(DEFAULTS TO 1 IF NISKIP=0)
NJSKIP - INTEGER SKIP NUMBER BETWEEN GRID J-POINTS
(DEFAULTS TO MI IF NJSKIP=0)
JCPU - INTEGER NUMBER OF CPUS OVER WHICH TO MULTIPROCESS
(DEFAULTS TO ENVIRONMENT NCPUS IF JCPU=0)
RLAT1 - REAL LATITUDE OF THE FIRST GRID POINT IN DEGREES
RLON1 - REAL LONGITUDE OF THE FIRST GRID POINT IN DEGREES
DLAT - REAL LATITUDE INCREMENT IN DEGREES SUCH THAT
D(PHI)/D(J)=DLAT*COS(PHI) WHERE J IS MERIDIONAL INDEX.
DLAT IS NEGATIVE FOR GRIDS INDEXED SOUTHWARD.
(IN TERMS OF GRID INCREMENT DY VALID AT LATITUDE RLATI,
THE LATITUDE INCREMENT DLAT IS DETERMINED AS
DLAT=DPR*DY/(RERTH*COS(RLATI/DPR))
WHERE DPR=180/PI AND RERTH IS EARTH'S RADIUS)
DLON - REAL LONGITUDE INCREMENT IN DEGREES SUCH THAT
D(LAMBDA)/D(I)=DLON WHERE I IS ZONAL INDEX.
DLON IS NEGATIVE FOR GRIDS INDEXED WESTWARD.
GRIDUI - REAL (*) INPUT GRID U-WINDS
GRIDVI - REAL (*) INPUT GRID V-WINDS
LUV - LOGICAL FLAG WHETHER TO RETURN WINDS
LDZ - LOGICAL FLAG WHETHER TO RETURN DIVERGENCE AND VORTICITY
LPS - LOGICAL FLAG WHETHER TO RETURN POTENTIAL AND STREAMFCN
Output arguments:
UM - REAL (*) MERCATOR U-WINDS IF LUV
VM - REAL (*) MERCATOR V-WINDS IF LUV
DM - REAL (*) MERCATOR DIVERGENCES IF LDZ
ZM - REAL (*) MERCATOR VORTICITIES IF LDZ
PM - REAL (*) MERCATOR POTENTIALS IF LPS
SM - REAL (*) MERCATOR STREAMFCNS IF LPS
REMARKS: MINIMUM GRID DIMENSIONS FOR UNALIASED TRANSFORMS TO SPECTRAL:
DIMENSION LINEAR QUADRATIC
----------------------- --------- -------------
IMAX 2*MAXWV+2 3*MAXWV/2*2+2
JMAX (IDRT=4,IROMB=0) 1*MAXWV+1 3*MAXWV/2+1
JMAX (IDRT=4,IROMB=1) 2*MAXWV+1 5*MAXWV/2+1
JMAX (IDRT=0,IROMB=0) 2*MAXWV+3 3*MAXWV/2*2+3
JMAX (IDRT=0,IROMB=1) 4*MAXWV+3 5*MAXWV/2*2+3
JMAX (IDRT=256,IROMB=0) 2*MAXWV+1 3*MAXWV/2*2+1
JMAX (IDRT=256,IROMB=1) 4*MAXWV+1 5*MAXWV/2*2+1
SPTRUNS
The SPTRUNS routine spectrally truncates scalar fields
on a global cylindrical grid, returning the fields
to specific pairs of Polar Stereographic scalar fields.
The wave-space can be either Triangular or Rhomboidal.
The grid-space can be either an equally-spaced grid
(with or without pole points) or a Gaussian grid.
The grid fields may have general indexing.
The transforms are all multiprocessed.
Transform several fields at a time to improve vectorization.
Subprogram can be called from a multiprocessing environment.
USAGE: CALL SPTRUNS(IROMB,MAXWV,IDRTI,IMAXI,JMAXI,KMAX,NPS,
IPRIME,ISKIPI,JSKIPI,KSKIPI,KGSKIP,
NISKIP,NJSKIP,JCPU,TRUE,XMESH,ORIENT,
GRIDI,GN,GS)
Input arguments:
IROMB - INTEGER SPECTRAL DOMAIN SHAPE
(0 FOR TRIANGULAR, 1 FOR RHOMBOIDAL)
MAXWV - INTEGER SPECTRAL TRUNCATION
IDRTI - INTEGER INPUT GRID IDENTIFIER
(IDRTI=4 FOR GAUSSIAN GRID,
IDRTI=0 FOR EQUALLY-SPACED GRID INCLUDING POLES,
IDRTI=256 FOR EQUALLY-SPACED GRID EXCLUDING POLES)
IMAXI - INTEGER EVEN NUMBER OF INPUT LONGITUDES.
JMAXI - INTEGER NUMBER OF INPUT LATITUDES.
KMAX - INTEGER NUMBER OF FIELDS TO TRANSFORM.
NPS - INTEGER ODD ORDER OF THE POLAR STEREOGRAPHIC GRIDS
IPRIME - INTEGER INPUT LONGITUDE INDEX FOR THE PRIME MERIDIAN.
(DEFAULTS TO 1 IF IPRIME=0)
(OUTPUT LONGITUDE INDEX FOR PRIME MERIDIAN ASSUMED 1.)
ISKIPI - INTEGER SKIP NUMBER BETWEEN INPUT LONGITUDES
(DEFAULTS TO 1 IF ISKIPI=0)
JSKIPI - INTEGER SKIP NUMBER BETWEEN INPUT LATITUDES FROM SOUTH
(DEFAULTS TO -IMAXI IF JSKIPI=0)
KSKIPI - INTEGER SKIP NUMBER BETWEEN INPUT GRID FIELDS
(DEFAULTS TO IMAXI*JMAXI IF KSKIPI=0)
KGSKIP - INTEGER SKIP NUMBER BETWEEN GRID FIELDS
(DEFAULTS TO NPS*NPS IF KGSKIP=0)
NISKIP - INTEGER SKIP NUMBER BETWEEN GRID I-POINTS
(DEFAULTS TO 1 IF NISKIP=0)
NJSKIP - INTEGER SKIP NUMBER BETWEEN GRID J-POINTS
(DEFAULTS TO NPS IF NJSKIP=0)
JCPU - INTEGER NUMBER OF CPUS OVER WHICH TO MULTIPROCESS
(DEFAULTS TO ENVIRONMENT NCPUS IF JCPU=0)
TRUE - REAL LATITUDE AT WHICH PS GRID IS TRUE (USUALLY 60.)
XMESH - REAL GRID LENGTH AT TRUE LATITUDE (M)
ORIENT - REAL LONGITUDE AT BOTTOM OF NORTHERN PS GRID
(SOUTHERN PS GRID WILL HAVE OPPOSITE ORIENTATION.)
GRIDI - REAL (*) INPUT GRID FIELDS
Output arguments:
GN - REAL (*) NORTHERN POLAR STEREOGRAPHIC FIELDS
GS - REAL (*) SOUTHERN POLAR STEREOGRAPHIC FIELDS
REMARKS:
MINIMUM GRID DIMENSIONS FOR UNALIASED TRANSFORMS TO SPECTRAL:
DIMENSION LINEAR QUADRATIC
----------------------- --------- -------------
IMAX 2*MAXWV+2 3*MAXWV/2*2+2
JMAX (IDRT=4,IROMB=0) 1*MAXWV+1 3*MAXWV/2+1
JMAX (IDRT=4,IROMB=1) 2*MAXWV+1 5*MAXWV/2+1
JMAX (IDRT=0,IROMB=0) 2*MAXWV+3 3*MAXWV/2*2+3
JMAX (IDRT=0,IROMB=1) 4*MAXWV+3 5*MAXWV/2*2+3
JMAX (IDRT=256,IROMB=0) 2*MAXWV+1 3*MAXWV/2*2+1
JMAX (IDRT=256,IROMB=1) 4*MAXWV+1 5*MAXWV/2*2+1
SPTRUNSV
The SPTRUNSV routine spectrally truncates vector fields
on a global cylindrical grid, returning the fields
to specific pairs of Polar Stereographic scalar fields.
The wave-space can be either Triangular or Rhomboidal.
The grid-space can be either an equally-spaced grid
(with or without pole points) or a Gaussian grid.
The grid fields may have general indexing.
The transforms are all multiprocessed.
Transform several fields at a time to improve vectorization.
Subprogram can be called from a multiprocessing environment.
USAGE: CALL SPTRUNSV(IROMB,MAXWV,IDRTI,IMAXI,JMAXI,KMAX,NPS,
IPRIME,ISKIPI,JSKIPI,KSKIPI,KGSKIP,
NISKIP,NJSKIP,JCPU,TRUE,XMESH,ORIENT,
GRIDUI,GRIDVI,
LUV,UN,VN,US,VS,LDZ,DN,ZN,DS,ZS,
LPS,PN,SN,PS,SS)
INPUT ARGUMENTS:
IROMB - INTEGER SPECTRAL DOMAIN SHAPE
(0 FOR TRIANGULAR, 1 FOR RHOMBOIDAL)
MAXWV - INTEGER SPECTRAL TRUNCATION
IDRTI - INTEGER INPUT GRID IDENTIFIER
(IDRTI=4 FOR GAUSSIAN GRID,
IDRTI=0 FOR EQUALLY-SPACED GRID INCLUDING POLES,
IDRTI=256 FOR EQUALLY-SPACED GRID EXCLUDING POLES)
IMAXI - INTEGER EVEN NUMBER OF INPUT LONGITUDES.
JMAXI - INTEGER NUMBER OF INPUT LATITUDES.
KMAX - INTEGER NUMBER OF FIELDS TO TRANSFORM.
NPS - INTEGER ODD ORDER OF THE POLAR STEREOGRAPHIC GRIDS
IPRIME - INTEGER INPUT LONGITUDE INDEX FOR THE PRIME MERIDIAN.
(DEFAULTS TO 1 IF IPRIME=0)
(OUTPUT LONGITUDE INDEX FOR PRIME MERIDIAN ASSUMED 1.)
ISKIPI - INTEGER SKIP NUMBER BETWEEN INPUT LONGITUDES
(DEFAULTS TO 1 IF ISKIPI=0)
JSKIPI - INTEGER SKIP NUMBER BETWEEN INPUT LATITUDES FROM SOUTH
(DEFAULTS TO -IMAXI IF JSKIPI=0)
KSKIPI - INTEGER SKIP NUMBER BETWEEN INPUT GRID FIELDS
(DEFAULTS TO IMAXI*JMAXI IF KSKIPI=0)
KGSKIP - INTEGER SKIP NUMBER BETWEEN GRID FIELDS
(DEFAULTS TO NPS*NPS IF KGSKIP=0)
NISKIP - INTEGER SKIP NUMBER BETWEEN GRID I-POINTS
(DEFAULTS TO 1 IF NISKIP=0)
NJSKIP - INTEGER SKIP NUMBER BETWEEN GRID J-POINTS
(DEFAULTS TO NPS IF NJSKIP=0)
JCPU - INTEGER NUMBER OF CPUS OVER WHICH TO MULTIPROCESS
(DEFAULTS TO ENVIRONMENT NCPUS IF JCPU=0)
TRUE - REAL LATITUDE AT WHICH PS GRID IS TRUE (USUALLY 60.)
XMESH - REAL GRID LENGTH AT TRUE LATITUDE (M)
ORIENT - REAL LONGITUDE AT BOTTOM OF NORTHERN PS GRID
(SOUTHERN PS GRID WILL HAVE OPPOSITE ORIENTATION.)
GRIDUI - REAL (*) INPUT GRID U-WINDS
GRIDVI - REAL (*) INPUT GRID V-WINDS
LUV - LOGICAL FLAG WHETHER TO RETURN WINDS
LDZ - LOGICAL FLAG WHETHER TO RETURN DIVERGENCE AND VORTICITY
LPS - LOGICAL FLAG WHETHER TO RETURN POTENTIAL AND STREAMFCN
Output arguments:
UN - REAL (*) NORTHERN PS U-WINDS IF LUV
VN - REAL (*) NORTHERN PS V-WINDS IF LUV
US - REAL (*) SOUTHERN PS U-WINDS IF LUV
VS - REAL (*) SOUTHERN PS V-WINDS IF LUV
DN - REAL (*) NORTHERN DIVERGENCES IF LDZ
ZN - REAL (*) NORTHERN VORTICITIES IF LDZ
DS - REAL (*) SOUTHERN DIVERGENCES IF LDZ
ZS - REAL (*) SOUTHERN VORTICITIES IF LDZ
PN - REAL (*) NORTHERN POTENTIALS IF LPS
SN - REAL (*) NORTHERN STREAMFCNS IF LPS
PS - REAL (*) SOUTHERN POTENTIALS IF LPS
SS - REAL (*) SOUTHERN STREAMFCNS IF LPS
REMARKS:
MINIMUM GRID DIMENSIONS FOR UNALIASED TRANSFORMS TO SPECTRAL:
DIMENSION LINEAR QUADRATIC
----------------------- --------- -------------
IMAX 2*MAXWV+2 3*MAXWV/2*2+2
JMAX (IDRT=4,IROMB=0) 1*MAXWV+1 3*MAXWV/2+1
JMAX (IDRT=4,IROMB=1) 2*MAXWV+1 5*MAXWV/2+1
JMAX (IDRT=0,IROMB=0) 2*MAXWV+3 3*MAXWV/2*2+3
JMAX (IDRT=0,IROMB=1) 4*MAXWV+3 5*MAXWV/2*2+3
JMAX (IDRT=256,IROMB=0) 2*MAXWV+1 3*MAXWV/2*2+1
JMAX (IDRT=256,IROMB=1) 4*MAXWV+1 5*MAXWV/2*2+1
SPTRUNV
The SPTRUNV routine spectrally truncates vector fields
on a global cylindrical grid, returning the fields
to a possibly different global cylindrical grid.
The wave-space can be either Triangular or Rhomboidal.
either grid-space can be either an equally-spaced grid
(with or without pole points) or a Gaussian grid.
The grid fields may have general indexing.
The transforms are all multiprocessed.
over zonal wavenumber to ensure reproducibility.
Transform several fields at a time to improve vectorization.
Subprogram can be called from a multiprocessing environment.
USAGE: CALL SPTRUNV(IROMB,MAXWV,IDRTI,IMAXI,JMAXI,
IDRTO,IMAXO,JMAXO,KMAX,
IPRIME,ISKIPI,JSKIPI,KSKIPI,
ISKIPO,JSKIPO,KSKIPO,JCPU,GRIDUI,GRIDVI,
LUV,GRIDUO,GRIDVO,LDZ,GRIDDO,GRIDZO,
LPS,GRIDPO,GRIDSO)
Input arguments:
IROMB - INTEGER SPECTRAL DOMAIN SHAPE
(0 FOR TRIANGULAR, 1 FOR RHOMBOIDAL)
MAXWV - INTEGER SPECTRAL TRUNCATION
IDRTI - INTEGER INPUT GRID IDENTIFIER
(IDRTI=4 FOR GAUSSIAN GRID,
IDRTI=0 FOR EQUALLY-SPACED GRID INCLUDING POLES,
IDRTI=256 FOR EQUALLY-SPACED GRID EXCLUDING POLES)
IMAXI - INTEGER EVEN NUMBER OF INPUT LONGITUDES.
JMAXI - INTEGER NUMBER OF INPUT LATITUDES.
IDRTO - INTEGER OUTPUT GRID IDENTIFIER
(IDRTO=4 FOR GAUSSIAN GRID,
IDRTO=0 FOR EQUALLY-SPACED GRID INCLUDING POLES,
IDRTO=256 FOR EQUALLY-SPACED GRID EXCLUDING POLES)
IMAXO - INTEGER EVEN NUMBER OF OUTPUT LONGITUDES.
JMAXO - INTEGER NUMBER OF OUTPUT LATITUDES.
KMAX - INTEGER NUMBER OF FIELDS TO TRANSFORM.
IPRIME - INTEGER INPUT LONGITUDE INDEX FOR THE PRIME MERIDIAN.
(DEFAULTS TO 1 IF IPRIME=0)
(OUTPUT LONGITUDE INDEX FOR PRIME MERIDIAN ASSUMED 1.)
ISKIPI - INTEGER SKIP NUMBER BETWEEN INPUT LONGITUDES
(DEFAULTS TO 1 IF ISKIPI=0)
JSKIPI - INTEGER SKIP NUMBER BETWEEN INPUT LATITUDES FROM SOUTH
(DEFAULTS TO -IMAXI IF JSKIPI=0)
KSKIPI - INTEGER SKIP NUMBER BETWEEN INPUT GRID FIELDS
(DEFAULTS TO IMAXI*JMAXI IF KSKIPI=0)
ISKIPO - INTEGER SKIP NUMBER BETWEEN OUTPUT LONGITUDES
(DEFAULTS TO 1 IF ISKIPO=0)
JSKIPO - INTEGER SKIP NUMBER BETWEEN OUTPUT LATITUDES FROM SOUTH
(DEFAULTS TO -IMAXO IF JSKIPO=0)
KSKIPO - INTEGER SKIP NUMBER BETWEEN OUTPUT GRID FIELDS
(DEFAULTS TO IMAXO*JMAXO IF KSKIPO=0)
JCPU - INTEGER NUMBER OF CPUS OVER WHICH TO MULTIPROCESS
(DEFAULTS TO ENVIRONMENT NCPUS IF JCPU=0)
GRIDUI - REAL (*) INPUT GRID U-WINDS
GRIDVI - REAL (*) INPUT GRID V-WINDS
LUV - LOGICAL FLAG WHETHER TO RETURN WINDS
LDZ - LOGICAL FLAG WHETHER TO RETURN DIVERGENCE AND VORTICITY
LPS - LOGICAL FLAG WHETHER TO RETURN POTENTIAL AND STREAMFCN
Output arguments:
GRIDUO - REAL (*) OUTPUT U-WINDS IF LUV
(MAY OVERLAY INPUT FIELDS IF GRID SHAPE IS APPROPRIATE)
GRIDVO - REAL (*) OUTPUT V-WINDS IF LUV
(MAY OVERLAY INPUT FIELDS IF GRID SHAPE IS APPROPRIATE)
GRIDDO - REAL (*) OUTPUT DIVERGENCES IF LDZ
(MAY OVERLAY INPUT FIELDS IF GRID SHAPE IS APPROPRIATE)
GRIDZO - REAL (*) OUTPUT VORTICITIES IF LDZ
(MAY OVERLAY INPUT FIELDS IF GRID SHAPE IS APPROPRIATE)
GRIDPO - REAL (*) OUTPUT POTENTIALS IF LPS
(MAY OVERLAY INPUT FIELDS IF GRID SHAPE IS APPROPRIATE)
GRIDSO - REAL (*) OUTPUT STREAMFCNS IF LPS
(MAY OVERLAY INPUT FIELDS IF GRID SHAPE IS APPROPRIATE)
REMARKS:
MINIMUM GRID DIMENSIONS FOR UNALIASED TRANSFORMS TO SPECTRAL:
DIMENSION LINEAR QUADRATIC
----------------------- --------- -------------
IMAX 2*MAXWV+2 3*MAXWV/2*2+2
JMAX (IDRT=4,IROMB=0) 1*MAXWV+1 3*MAXWV/2+1
JMAX (IDRT=4,IROMB=1) 2*MAXWV+1 5*MAXWV/2+1
JMAX (IDRT=0,IROMB=0) 2*MAXWV+3 3*MAXWV/2*2+3
JMAX (IDRT=0,IROMB=1) 4*MAXWV+3 5*MAXWV/2*2+3
JMAX (IDRT=256,IROMB=0) 2*MAXWV+1 3*MAXWV/2*2+1
JMAX (IDRT=256,IROMB=1) 4*MAXWV+1 5*MAXWV/2*2+1
SPUV2DZ
The SPUV2DZ routine computes the divergence and vorticity from
wind components in spectral space.
Subprogram SPEPS should be called already.
If l is the zonal wavenumber, n is the total wavenumber,
eps(l,n)=sqrt((n**2-l**2)/(4*n**2-1)) and a is earth radius,
then the divergence d is computed as
d(l,n)=i*l*a*u(l,n)
+eps(l,n+1)*n*a*v(l,n+1)-eps(l,n)*(n+1)*a*v(l,n-1)
and the vorticity z is computed as
z(l,n)=i*l*a*v(l,n)
-eps(l,n+1)*n*a*u(l,n+1)+eps(l,n)*(n+1)*a*u(l,n-1)
where u is the zonal wind and v is the meridional wind.
u and v are weighted by the secant of latitude.
Extra terms are used over top of the spectral domain.
Advantage is taken of the fact that eps(l,l)=0
in order to vectorize over the entire spectraL domain.
USAGE: CALL SPUV2DZ(I,M,ENN1,ELONN1,EON,EONTOP,U,V,UTOP,VTOP,D,Z)
Input argument list:
I - INTEGER SPECTRAL DOMAIN SHAPE
(0 FOR TRIANGULAR, 1 FOR RHOMBOIDAL)
M - INTEGER SPECTRAL TRUNCATION
ENN1 - REAL ((M+1)*((I+1)*M+2)/2) N*(N+1)/A**2
ELONN1 - REAL ((M+1)*((I+1)*M+2)/2) L/(N*(N+1))*A
EON - REAL ((M+1)*((I+1)*M+2)/2) EPSILON/N*A
EONTOP - REAL (M+1) EPSILON/N*A OVER TOP
U - REAL ((M+1)*((I+1)*M+2)) ZONAL WIND (OVER COSLAT)
V - REAL ((M+1)*((I+1)*M+2)) MERID WIND (OVER COSLAT)
UTOP - REAL (2*(M+1)) ZONAL WIND (OVER COSLAT) OVER TOP
VTOP - REAL (2*(M+1)) MERID WIND (OVER COSLAT) OVER TOP
Output argument list:
D - REAL ((M+1)*((I+1)*M+2)) DIVERGENCE
Z - REAL ((M+1)*((I+1)*M+2)) VORTICITY
SPVAR
The SPVAR routine computes the variances by total
wavenumber of a scalar field in spectral space.
USAGE: CALL SPVAR(I,M,Q,QVAR)
Input argument list:
I - INTEGER SPECTRAL DOMAIN SHAPE
(0 FOR TRIANGULAR, 1 FOR RHOMBOIDAL)
M - INTEGER SPECTRAL TRUNCATION
Q - REAL ((M+1)*((I+1)*M+2)) SCALAR FIELD
Output argument list:
QVAR - REAL (0:(I+1)*M) VARIANCES
SPWGET
The SPWGET routine gets wave-space constants.
USAGE: CALL SPWGET(IROMB,MAXWV,EPS,EPSTOP,ENN1,ELONN1,EON,EONTOP)
Input arguments:
IROMB - INTEGER SPECTRAL DOMAIN SHAPE
(0 FOR TRIANGULAR, 1 FOR RHOMBOIDAL)
MAXWV - INTEGER SPECTRAL TRUNCATION
Output arguments:
EPS - REAL ((MAXWV+1)*((IROMB+1)*MAXWV+2)/2)
EPSTOP - REAL (MAXWV+1)
ENN1 - REAL ((MAXWV+1)*((IROMB+1)*MAXWV+2)/2)
ELONN1 - REAL ((MAXWV+1)*((IROMB+1)*MAXWV+2)/2)
EON - REAL ((MAXWV+1)*((IROMB+1)*MAXWV+2)/2)
EONTOP - REAL (MAXWV+1)
| SPLIB.tar |
Library contains routines to be
be used for a variety of spectral transform functions. (Fortran90)
Date posted: 9/05/2012 |