Context Navigation

← Previous Revision
Latest Revision
Next Revision →
Normal
Revision Log

wrf_SST_ESMF.F @ 3567

Last change on this file since 3567 was 2759, checked in by aslmd, 2 years ago
adding unmodified code from WRFV3.0.1.1, expurged from useless data +1M size
File size: 82.3 KB

Rev	Line
[2759]	1	!WRF:DRIVER_LAYER:MAIN
	2	!
	3
	4	!<DESCRIPTION>
	5	! ESMF Application Wrapper for coupling WRF with a "dummy" component
	6	! that simply reads SSTs from a file, sends to WRF, receives SST from
	7	! WRF (two-way coupling). and checks that the SSTs match.
	8	!
	9	! This file contains the main program and associated modules for the
	10	! SST "dummy" component and a simple coupler. It creates ESMF Gridded
	11	! and Coupler Components.
	12	!
	13	! This source file is only built when ESMF coupling is used.
	14	!
	15	!</DESCRIPTION>
	16
	17
	18
	19	!<DESCRIPTION>
	20	! Modules module_sst_component_top and module_sst_setservices define the
	21	! "SST" dummy component.
	22	!</DESCRIPTION>
	23
	24	MODULE module_sst_component_top
	25	!<DESCRIPTION>
	26	! This module defines sst_component_init1(), sst_component_init2(),
	27	! sst_component_run1(), sst_component_run2(), and sst_component_finalize()
	28	! routines that are called when SST is run as an ESMF component.
	29	!</DESCRIPTION>
	30
	31	USE ESMF_Mod
	32	USE module_esmf_extensions
	33	USE module_metadatautils, ONLY: AttachTimesToState
	34
	35
	36	IMPLICIT NONE
	37
	38	! everything is private by default
	39	PRIVATE
	40
	41	! Public entry points
	42	PUBLIC sst_component_init1
	43	PUBLIC sst_component_init2
	44	PUBLIC sst_component_run1
	45	PUBLIC sst_component_run2
	46	PUBLIC sst_component_finalize
	47
	48	! private stuff
	49	TYPE(ESMF_Grid), SAVE :: esmfgrid ! grid used in fields
	50	CHARACTER (4096) :: str
	51	INTEGER, SAVE :: fid ! file handle
	52	! decomposition information
	53	INTEGER, SAVE :: ids, ide, jds, jde, kds, kde
	54	INTEGER, SAVE :: ims, ime, jms, jme, kms, kme
	55	INTEGER, SAVE :: ips, ipe, jps, jpe, kps, kpe
	56	REAL(ESMF_KIND_R4), POINTER, SAVE :: tmp_data_out_sst(:,:)
	57	REAL(ESMF_KIND_R4), POINTER, SAVE :: tmp_data_out_landmask(:,:)
	58	REAL(ESMF_KIND_R4), POINTER, SAVE :: tmp_data_in_sst(:,:)
	59	REAL(ESMF_KIND_R4), POINTER, SAVE :: tmp_data_in_landmask(:,:)
	60	INTEGER, SAVE :: domdesc
	61	LOGICAL, SAVE :: bdy_mask(4)
	62	! MPI communicator, if needed
	63	INTEGER, SAVE :: mpicom
	64	! field data
	65	REAL, POINTER, SAVE :: file_landmask_data(:,:), file_sst_data(:,:)
	66	! input data file name
	67	CHARACTER ( ESMF_MAXSTR ), SAVE :: sstinfilename
	68	! field names
	69	INTEGER, PARAMETER :: datacount = 2
	70	INTEGER, PARAMETER :: SST_INDX = 1
	71	INTEGER, PARAMETER :: LANDMASK_INDX = 2
	72	CHARACTER(LEN=ESMF_MAXSTR), SAVE :: datanames(datacount)
	73	TYPE real2d
	74	REAL, POINTER :: r2d(:,:)
	75	END TYPE real2d
	76	TYPE(real2d) :: this_data(datacount)
	77
	78
	79	CONTAINS
	80
	81
	82
	83	! First-phase "init" reads "SST" data file and returns "time" metadata in
	84	! exportState.
	85	SUBROUTINE sst_component_init1( gcomp, importState, exportState, clock, rc )
	86	USE module_io
	87	TYPE(ESMF_GridComp), TARGET, INTENT(INOUT) :: gcomp
	88	TYPE(ESMF_State), TARGET, INTENT(INOUT) :: importState
	89	TYPE(ESMF_State), TARGET, INTENT(INOUT) :: exportState
	90	TYPE(ESMF_Clock), TARGET, INTENT(INOUT) :: clock
	91	INTEGER, INTENT( OUT) :: rc
	92	!<DESCRIPTION>
	93	! SST component init routine, phase 1.
	94	!
	95	! The arguments are:
	96	! gcomp Component
	97	! importState Importstate
	98	! exportState Exportstate
	99	! clock External clock
	100	! rc Return code; equals ESMF_SUCCESS if there are no errors,
	101	! otherwise ESMF_FAILURE.
	102	!</DESCRIPTION>
	103
	104	#ifdef DM_PARALLEL
	105	INCLUDE 'mpif.h'
	106	#endif
	107
	108	! Local variables
	109	CHARACTER (LEN=19) :: date_string
	110	#ifdef DM_PARALLEL
	111	TYPE(ESMF_VM) :: vm
	112	INTEGER :: mpicomtmp
	113	#endif
	114	TYPE(ESMF_Time) :: startTime, stopTime, currentTime, dataTime
	115	TYPE(ESMF_TimeInterval) :: timeStep
	116	INTEGER :: ierr, num_steps, time_loop_max
	117	INTEGER :: status_next_var
	118
	119	!TODO: For now, sstinfilename is hard-coded
	120	!TODO: Upgrade to use a variant of construct_filename() via startTime
	121	!TODO: extracted from clock.
	122	sstinfilename = 'sstin_d01_000000'
	123
	124	! get MPI communicator out of current VM and duplicate (if needed)
	125	#ifdef DM_PARALLEL
	126	CALL ESMF_VMGetCurrent(vm, rc=rc)
	127	IF ( rc /= ESMF_SUCCESS ) THEN
	128	CALL wrf_error_fatal ( 'sst_component_init1: ESMF_VMGetCurrent failed' )
	129	ENDIF
	130	CALL ESMF_VMGet(vm, mpiCommunicator=mpicomtmp, rc=rc)
	131	IF ( rc /= ESMF_SUCCESS ) THEN
	132	CALL wrf_error_fatal ( 'sst_component_init1: ESMF_VMGet failed' )
	133	ENDIF
	134	CALL MPI_Comm_dup( mpicomtmp, mpicom, ierr )
	135	#else
	136	mpicom = 0
	137	#endif
	138	! Open the "SST" input data file for reading.
	139	write(str,'(A,A)') 'Subroutine sst_component_init1: Opening data file ', &
	140	TRIM(sstinfilename)
	141	CALL wrf_message ( TRIM(str) )
	142	CALL wrf_open_for_read ( TRIM(sstinfilename) , &
	143	mpicom , &
	144	mpicom , &
	145	"DATASET=INPUT" , &
	146	fid , &
	147	ierr )
	148	IF ( ierr .NE. 0 ) THEN
	149	WRITE( str , FMT='(A,A,A,I8)' ) &
	150	'subroutine sst_component_init1: error opening ', &
	151	TRIM(sstinfilename),' for reading ierr=',ierr
	152	CALL wrf_error_fatal ( TRIM(str) )
	153	ENDIF
	154	WRITE( str , FMT='(A,A,A,I8)' ) &
	155	'subroutine sst_component_init1: opened file ', &
	156	TRIM(sstinfilename),' for reading fid=',fid
	157	CALL wrf_debug ( 100, TRIM(str) )
	158
	159	! How many data time levels are in the SST input file?
	160	num_steps = -1
	161	time_loop_max = 0
	162	CALL wrf_debug ( 100, 'subroutine sst_component_init1: find time_loop_max' )
	163	! compute SST start time, time step, and end time here
	164	get_the_right_time : DO
	165	CALL wrf_get_next_time ( fid, date_string, status_next_var )
	166	write(str,'(A,A)') 'Subroutine sst_component_init1: SST data startTime: ', &
	167	date_string
	168	CALL wrf_debug ( 100 , TRIM(str) )
	169	IF ( status_next_var == 0 ) THEN
	170	IF ( time_loop_max == 0 ) THEN
	171	CALL wrf_atotime( date_string, startTime )
	172	ELSEIF ( time_loop_max == 1 ) THEN
	173	! assumes fixed time step!
	174	CALL wrf_atotime( date_string, dataTime )
	175	timeStep = dataTime - startTime
	176	ENDIF
	177	time_loop_max = time_loop_max + 1
	178	CALL wrf_atotime( date_string, stopTime )
	179	ELSE
	180	EXIT get_the_right_time
	181	ENDIF
	182	END DO get_the_right_time
	183	CALL wrf_timetoa ( stopTime, date_string )
	184	write(str,'(A,A)') 'Subroutine sst_component_init1: SST data stopTime: ', &
	185	date_string
	186	CALL wrf_debug ( 100 , TRIM(str) )
	187	! attach times to exportState for use by driver
	188	CALL AttachTimesToState( exportState, startTime, stopTime, timeStep )
	189
	190	! There should be a more elegant way to get to the beginning of the
	191	! file, but this will do.
	192	CALL wrf_ioclose( fid , ierr )
	193	IF ( ierr .NE. 0 ) THEN
	194	CALL wrf_error_fatal ( 'sst_component_init1: wrf_ioclose failed' )
	195	ENDIF
	196	WRITE( str , FMT='(A,I8)' ) &
	197	'subroutine sst_component_init1: closed file fid=',fid
	198	CALL wrf_debug ( 100, TRIM(str) )
	199
	200	! set up field names
	201	!TODO: use CF conventions for "standard_name" once WRF Registry supports them
	202	!TODO: datanames(SST_INDX) = "sea_surface_temperature"
	203	!TODO: datanames(LANDMASK_INDX) = "land_binary_mask"
	204	datanames(SST_INDX) = "SST"
	205	datanames(LANDMASK_INDX) = "LANDMASK"
	206
	207	rc = ESMF_SUCCESS
	208
	209	END SUBROUTINE sst_component_init1
	210
	211
	212
	213	SUBROUTINE read_data( exportState, clock )
	214	USE module_io
	215	TYPE(ESMF_State), INTENT(INOUT) :: exportState
	216	TYPE(ESMF_Clock), INTENT(IN ) :: clock
	217	!<DESCRIPTION>
	218	! Reads data from file and stores. Then
	219	! stuffs the file data into the SST exportState.
	220	!</DESCRIPTION>
	221
	222	#include <wrf_status_codes.h>
	223	#include <wrf_io_flags.h>
	224
	225	! Local variables
	226	CHARACTER (LEN=19) :: date_string
	227	TYPE(ESMF_Time) :: currentTime, dataTime
	228	REAL(ESMF_KIND_R4), POINTER :: out_sst_ptr(:,:), out_landmask_ptr(:,:)
	229	TYPE(ESMF_Field) :: out_sst_field, out_landmask_field
	230	TYPE(ESMF_Field) :: in_sst_field, in_landmask_field
	231	INTEGER :: i, j
	232	CHARACTER(LEN=ESMF_MAXSTR) :: fieldname, debugmsg, errormsg, timestr
	233	INTEGER :: ierr
	234	INTEGER :: rc
	235
	236	! This call to wrf_get_next_time will position the dataset over the next
	237	! time-frame in the file and return the date_string, which is used as an
	238	! argument to the read_field routines in the blocks of code included
	239	! below.
	240
	241	CALL wrf_get_next_time( fid, date_string , ierr )
	242	WRITE(str,'(A,A)') 'Subroutine read_data: SST data time: ', &
	243	date_string
	244	CALL wrf_debug ( 100 , TRIM(str) )
	245	IF ( ierr .NE. 0 .AND. ierr .NE. WRF_WARN_NOTSUPPORTED .AND. &
	246	ierr .NE. WRF_WARN_DRYRUN_READ ) THEN
	247	CALL wrf_error_fatal ( "... May have run out of valid SST data ..." )
	248	ELSE IF ( ierr .NE. WRF_WARN_NOTSUPPORTED .AND. &
	249	ierr .NE. WRF_WARN_DRYRUN_READ) THEN
	250	! check input time against current time (which will be start time at
	251	! beginning)
	252	CALL wrf_atotime( date_string, dataTime )
	253	CALL ESMF_ClockGet( clock, CurrTime=currentTime, rc=rc )
	254	IF (rc /= ESMF_SUCCESS) THEN
	255	CALL wrf_error_fatal ( 'read_data: ESMF_ClockGet() failed' )
	256	ENDIF
	257	CALL wrf_clockprint(150, clock, &
	258	'DEBUG read_data(): get currentTime from clock,')
	259	IF ( dataTime .NE. currentTime ) THEN
	260	CALL wrf_timetoa ( dataTime, timestr )
	261	WRITE( errormsg , * )'Time in file: ',trim( timestr )
	262	CALL wrf_message ( trim(errormsg) )
	263	CALL wrf_timetoa ( currentTime, timestr )
	264	WRITE( errormsg , * )'Time on domain: ',trim( timestr )
	265	CALL wrf_message ( trim(errormsg) )
	266	CALL wrf_error_fatal( &
	267	"ERROR Time in input file not equal to time on domain ERROR" )
	268	ENDIF
	269	ENDIF
	270
	271	! doing this in a loop only works if staggering is the same for all fields
	272	this_data(SST_INDX)%r2d => file_sst_data
	273	this_data(LANDMASK_INDX)%r2d => file_landmask_data
	274	DO i=1, datacount
	275	fieldname = TRIM(datanames(i))
	276	debugmsg = 'ext_read_field '//TRIM(fieldname)//' memorder XY'
	277	errormsg = 'could not read '//TRIM(fieldname)//' data from file'
	278	CALL wrf_ext_read_field ( &
	279	fid , & ! DataHandle
	280	date_string , & ! DateStr
	281	TRIM(fieldname) , & ! Data Name
	282	this_data(i)%r2d , & ! Field
	283	WRF_REAL , & ! FieldType
	284	mpicom , & ! Comm
	285	mpicom , & ! I/O Comm
	286	domdesc , & ! Domain descriptor
	287	bdy_mask , & ! bdy_mask
	288	'XY' , & ! MemoryOrder
	289	'' , & ! Stagger
	290	TRIM(debugmsg) , & ! Debug message
	291	! ids , (ide-1) , jds , (jde-1) , 1 , 1 , &
	292	! ims , ime , jms , jme , 1 , 1 , &
	293	! ips , MIN( (ide-1), ipe ) , jps , MIN( (jde-1), jpe ) , 1 , 1 , &
	294	!jm the dimensions have already been reduced to the non-staggered WRF grid when
	295	! they were stored in this module.. Just use as is.
	296	ids , ide , jds , jde , 1 , 1 , &
	297	ims , ime , jms , jme , 1 , 1 , &
	298	ips , ipe , jps , jpe , 1 , 1 , &
	299	ierr )
	300	IF (ierr /= 0) THEN
	301	CALL wrf_error_fatal ( TRIM(errormsg) )
	302	ENDIF
	303	ENDDO
	304
	305	! stuff fields into exportState
	306	!TODO: change this to Bundles, eventually
	307	CALL ESMF_StateGet( exportState, TRIM(datanames(SST_INDX)), &
	308	out_sst_field, rc=rc )
	309	IF (rc /= ESMF_SUCCESS) THEN
	310	CALL wrf_error_fatal ( &
	311	'could not find sea_surface_temperature field in exportState' )
	312	ENDIF
	313	CALL ESMF_StateGet( exportState, TRIM(datanames(LANDMASK_INDX)), &
	314	out_landmask_field, rc=rc )
	315	IF (rc /= ESMF_SUCCESS) THEN
	316	CALL wrf_error_fatal ( &
	317	'could not find land_binary_mask field in exportState' )
	318	ENDIF
	319	! CALL ESMF_FieldGetDataPointer( out_sst_field, out_sst_ptr, rc=rc )
	320	CALL ESMF_FieldGet( out_sst_field, 0, out_sst_ptr, rc=rc )
	321	IF (rc /= ESMF_SUCCESS) THEN
	322	CALL wrf_error_fatal ( &
	323	'could not find sea_surface_temperature data in sea_surface_temperature field' )
	324	ENDIF
	325	! CALL ESMF_FieldGetDataPointer( out_landmask_field, out_landmask_ptr, rc=rc )
	326	CALL ESMF_FieldGet( out_landmask_field, 0, out_landmask_ptr, rc=rc )
	327	IF (rc /= ESMF_SUCCESS) THEN
	328	CALL wrf_error_fatal ( &
	329	'could not find land_binary_mask data in land_binary_mask field' )
	330	ENDIF
	331	! staggered starts/ends
	332	DO j= jps , jpe
	333	DO i= ips , ipe
	334	out_sst_ptr(i,j) = file_sst_data(i,j)
	335	out_landmask_ptr(i,j) = file_landmask_data(i,j)
	336	ENDDO
	337	ENDDO
	338
	339	END SUBROUTINE read_data
	340
	341
	342
	343
	344	SUBROUTINE compare_data( importState, clock )
	345	TYPE(ESMF_State), INTENT(INOUT) :: importState
	346	!TODO: remove clock after debugging is finished
	347	TYPE(ESMF_Clock), INTENT(INOUT) :: clock
	348	!<DESCRIPTION>
	349	! Gets data from coupler via importState
	350	! and compares with data read from file and
	351	! error-exits if they differ.
	352	!
	353	! The arguments are:
	354	! importState Importstate
	355	!</DESCRIPTION>
	356
	357	! Local variables
	358	TYPE(ESMF_Field) :: in_sst_field, in_landmask_field
	359	REAL(ESMF_KIND_R4), POINTER :: in_sst_ptr(:,:), in_landmask_ptr(:,:)
	360	REAL, POINTER :: in_sst_ptr_real(:,:), in_landmask_ptr_real(:,:)
	361	INTEGER :: i, j
	362	INTEGER :: rc
	363	LOGICAL :: landmask_ok, sst_ok
	364	! use these for debug prints
	365	TYPE(ESMF_Time) :: currentTime
	366	INTEGER, SAVE :: numtimes=0 ! track number of calls
	367	CHARACTER(LEN=256) :: timestamp
	368
	369	! count calls for debug prints...
	370	CALL ESMF_ClockGet( clock, CurrTime=currentTime, rc=rc )
	371	IF (rc /= ESMF_SUCCESS) THEN
	372	CALL wrf_error_fatal ( 'compare_data: ESMF_ClockGet() failed' )
	373	ENDIF
	374	CALL wrf_timetoa ( currentTime, timestamp )
	375	numtimes = numtimes + 1
	376	WRITE(str,*) 'SST compare_data: begin, numtimes = ',numtimes,' time = ',TRIM(timestamp)
	377	CALL wrf_debug ( 100 , TRIM(str) )
	378
	379	! extract data from the importState and compare with data from file
	380	!TODO: change this to Bundles, eventually
	381	CALL ESMF_StateGet( importState, TRIM(datanames(SST_INDX)), &
	382	in_sst_field, rc=rc )
	383	IF (rc /= ESMF_SUCCESS) THEN
	384	CALL wrf_error_fatal ( &
	385	'could not extract sea_surface_temperature field from importState' )
	386	ENDIF
	387	CALL ESMF_StateGet( importState, TRIM(datanames(LANDMASK_INDX)), &
	388	in_landmask_field, rc=rc )
	389	IF (rc /= ESMF_SUCCESS) THEN
	390	CALL wrf_error_fatal ( &
	391	'could not extract land_binary_mask field from importState' )
	392	ENDIF
	393	! CALL ESMF_FieldGetDataPointer( in_sst_field, in_sst_ptr, rc=rc )
	394	CALL ESMF_FieldGet( in_sst_field, 0, in_sst_ptr, rc=rc )
	395	IF (rc /= ESMF_SUCCESS) THEN
	396	CALL wrf_error_fatal ( &
	397	'could not extract sea_surface_temperature data from sea_surface_temperature field' )
	398	ENDIF
	399	ALLOCATE( in_sst_ptr_real(ims:ime,jms:jme) )
	400	WRITE( str,* ) 'compare_data, ips:ipe,jps:jpe = ', &
	401	ips,':',ipe,',',jps,':',jpe, &
	402	', in_sst_ptr(BOUNDS) = ', &
	403	LBOUND(in_sst_ptr,1),':',UBOUND(in_sst_ptr,1),',', &
	404	LBOUND(in_sst_ptr,2),':',UBOUND(in_sst_ptr,2)
	405	CALL wrf_debug ( 100 , TRIM(str) )
	406	DO j= jms, jme
	407	DO i= ims, ime
	408	in_sst_ptr_real(i,j) = -(i*1000.0 + j)/100000.0 ! obvious bad value for debugging
	409	ENDDO
	410	ENDDO
	411	in_sst_ptr_real(ips:MIN((ide-1),ipe),jps:MIN((jde-1),jpe)) = &
	412	in_sst_ptr(ips:MIN((ide-1),ipe),jps:MIN((jde-1),jpe))
	413	! CALL ESMF_FieldGetDataPointer( in_landmask_field, in_landmask_ptr, rc=rc )
	414	CALL ESMF_FieldGet( in_landmask_field, 0, in_landmask_ptr, rc=rc )
	415	IF (rc /= ESMF_SUCCESS) THEN
	416	CALL wrf_error_fatal ( &
	417	'could not extract land_binary_mask data from land_binary_mask field' )
	418	ENDIF
	419	ALLOCATE( in_landmask_ptr_real(ims:ime,jms:jme) )
	420	WRITE( str,* ) 'compare_data, ips:ipe,jps:jpe = ', &
	421	ips,':',ipe,',',jps,':',jpe, &
	422	', in_landmask_ptr(BOUNDS) = ', &
	423	LBOUND(in_landmask_ptr,1),':',UBOUND(in_landmask_ptr,1),',', &
	424	LBOUND(in_landmask_ptr,2),':',UBOUND(in_landmask_ptr,2)
	425	CALL wrf_debug ( 100 , TRIM(str) )
	426	DO j= jms, jme
	427	DO i= ims, ime
	428	in_landmask_ptr_real(i,j) = -(i*1000.0 + j)/100000.0 ! obvious bad value for debugging
	429	ENDDO
	430	ENDDO
	431	in_landmask_ptr_real(ips:MIN((ide-1),ipe),jps:MIN((jde-1),jpe)) = &
	432	in_landmask_ptr(ips:MIN((ide-1),ipe),jps:MIN((jde-1),jpe))
	433
	434	! compare LANDMASK...
	435	landmask_ok = .TRUE.
	436	! staggered starts/ends
	437	LANDMASK_COMPARE : DO j= jps , MIN( (jde-1), jpe )
	438	DO i= ips , MIN( (ide-1), ipe )
	439	IF ( file_landmask_data(i,j) /= in_landmask_ptr_real(i,j) ) THEN
	440	landmask_ok = .FALSE.
	441	WRITE( str , * ) 'error landmask mismatch at (i,j) = (',i,',',j, &
	442	'), values are',file_landmask_data(i,j),' and ', &
	443	in_landmask_ptr_real(i,j)
	444	EXIT LANDMASK_COMPARE
	445	ENDIF
	446	ENDDO
	447	ENDDO LANDMASK_COMPARE
	448	IF ( landmask_ok ) THEN
	449	WRITE(str,*) 'compare_data: LANDMASK compares OK'
	450	CALL wrf_debug ( 100 , TRIM(str) )
	451	ELSE
	452	CALL wrf_error_fatal ( TRIM(str) )
	453	ENDIF
	454
	455	! compare SST...
	456	sst_ok = .TRUE.
	457	! staggered starts/ends
	458	SST_COMPARE : DO j= jps , MIN( (jde-1), jpe )
	459	DO i= ips , MIN( (ide-1), ipe )
	460	IF ( file_sst_data(i,j) /= in_sst_ptr_real(i,j) ) THEN
	461	sst_ok = .FALSE.
	462	WRITE( str , * ) 'error sst mismatch at (i,j) = (',i,',',j, &
	463	'), values are',file_sst_data(i,j),' and ', &
	464	in_sst_ptr_real(i,j)
	465	EXIT SST_COMPARE
	466	ENDIF
	467	ENDDO
	468	ENDDO SST_COMPARE
	469	IF ( sst_ok ) THEN
	470	WRITE(str,*) 'compare_data: SST compares OK'
	471	CALL wrf_debug ( 100 , TRIM(str) )
	472	ELSE
	473	CALL wrf_error_fatal ( TRIM(str) )
	474	ENDIF
	475
	476	DEALLOCATE( in_sst_ptr_real, in_landmask_ptr_real )
	477
	478	WRITE(str,*) 'compare_data: end, numtimes = ',numtimes
	479	CALL wrf_debug ( 100 , TRIM(str) )
	480
	481	END SUBROUTINE compare_data
	482
	483	! Second-phase "init" gets decomposition information from
	484	! importState.
	485	SUBROUTINE sst_component_init2( gcomp, importState, exportState, clock, rc )
	486	USE module_metadatautils, ONLY: GetDecompFromState
	487	USE module_io
	488	TYPE(ESMF_GridComp), TARGET, INTENT(INOUT) :: gcomp
	489	TYPE(ESMF_State), TARGET, INTENT(INOUT) :: importState
	490	TYPE(ESMF_State), TARGET, INTENT(INOUT) :: exportState
	491	TYPE(ESMF_Clock), TARGET, INTENT(INOUT) :: clock
	492	INTEGER, INTENT( OUT) :: rc
	493	!<DESCRIPTION>
	494	! SST component init routine, phase 2.
	495	!
	496	! The arguments are:
	497	! gcomp Component
	498	! importState Importstate
	499	! exportState Exportstate
	500	! clock External clock
	501	! rc Return code; equals ESMF_SUCCESS if there are no errors,
	502	! otherwise ESMF_FAILURE.
	503	!</DESCRIPTION>
	504
	505	! Local variables
	506	TYPE(ESMF_Field) :: out_sst_field, out_landmask_field
	507	TYPE(ESMF_Field) :: in_sst_field, in_landmask_field
	508	INTEGER, PARAMETER :: NUMDIMS=2
	509	INTEGER :: DomainStart(NUMDIMS)
	510	INTEGER :: DomainEnd(NUMDIMS)
	511	INTEGER :: MemoryStart(NUMDIMS)
	512	INTEGER :: MemoryEnd(NUMDIMS)
	513	INTEGER :: PatchStart(NUMDIMS)
	514	INTEGER :: PatchEnd(NUMDIMS)
	515	INTEGER :: rc, i, j
	516	INTEGER :: ierr
	517
	518	! Get decomposition information from importState. Note that index
	519	! values are for staggered dimensions, following the WRF convention.
	520	!TODO: Note that this will only work for SPMD serial operation. For
	521	!TODO: concurrent operation (SPMD or MPMD), we will need to create a new
	522	!TODO: "domdesc" suitable for the task layout of the SST component. For
	523	!TODO: MPMD serial operation, we will need to extract serialized domdesc
	524	!TODO: from export state metadata and de-serialize it. Similar arguments
	525	!TODO: apply to [ij][mp][se] and bdy_mask.
	526	write(0,*)__FILE__,__LINE__,'entered sst_component_init2 '
	527	write(str,*) 'sst_component_init2: calling GetDecompFromState'
	528	CALL wrf_debug ( 100 , TRIM(str) )
	529	CALL GetDecompFromState( importState, &
	530	ids, ide, jds, jde, kds, kde, &
	531	ims, ime, jms, jme, kms, kme, &
	532	ips, ipe, jps, jpe, kps, kpe, &
	533	domdesc, bdy_mask )
	534	write(str,*) 'sst_component_init2: back from GetDecompFromState'
	535	CALL wrf_debug ( 100 , TRIM(str) )
	536	write(str,*) 'sst_component_init2: ids, ide, jds, jde, kds, kde = ', ids, ide, jds, jde, kds, kde
	537	CALL wrf_debug ( 100 , TRIM(str) )
	538	write(str,*) 'sst_component_init2: ims, ime, jms, jme, kms, kme = ', ims, ime, jms, jme, kms, kme
	539	CALL wrf_debug ( 100 , TRIM(str) )
	540	write(str,*) 'sst_component_init2: ips, ipe, jps, jpe, kps, kpe = ', ips, ipe, jps, jpe, kps, kpe
	541	CALL wrf_debug ( 100 , TRIM(str) )
	542
	543	! allocate space for data read from disk
	544	ALLOCATE( file_sst_data (ims:ime,jms:jme) )
	545	DO j= jms, jme
	546	DO i= ims, ime
	547	file_sst_data(i,j) = -(i*1000.0 + j)/100000.0 ! obvious bad value for debugging
	548	ENDDO
	549	ENDDO
	550	!TODO: Hmmm... really need to load these pointers here? Check...
	551	this_data(SST_INDX)%r2d => file_sst_data
	552	ALLOCATE( file_landmask_data(ims:ime,jms:jme) )
	553	DO j= jms, jme
	554	DO i= ims, ime
	555	file_landmask_data(i,j) = -(i*1000.0 + j)/100000.0 ! obvious bad value for debugging
	556	ENDDO
	557	ENDDO
	558	this_data(LANDMASK_INDX)%r2d => file_landmask_data
	559
	560	! Create ESMF_Fields in importState and exportState
	561	! Create ESMF_Grid. Use exactly the same method as WRF so WRFIO will
	562	! work.
	563	DomainStart(1) = ids; DomainEnd(1) = ide;
	564	DomainStart(2) = jds; DomainEnd(2) = jde;
	565	MemoryStart(1) = ims; MemoryEnd(1) = ime;
	566	MemoryStart(2) = jms; MemoryEnd(2) = jme;
	567	PatchStart(1) = ips; PatchEnd(1) = ipe;
	568	PatchStart(2) = jps; PatchEnd(2) = jpe
	569	write(0,*)__FILE__,__LINE__,'DomainStart ',DomainStart(1:2)
	570	write(0,*)__FILE__,__LINE__,'DomainEnd ',DomainEnd(1:2)
	571	write(0,*)__FILE__,__LINE__,'MemoryStart ',MemoryStart(1:2)
	572	write(0,*)__FILE__,__LINE__,'MemoryEnd ',MemoryEnd(1:2)
	573	write(0,*)__FILE__,__LINE__,'PatchStart ',PatchStart(1:2)
	574	write(0,*)__FILE__,__LINE__,'PatchEnd ',PatchEnd(1:2)
	575	CALL wrf_debug ( 5 , 'DEBUG sst_component_init2: Calling ioesmf_create_grid_int()' )
	576	CALL ioesmf_create_grid_int( esmfgrid, NUMDIMS, &
	577	DomainStart, DomainEnd, &
	578	MemoryStart, MemoryEnd, &
	579	PatchStart, PatchEnd )
	580	write(0,*)__FILE__,__LINE__
	581	CALL wrf_debug ( 5 , 'DEBUG sst_component_init2: back from ioesmf_create_grid_int()' )
	582	! create ESMF_Fields
	583	! Note use of patch dimension for POINTERs allocated by ESMF.
	584	CALL wrf_debug ( 5 , 'DEBUG sst_component_init2: Calling ESMF_GridValidate(esmfgrid)' )
	585	CALL ESMF_GridValidate( esmfgrid, rc=rc )
	586	write(0,*)__FILE__,__LINE__
	587	IF ( rc /= ESMF_SUCCESS ) THEN
	588	WRITE( str,* ) 'Error in ESMF_GridValidate ', &
	589	__FILE__ , &
	590	', line ', &
	591	__LINE__ , &
	592	', error code = ',rc
	593	CALL wrf_error_fatal ( TRIM(str) )
	594	ENDIF
	595	CALL wrf_debug ( 5 , 'DEBUG sst_component_init2: back OK from ESMF_GridValidate(esmfgrid)' )
	596	!TODO: Once new ESMF 3.0 interfaces have settled down, eliminate "tmp_data_"
	597	!TODO: arrays and let ESMF allocate/deallocate them. Assuming of course that
	598	!TODO: we can convince ESMF to deallocate safely...
	599	write(0,*)__FILE__,__LINE__
	600	ALLOCATE( tmp_data_out_sst(ips:ipe,jps:jpe) )
	601	write(0,*)__FILE__,__LINE__
	602	write(str,*) 'sst_component_init2: tmp_data_out_sst(', &
	603	LBOUND(tmp_data_out_sst,1),':',UBOUND(tmp_data_out_sst,1),',',LBOUND(tmp_data_out_sst,2),':',UBOUND(tmp_data_out_sst,2),')'
	604	CALL wrf_debug ( 100 , TRIM(str) )
	605	CALL wrf_debug ( 100, 'sst_component_init2: calling ESMF_FieldCreate(out_sst_field)' )
	606	write(0,*)__FILE__,__LINE__,trim(datanames(sst_indx))
	607	write(0,*)__FILE__,__LINE__,ips,jps,ipe,jpe
	608	out_sst_field = ESMF_FieldCreate( &
	609	esmfgrid, tmp_data_out_sst, &
	610	copyflag=ESMF_DATA_REF, &
	611	staggerloc=ESMF_STAGGERLOC_CENTER, &
	612	name=TRIM(datanames(SST_INDX)), &
	613	rc=rc )
	614	write(0,*)__FILE__,__LINE__,'Creating out_sst_field for exportState of SST component name ',TRIM(datanames(SST_INDX))
	615	IF ( rc /= ESMF_SUCCESS ) THEN
	616	WRITE( str,* ) 'ESMF_FieldCreate(out_sst_field) failed ', &
	617	__FILE__ , &
	618	', line ', &
	619	__LINE__ , &
	620	', error code = ',rc
	621	CALL wrf_error_fatal ( TRIM(str) )
	622	ENDIF
	623	CALL wrf_debug ( 100, 'sst_component_init2: back from ESMF_FieldCreate(out_sst_field)' )
	624	write(str,*) 'sst_component_init2: ips:ipe,jps:jpe = ', &
	625	ips,':',ipe,',',jps,':',jpe
	626	CALL wrf_debug ( 100 , TRIM(str) )
	627	!TODO: This bit will be useful once ESMF handles allocation/deallocation.
	628	! validate ESMF allocation
	629	IF ( ( ips /= LBOUND(tmp_data_out_sst,1) ) .OR. ( ipe /= UBOUND(tmp_data_out_sst,1) ) .OR. &
	630	( jps /= LBOUND(tmp_data_out_sst,2) ) .OR. ( jpe /= UBOUND(tmp_data_out_sst,2) ) ) THEN
	631	WRITE( str,* ) 'ESMF_FieldCreate(out_sst_field) allocation failed ', &
	632	__FILE__ , &
	633	', line ', &
	634	__LINE__ , &
	635	', ips:ipe,jps:jpe = ',ips,':',ipe,',',jps,':',jpe, &
	636	', tmp_data_out_sst(BOUNDS) = ',LBOUND(tmp_data_out_sst,1),':',UBOUND(tmp_data_out_sst,1),',', &
	637	LBOUND(tmp_data_out_sst,2),':',UBOUND(tmp_data_out_sst,2)
	638	CALL wrf_error_fatal ( TRIM(str) )
	639	ENDIF
	640	ALLOCATE( tmp_data_out_landmask(ips:ipe,jps:jpe) )
	641	write(str,*) 'sst_component_init2: tmp_data_out_landmask(', &
	642	LBOUND(tmp_data_out_landmask,1),':',UBOUND(tmp_data_out_landmask,1),',',LBOUND(tmp_data_out_landmask,2),':',UBOUND(tmp_data_out_landmask,2),')'
	643	CALL wrf_debug ( 100 , TRIM(str) )
	644	CALL wrf_debug ( 100, 'sst_component_init2: calling ESMF_FieldCreate(out_landmask_field)' )
	645	out_landmask_field = ESMF_FieldCreate( &
	646	esmfgrid, tmp_data_out_landmask, &
	647	copyflag=ESMF_DATA_REF, &
	648	staggerloc=ESMF_STAGGERLOC_CENTER, &
	649	name=TRIM(datanames(LANDMASK_INDX)), &
	650	! lbounds=(/ips,jps/), &
	651	! ubounds=(/ipe,jpe/), &
	652	rc=rc )
	653	IF ( rc /= ESMF_SUCCESS ) THEN
	654	CALL wrf_error_fatal ( 'ESMF_FieldCreate(out_landmask_field) failed' )
	655	ENDIF
	656	CALL wrf_debug ( 100, 'sst_component_init2: back from ESMF_FieldCreate(out_landmask_field)' )
	657	!TODO: This bit will be useful once ESMF handles allocation/deallocation.
	658	! validate ESMF allocation
	659	IF ( ( ips /= LBOUND(tmp_data_out_landmask,1) ) .OR. ( ipe /= UBOUND(tmp_data_out_landmask,1) ) .OR. &
	660	( jps /= LBOUND(tmp_data_out_landmask,2) ) .OR. ( jpe /= UBOUND(tmp_data_out_landmask,2) ) ) THEN
	661	WRITE( str,* ) 'ESMF_FieldCreate(out_landmask_field) allocation failed ', &
	662	__FILE__ , &
	663	', line ', &
	664	__LINE__ , &
	665	', ips:ipe,jps:jpe = ',ips,':',ipe,',',jps,':',jpe, &
	666	', tmp_data_out_landmask(BOUNDS) = ',LBOUND(tmp_data_out_landmask,1),':',UBOUND(tmp_data_out_landmask,1),',', &
	667	LBOUND(tmp_data_out_landmask,2),':',UBOUND(tmp_data_out_landmask,2)
	668	CALL wrf_error_fatal ( TRIM(str) )
	669	ENDIF
	670	ALLOCATE( tmp_data_in_sst(ips:ipe,jps:jpe) )
	671	write(str,*) 'sst_component_init2: tmp_data_in_sst(', &
	672	LBOUND(tmp_data_in_sst,1),':',UBOUND(tmp_data_in_sst,1),',',LBOUND(tmp_data_in_sst,2),':',UBOUND(tmp_data_in_sst,2),')'
	673	CALL wrf_debug ( 100 , TRIM(str) )
	674	CALL wrf_debug ( 100, 'sst_component_init2: calling ESMF_FieldCreate(in_sst_field)' )
	675	in_sst_field = ESMF_FieldCreate( &
	676	esmfgrid, tmp_data_in_sst, &
	677	copyflag=ESMF_DATA_REF, &
	678	staggerloc=ESMF_STAGGERLOC_CENTER, &
	679	name=TRIM(datanames(SST_INDX)), &
	680	! lbounds=(/ips,jps/), &
	681	! ubounds=(/ipe,jpe/), &
	682	rc=rc )
	683	IF ( rc /= ESMF_SUCCESS ) THEN
	684	CALL wrf_error_fatal ( 'ESMF_FieldCreate(in_sst_field) failed' )
	685	ENDIF
	686	CALL wrf_debug ( 100, 'sst_component_init2: back from ESMF_FieldCreate(in_sst_field)' )
	687	!TODO: This bit will be useful once ESMF handles allocation/deallocation.
	688	! validate ESMF allocation
	689	IF ( ( ips /= LBOUND(tmp_data_in_sst,1) ) .OR. ( ipe /= UBOUND(tmp_data_in_sst,1) ) .OR. &
	690	( jps /= LBOUND(tmp_data_in_sst,2) ) .OR. ( jpe /= UBOUND(tmp_data_in_sst,2) ) ) THEN
	691	WRITE( str,* ) 'ESMF_FieldCreate(in_sst_field) allocation failed ', &
	692	__FILE__ , &
	693	', line ', &
	694	__LINE__ , &
	695	', ips:ipe,jps:jpe = ',ips,':',ipe,',',jps,':',jpe, &
	696	', tmp_data_in_sst(BOUNDS) = ',LBOUND(tmp_data_in_sst,1),':',UBOUND(tmp_data_in_sst,1),',', &
	697	LBOUND(tmp_data_in_sst,2),':',UBOUND(tmp_data_in_sst,2)
	698	CALL wrf_error_fatal ( TRIM(str) )
	699	ENDIF
	700	ALLOCATE( tmp_data_in_landmask(ips:ipe,jps:jpe) )
	701	write(str,*) 'sst_component_init2: tmp_data_in_landmask(', &
	702	LBOUND(tmp_data_in_landmask,1),':',UBOUND(tmp_data_in_landmask,1),',',LBOUND(tmp_data_in_landmask,2),':',UBOUND(tmp_data_in_landmask,2),')'
	703	CALL wrf_debug ( 100 , TRIM(str) )
	704	CALL wrf_debug ( 100, 'sst_component_init2: calling ESMF_FieldCreate(in_landmask_field)' )
	705	in_landmask_field = ESMF_FieldCreate( &
	706	esmfgrid, tmp_data_in_landmask, &
	707	copyflag=ESMF_DATA_REF, &
	708	staggerloc=ESMF_STAGGERLOC_CENTER, &
	709	name=TRIM(datanames(LANDMASK_INDX)), &
	710	! lbounds=(/ips,jps/), &
	711	! ubounds=(/ipe,jpe/), &
	712	rc=rc )
	713	IF ( rc /= ESMF_SUCCESS ) THEN
	714	CALL wrf_error_fatal ( 'ESMF_FieldCreate(in_landmask_field) failed' )
	715	ENDIF
	716	CALL wrf_debug ( 100, 'sst_component_init2: back from ESMF_FieldCreate(in_landmask_field)' )
	717	!TODO: This bit will be useful once ESMF handles allocation/deallocation.
	718	! validate ESMF allocation
	719	IF ( ( ips /= LBOUND(tmp_data_in_landmask,1) ) .OR. ( ipe /= UBOUND(tmp_data_in_landmask,1) ) .OR. &
	720	( jps /= LBOUND(tmp_data_in_landmask,2) ) .OR. ( jpe /= UBOUND(tmp_data_in_landmask,2) ) ) THEN
	721	WRITE( str,* ) 'ESMF_FieldCreate(in_landmask_field) allocation failed ', &
	722	__FILE__ , &
	723	', line ', &
	724	__LINE__ , &
	725	', ips:ipe,jps:jpe = ',ips,':',ipe,',',jps,':',jpe, &
	726	', tmp_data_in_landmask(BOUNDS) = ',LBOUND(tmp_data_in_landmask,1),':',UBOUND(tmp_data_in_landmask,1),',', &
	727	LBOUND(tmp_data_in_landmask,2),':',UBOUND(tmp_data_in_landmask,2)
	728	CALL wrf_error_fatal ( TRIM(str) )
	729	ENDIF
	730
	731	! attach ESMF_Field to importState
	732	CALL ESMF_StateAdd( importState, in_sst_field, rc=rc )
	733	IF ( rc /= ESMF_SUCCESS ) THEN
	734	CALL wrf_error_fatal ( 'ESMF_StateAdd(in_sst_field) failed' )
	735	ENDIF
	736	CALL ESMF_StateAdd( importState, in_landmask_field, rc=rc )
	737	IF ( rc /= ESMF_SUCCESS ) THEN
	738	CALL wrf_error_fatal ( 'ESMF_StateAdd(in_landmask_field) failed' )
	739	ENDIF
	740	! attach ESMF_Field to exportState
	741	CALL ESMF_StateAdd( exportState, out_sst_field, rc=rc )
	742	IF ( rc /= ESMF_SUCCESS ) THEN
	743	CALL wrf_error_fatal ( 'ESMF_StateAdd(out_sst_field) failed' )
	744	ENDIF
	745	CALL ESMF_StateAdd( exportState, out_landmask_field, rc=rc )
	746	IF ( rc /= ESMF_SUCCESS ) THEN
	747	CALL wrf_error_fatal ( 'ESMF_StateAdd(out_landmask_field) failed' )
	748	ENDIF
	749
	750	! Open the "SST" input data file for reading.
	751	write(str,'(A,A)') 'sst_component_init2: Opening data file ', &
	752	TRIM(sstinfilename)
	753	CALL wrf_message ( TRIM(str) )
	754	CALL wrf_open_for_read ( TRIM(sstinfilename) , &
	755	mpicom , &
	756	mpicom , &
	757	"DATASET=INPUT" , &
	758	fid , &
	759	ierr )
	760	IF ( ierr .NE. 0 ) THEN
	761	WRITE( str , FMT='(A,A,A,I8)' ) &
	762	'sst_component_init2: error opening ', &
	763	TRIM(sstinfilename),' for reading ierr=',ierr
	764	CALL wrf_error_fatal ( TRIM(str) )
	765	ENDIF
	766	WRITE( str , FMT='(A,A,A,I8)' ) &
	767	'subroutine sst_component_init2: opened file ', &
	768	TRIM(sstinfilename),' for reading fid=',fid
	769	CALL wrf_debug ( 100, TRIM(str) )
	770
	771	write(str,'(A)') 'sst_component_init2: returning rc=ESMF_SUCCESS'
	772	CALL wrf_debug ( 100 , TRIM(str) )
	773
	774	rc = ESMF_SUCCESS
	775
	776	END SUBROUTINE sst_component_init2
	777
	778
	779
	780	SUBROUTINE sst_component_run1( gcomp, importState, exportState, clock, rc )
	781	TYPE(ESMF_GridComp), TARGET, INTENT(INOUT) :: gcomp
	782	TYPE(ESMF_State), TARGET, INTENT(INOUT) :: importState, exportState
	783	TYPE(ESMF_Clock), TARGET, INTENT(INOUT) :: clock
	784	INTEGER, INTENT( OUT) :: rc
	785	!<DESCRIPTION>
	786	! SST component run routine, phase 1.
	787	! Read "SST" data from file and stuff into exportState.
	788	!
	789	! The arguments are:
	790	! gcomp Component
	791	! importState Importstate
	792	! exportState Exportstate
	793	! clock External clock
	794	! rc Return code; equals ESMF_SUCCESS if there are no errors,
	795	! otherwise ESMF_FAILURE.
	796	!</DESCRIPTION>
	797
	798	rc = ESMF_SUCCESS
	799
	800	! Get "SST" data from file and stuff it into exportState.
	801	CALL read_data( exportState, clock )
	802
	803	END SUBROUTINE sst_component_run1
	804
	805
	806
	807	SUBROUTINE sst_component_run2( gcomp, importState, exportState, clock, rc )
	808	TYPE(ESMF_GridComp), TARGET, INTENT(INOUT) :: gcomp
	809	TYPE(ESMF_State), TARGET, INTENT(INOUT) :: importState, exportState
	810	TYPE(ESMF_Clock), TARGET, INTENT(INOUT) :: clock
	811	INTEGER, INTENT( OUT) :: rc
	812	!<DESCRIPTION>
	813	! SST component run routine, phase 2.
	814	! Get from importState, compare with file data, and error-exit
	815	! if they differ... If they are the same, then
	816	! stuff the file data into the exportState.
	817	!
	818	! The arguments are:
	819	! gcomp Component
	820	! importState Importstate
	821	! exportState Exportstate
	822	! clock External clock
	823	! rc Return code; equals ESMF_SUCCESS if there are no errors,
	824	! otherwise ESMF_FAILURE.
	825	!</DESCRIPTION>
	826
	827	rc = ESMF_SUCCESS
	828
	829	! Get from importState, compare with file data, and error_exit
	830	! if they differ...
	831	!TODO: change this once WRF can load exportState after integrating
	832	! This works because WRF loads its exportState BEFORE integrating.
	833	CALL wrf_clockprint ( 50, clock, 'sst_component_run2: clock before call to compare_data()' )
	834	CALL compare_data( importState, clock )
	835	CALL wrf_clockprint ( 50, clock, 'sst_component_run2: clock after call to compare_data()' )
	836
	837	END SUBROUTINE sst_component_run2
	838
	839
	840
	841	SUBROUTINE sst_component_finalize( gcomp, importState, exportState, clock, rc )
	842	USE module_io
	843	TYPE(ESMF_GridComp), TARGET, INTENT(INOUT) :: gcomp
	844	TYPE(ESMF_State), TARGET, INTENT(INOUT) :: importState, exportState
	845	TYPE(ESMF_Clock), TARGET, INTENT(INOUT) :: clock
	846	INTEGER, INTENT( OUT) :: rc
	847	!<DESCRIPTION>
	848	! SST component finalize routine.
	849	!
	850	! The arguments are:
	851	! gcomp Component
	852	! importState Importstate
	853	! exportState Exportstate
	854	! clock External clock
	855	! rc Return code; equals ESMF_SUCCESS if there are no errors,
	856	! otherwise ESMF_FAILURE.
	857	!</DESCRIPTION>
	858
	859	! Local variables
	860	TYPE(ESMF_Field) :: tmp_field
	861	INTEGER :: i, ierr
	862
	863	rc = ESMF_SUCCESS
	864
	865	! destroy ESMF_Fields and other "deep" objects created by this component
	866	! note that this component relied on ESMF to allocate data pointers during
	867	! calls to ESMF_FieldCreate() so it also expects ESMF to free these pointers
	868	DO i=1, datacount
	869	! destroy field in importState
	870	CALL ESMF_StateGet( importState, TRIM(datanames(i)), tmp_field, &
	871	rc=rc )
	872	IF (rc /= ESMF_SUCCESS) THEN
	873	WRITE( str , * ) &
	874	'sst_component_finalize: ESMF_StateGet( importState,', &
	875	TRIM(datanames(i)),') failed'
	876	CALL wrf_error_fatal ( TRIM(str) )
	877	ENDIF
	878	CALL ESMF_FieldDestroy( tmp_field, rc=rc )
	879	IF (rc /= ESMF_SUCCESS) THEN
	880	WRITE( str , * ) &
	881	'sst_component_finalize: ESMF_FieldDestroy( importState,', &
	882	TRIM(datanames(i)),') failed'
	883	CALL wrf_error_fatal ( TRIM(str) )
	884	ENDIF
	885	! destroy field in exportState
	886	CALL ESMF_StateGet( exportState, TRIM(datanames(i)), tmp_field, &
	887	rc=rc )
	888	IF (rc /= ESMF_SUCCESS) THEN
	889	WRITE( str , * ) &
	890	'sst_component_finalize: ESMF_StateGet( exportState,', &
	891	TRIM(datanames(i)),') failed'
	892	CALL wrf_error_fatal ( TRIM(str) )
	893	ENDIF
	894	CALL ESMF_FieldDestroy( tmp_field, rc=rc )
	895	IF (rc /= ESMF_SUCCESS) THEN
	896	WRITE( str , * ) &
	897	'sst_component_finalize: ESMF_FieldDestroy( exportState,', &
	898	TRIM(datanames(i)),') failed'
	899	CALL wrf_error_fatal ( TRIM(str) )
	900	ENDIF
	901	ENDDO
	902
	903	! deallocate space for data read from disk
	904	DEALLOCATE( file_sst_data, file_landmask_data )
	905
	906	! close SST data file
	907	WRITE( str , FMT='(A,I8)' ) &
	908	'subroutine sst_component_finalize: closing file fid=',fid
	909	CALL wrf_debug ( 100, TRIM(str) )
	910	CALL wrf_ioclose( fid , ierr )
	911	IF ( ierr .NE. 0 ) THEN
	912	CALL wrf_error_fatal ( 'sst_component_finalize: wrf_ioclose failed' )
	913	ENDIF
	914
	915	END SUBROUTINE sst_component_finalize
	916
	917
	918	END MODULE module_sst_component_top
	919
	920
	921
	922
	923	MODULE module_sst_setservices
	924	!<DESCRIPTION>
	925	! This module defines SST "Set Services" method sst_register()
	926	! used for ESMF coupling.
	927	!</DESCRIPTION>
	928
	929	USE module_sst_component_top, ONLY: sst_component_init1, &
	930	sst_component_init2, &
	931	sst_component_run1, &
	932	sst_component_run2, &
	933	sst_component_finalize
	934	USE ESMF_Mod
	935
	936	IMPLICIT NONE
	937
	938	! everything is private by default
	939	PRIVATE
	940
	941	! Public entry point for ESMF_GridCompSetServices()
	942	PUBLIC SST_register
	943
	944	! private stuff
	945	CHARACTER (ESMF_MAXSTR) :: str
	946
	947	CONTAINS
	948
	949
	950	SUBROUTINE sst_register(gcomp, rc)
	951	TYPE(ESMF_GridComp), INTENT(INOUT) :: gcomp
	952	INTEGER, INTENT(OUT) :: rc
	953	INTEGER :: finalrc
	954	!
	955	!<DESCRIPTION>
	956	! SST_register - Externally visible registration routine
	957	!
	958	! User-supplied SetServices routine.
	959	! The Register routine sets the subroutines to be called
	960	! as the init, run, and finalize routines. Note that these are
	961	! private to the module.
	962	!
	963	! The arguments are:
	964	! gcomp Component
	965	! rc Return code; equals ESMF_SUCCESS if there are no errors,
	966	! otherwise ESMF_FAILURE.
	967	!</DESCRIPTION>
	968
	969	finalrc = ESMF_SUCCESS
	970	! Register the callback routines.
	971	call ESMF_GridCompSetEntryPoint(gcomp, ESMF_SETINIT, &
	972	sst_component_init1, 1, rc)
	973	IF ( rc /= ESMF_SUCCESS) THEN
	974	WRITE(str,*) 'ESMF_GridCompSetEntryPoint(sst_component_init1) failed with rc = ', rc
	975	CALL wrf_error_fatal ( TRIM(str) )
	976	ENDIF
	977	call ESMF_GridCompSetEntryPoint(gcomp, ESMF_SETINIT, &
	978	sst_component_init2, 2, rc)
	979	IF ( rc /= ESMF_SUCCESS) THEN
	980	WRITE(str,*) 'ESMF_GridCompSetEntryPoint(sst_component_init2) failed with rc = ', rc
	981	CALL wrf_error_fatal ( TRIM(str) )
	982	ENDIF
	983	call ESMF_GridCompSetEntryPoint(gcomp, ESMF_SETRUN, &
	984	sst_component_run1, 1, rc)
	985	IF ( rc /= ESMF_SUCCESS) THEN
	986	WRITE(str,*) 'ESMF_GridCompSetEntryPoint(sst_component_run1) failed with rc = ', rc
	987	CALL wrf_error_fatal ( TRIM(str) )
	988	ENDIF
	989	call ESMF_GridCompSetEntryPoint(gcomp, ESMF_SETRUN, &
	990	sst_component_run2, 2, rc)
	991	IF ( rc /= ESMF_SUCCESS) THEN
	992	WRITE(str,*) 'ESMF_GridCompSetEntryPoint(sst_component_run2) failed with rc = ', rc
	993	CALL wrf_error_fatal ( TRIM(str) )
	994	ENDIF
	995	call ESMF_GridCompSetEntryPoint(gcomp, ESMF_SETFINAL, &
	996	sst_component_finalize, ESMF_SINGLEPHASE, rc)
	997	IF ( rc /= ESMF_SUCCESS) THEN
	998	WRITE(str,*) 'ESMF_GridCompSetEntryPoint(sst_component_finalize) failed with rc = ', rc
	999	CALL wrf_error_fatal ( TRIM(str) )
	1000	ENDIF
	1001
	1002	PRINT *,'SST: Registered Initialize, Run, and Finalize routines'
	1003
	1004	rc = finalrc
	1005
	1006	END SUBROUTINE sst_register
	1007
	1008	END MODULE module_sst_setservices
	1009
	1010
	1011
	1012	!<DESCRIPTION>
	1013	! Module module_wrfsst_coupler defines the
	1014	! "WRF-SST" coupler component. It provides two-way coupling between
	1015	! the "SST" and "WRF" components.
	1016	! In its run routine it transfers data directly from the
	1017	! SST Component's export state to the WRF Component's import state.
	1018	! It also transfers data directly from the
	1019	! WRF Component's export state to the SST Component's import state.
	1020	!
	1021	! This is derived from src/demo/coupled_flow/src/CouplerMod.F90
	1022	! created by Nancy Collins and others on the ESMF Core Team.
	1023	!
	1024	!</DESCRIPTION>
	1025
	1026	MODULE module_wrfsst_coupler
	1027
	1028	USE ESMF_Mod
	1029
	1030	IMPLICIT NONE
	1031
	1032	! everything is private by default
	1033	PRIVATE
	1034
	1035	! Public entry point
	1036	PUBLIC WRFSSTCpl_register
	1037
	1038	! private data members
	1039	! route handles and flags
	1040	TYPE(ESMF_RouteHandle), SAVE :: fromWRF_rh, fromSST_rh
	1041	LOGICAL, SAVE :: fromWRF_rh_ready = .FALSE.
	1042	LOGICAL, SAVE :: fromSST_rh_ready = .FALSE.
	1043	! field names
	1044	INTEGER, PARAMETER :: datacount = 2
	1045	INTEGER, PARAMETER :: SST_INDX = 1
	1046	INTEGER, PARAMETER :: LANDMASK_INDX = 2
	1047	CHARACTER(LEN=ESMF_MAXSTR), SAVE :: datanames(datacount)
	1048	CHARACTER(LEN=ESMF_MAXSTR) :: str
	1049
	1050
	1051	CONTAINS
	1052
	1053
	1054	SUBROUTINE WRFSSTCpl_register(comp, rc)
	1055	TYPE(ESMF_CplComp), INTENT(INOUT) :: comp
	1056	INTEGER, INTENT(OUT) :: rc
	1057	!
	1058	!<DESCRIPTION>
	1059	! WRFSSTCpl_register - Externally visible registration routine
	1060	!
	1061	! User-supplied SetServices routine.
	1062	! The Register routine sets the subroutines to be called
	1063	! as the init, run, and finalize routines. Note that these are
	1064	! private to the module.
	1065	!
	1066	! The arguments are:
	1067	! comp Component
	1068	! rc Return code; equals ESMF_SUCCESS if there are no errors,
	1069	! otherwise ESMF_FAILURE.
	1070	!</DESCRIPTION>
	1071
	1072	! guilty until proven innocent
	1073	rc = ESMF_FAILURE
	1074
	1075	! Register the callback routines.
	1076
	1077	call ESMF_CplCompSetEntryPoint(comp, ESMF_SETINIT, WRFSSTCpl_init, &
	1078	ESMF_SINGLEPHASE, rc)
	1079	IF ( rc /= ESMF_SUCCESS ) THEN
	1080	CALL wrf_error_fatal ( 'ESMF_CplCompSetEntryPoint(WRFSSTCpl_init) failed' )
	1081	ENDIF
	1082	call ESMF_CplCompSetEntryPoint(comp, ESMF_SETRUN, WRFSSTCpl_run, &
	1083	ESMF_SINGLEPHASE, rc)
	1084	IF ( rc /= ESMF_SUCCESS ) THEN
	1085	CALL wrf_error_fatal ( 'ESMF_CplCompSetEntryPoint(WRFSSTCpl_run) failed' )
	1086	ENDIF
	1087	call ESMF_CplCompSetEntryPoint(comp, ESMF_SETFINAL, WRFSSTCpl_final, &
	1088	ESMF_SINGLEPHASE, rc)
	1089	IF ( rc /= ESMF_SUCCESS ) THEN
	1090	CALL wrf_error_fatal ( 'ESMF_CplCompSetEntryPoint(WRFSSTCpl_final) failed' )
	1091	ENDIF
	1092
	1093	print *, "module_wrfsst_coupler: Registered Initialize, Run, and Finalize routines"
	1094
	1095	END SUBROUTINE WRFSSTCpl_register
	1096
	1097
	1098	SUBROUTINE WRFSSTCpl_init(comp, importState, exportState, clock, rc)
	1099	USE module_metadatautils, ONLY: AttachDecompToState, GetDecompFromState
	1100	TYPE(ESMF_CplComp), INTENT(INOUT) :: comp
	1101	TYPE(ESMF_State), INTENT(INOUT) :: importState, exportState
	1102	TYPE(ESMF_Clock), INTENT(INOUT) :: clock
	1103	INTEGER, INTENT(OUT) :: rc
	1104	!<DESCRIPTION>
	1105	! WRF-SST coupler component init routine. This simply passes needed
	1106	! metadata from WRF to SST. Initialization of ESMF_RouteHandle objects
	1107	! is handled later via lazy evaluation.
	1108	!
	1109	! The arguments are:
	1110	! comp Component
	1111	! importState Importstate
	1112	! exportState Exportstate
	1113	! clock External clock
	1114	! rc Return code; equals ESMF_SUCCESS if there are no errors,
	1115	! otherwise ESMF_FAILURE.
	1116	!</DESCRIPTION>
	1117
	1118	! Local variables
	1119	CHARACTER(ESMF_MAXSTR) :: importstatename
	1120	! decomposition information
	1121	INTEGER :: ids, ide, jds, jde, kds, kde
	1122	INTEGER :: ims, ime, jms, jme, kms, kme
	1123	INTEGER :: ips, ipe, jps, jpe, kps, kpe
	1124	INTEGER :: domdesc
	1125	LOGICAL :: bdy_mask(4)
	1126
	1127	PRINT *, "DEBUG: Coupler Init starting"
	1128
	1129	! guilty until proven innocent
	1130	rc = ESMF_FAILURE
	1131
	1132	CALL ESMF_StateGet(importState, name=importstatename, rc=rc)
	1133	IF ( rc /= ESMF_SUCCESS ) THEN
	1134	CALL wrf_error_fatal ( 'WRFSSTCpl_init: ESMF_StateGet failed' )
	1135	ENDIF
	1136
	1137	IF ( TRIM(importstatename) .EQ. "WRF Export State" ) THEN
	1138	! get metadata from WRF export state
	1139	CALL GetDecompFromState( importState, &
	1140	ids, ide, jds, jde, kds, kde, &
	1141	ims, ime, jms, jme, kms, kme, &
	1142	ips, ipe, jps, jpe, kps, kpe, &
	1143	domdesc, bdy_mask )
	1144	! put metadata from in SST import state
	1145	CALL AttachDecompToState( exportState, &
	1146	ids, ide, jds, jde, kds, kde, &
	1147	ims, ime, jms, jme, kms, kme, &
	1148	ips, ipe, jps, jpe, kps, kpe, &
	1149	domdesc, bdy_mask )
	1150
	1151
	1152	ELSE
	1153	CALL wrf_error_fatal ( 'WRFSSTCpl_init: invalid importState name' )
	1154	ENDIF
	1155
	1156	! set up field names
	1157	!TODO: use CF conventions for "standard_name" once WRF Registry supports them
	1158	!TODO: datanames(SST_INDX) = "sea_surface_temperature"
	1159	!TODO: datanames(LANDMASK_INDX) = "land_binary_mask"
	1160	datanames(SST_INDX) = "SST"
	1161	datanames(LANDMASK_INDX) = "LANDMASK"
	1162
	1163	PRINT *, "DEBUG: Coupler Init returning"
	1164
	1165	END SUBROUTINE WRFSSTCpl_init
	1166
	1167
	1168
	1169	SUBROUTINE WRFSSTCpl_run(comp, importState, exportState, clock, rc)
	1170	TYPE(ESMF_CplComp), INTENT(INOUT) :: comp
	1171	TYPE(ESMF_State), INTENT(INOUT) :: importState, exportState
	1172	TYPE(ESMF_Clock), INTENT(INOUT) :: clock
	1173	INTEGER, INTENT(OUT) :: rc
	1174	!<DESCRIPTION>
	1175	! WRF-SST coupler component run routine.
	1176	!
	1177	! The arguments are:
	1178	! comp Component
	1179	! importState Importstate
	1180	! exportState Exportstate
	1181	! clock External clock
	1182	! rc Return code; equals ESMF_SUCCESS if there are no errors,
	1183	! otherwise ESMF_FAILURE.
	1184	!</DESCRIPTION>
	1185
	1186	! Note that comments in this code are preserved from the sample coupler
	1187	! provided by the ESMF core team.
	1188
	1189	! Local variables
	1190	character*256 :: mename
	1191	character*256 :: melist(100)
	1192	integer :: mecount
	1193	TYPE(ESMF_StateItemType) :: metypelist(100)
	1194	TYPE(ESMF_Field) :: src_field, dst_field
	1195	TYPE(ESMF_Array) :: src_array, dst_array
	1196	TYPE(ESMF_RouteHandle) :: routehandle
	1197	TYPE(ESMF_VM) :: vm
	1198	LOGICAL :: build_fromWRF_rh, build_fromSST_rh, fromWRF
	1199	CHARACTER(LEN=ESMF_MAXSTR) :: importStatename
	1200	CHARACTER(LEN=ESMF_MAXSTR) :: SST_exportStatename, WRF_exportStatename
	1201	INTEGER :: i
	1202	CHARACTER(LEN=256) :: directionString
	1203
	1204	WRITE(str,*) 'WRFSSTCpl_run: begin'
	1205	CALL wrf_debug ( 100 , TRIM(str) )
	1206
	1207	! guilty until proven innocent
	1208	rc = ESMF_FAILURE
	1209
	1210	! Which way is this coupling going?
	1211	WRITE(str,*) 'WRFSSTCpl_run: calling ESMF_StateGet(importState,name,...)'
	1212	CALL wrf_debug ( 100 , TRIM(str) )
	1213	CALL ESMF_StateGet( importState, name=importStatename, rc=rc )
	1214	write(0,*)__FILE__,__LINE__, 'importStatename ', trim(importStatename), 'rc = ', rc
	1215	IF ( rc /= ESMF_SUCCESS ) THEN
	1216	CALL wrf_error_fatal ( 'WRFSSTCpl_run: ESMF_StateGet(importState,name,...) failed' )
	1217	ENDIF
	1218	WRITE(str,*) 'WRFSSTCpl_run: back from ESMF_StateGet, importStatename = <',TRIM(importStatename),'>'
	1219	CALL wrf_debug ( 100 , TRIM(str) )
	1220
	1221	! first time through in each direction: create route handle and
	1222	! associated objects
	1223	WRF_exportStatename = "WRF Export State"
	1224	SST_exportStatename = "SST Export State"
	1225	IF ( TRIM(importStatename) .EQ. TRIM(WRF_exportStatename) ) THEN
	1226	fromWRF = .TRUE.
	1227	directionString = 'WRFtoSST'
	1228	ELSE IF ( TRIM(importStatename) .EQ. TRIM(SST_exportStatename) ) THEN
	1229	fromWRF = .FALSE.
	1230	directionString = 'SSTtoWRF'
	1231	ELSE
	1232	CALL wrf_error_fatal ( 'WRFSSTCpl_run: invalid importState name' )
	1233	ENDIF
	1234	WRITE(str,*) 'WRFSSTCpl_run: fromWRF = ',fromWRF
	1235	CALL wrf_debug ( 100 , TRIM(str) )
	1236	build_fromWRF_rh = fromWRF .AND. ( .NOT. fromWRF_rh_ready )
	1237	build_fromSST_rh = ( .NOT. fromWRF ) .AND. ( .NOT. fromSST_rh_ready )
	1238	WRITE(str,*) 'WRFSSTCpl_run: build_fromWRF_rh = ',build_fromWRF_rh
	1239	CALL wrf_debug ( 100 , TRIM(str) )
	1240	WRITE(str,*) 'WRFSSTCpl_run: build_fromSST_rh = ',build_fromSST_rh
	1241	CALL wrf_debug ( 100 , TRIM(str) )
	1242	IF ( build_fromWRF_rh .OR. build_fromSST_rh ) THEN
	1243	CALL ESMF_CplCompGet( comp, vm=vm, rc=rc )
	1244	IF ( rc /= ESMF_SUCCESS ) THEN
	1245	CALL wrf_error_fatal ( 'WRFSSTCpl_run: ESMF_CplCompGet failed' )
	1246	ENDIF
	1247	! The use of literal index "1" here indicates that we don't care which
	1248	! ESMF_Field we get so we might as well get the first one.
	1249	WRITE(str,*) 'WRFSSTCpl_run: grabbing first field <',TRIM(datanames(1)), &
	1250	'> from import state'
	1251	CALL wrf_debug ( 100 , TRIM(str) )
	1252
	1253	CALL ESMF_StateGet( importState, name=mename, itemCount=mecount, itemNameList=melist, stateitemtypelist=metypelist, rc=rc )
	1254	write(0,*)'importState mename ',trim(mename)
	1255	write(0,*)'importState mecount ',mecount
	1256	do i = 1,mecount
	1257	write(0,*)i,trim(melist(i))
	1258	enddo
	1259	do i = 1,mecount
	1260	write(0,*)i,metypelist(i)
	1261	enddo
	1262
	1263	CALL ESMF_StateGet( importState, TRIM(datanames(1)), src_field, &
	1264	rc=rc )
	1265	write(0,*)__FILE__,__LINE__, 'from importState: datanames(1) ', TRIM(datanames(1)), ' rc = ', rc
	1266	IF ( rc /= ESMF_SUCCESS ) THEN
	1267	CALL wrf_error_fatal ( 'WRFSSTCpl_run: ESMF_StateGet(importState) failed' )
	1268	ENDIF
	1269
	1270	CALL ESMF_FieldGet( src_field, array=src_array, rc=rc )
	1271	write(0,*)__FILE__,__LINE__, 'from fieldget: rc = ', rc
	1272	IF ( rc /= ESMF_SUCCESS ) THEN
	1273	CALL wrf_error_fatal ( 'WRFSSTCpl_run: ESMF_FieldGet src_array failed' )
	1274	ENDIF
	1275	WRITE(str,*) 'WRFSSTCpl_run: grabbing first field <',TRIM(datanames(1)), &
	1276	'> from export state'
	1277	CALL wrf_debug ( 100 , TRIM(str) )
	1278
	1279	CALL ESMF_StateGet( exportState, name=mename, itemCount=mecount, itemNameList=melist, stateitemtypelist=metypelist, rc=rc )
	1280	write(0,*)'Exportstate mename ',trim(mename)
	1281	write(0,*)'Exportstate mecount ',mecount
	1282	do i = 1,mecount
	1283	write(0,*)i,trim(melist(i))
	1284	enddo
	1285	do i = 1,mecount
	1286	write(0,*)i,metypelist(i)
	1287	enddo
	1288
	1289	CALL ESMF_StateGet( exportState, TRIM(datanames(1)), dst_field, &
	1290	rc=rc )
	1291	IF ( rc /= ESMF_SUCCESS ) THEN
	1292	CALL wrf_error_fatal ( 'WRFSSTCpl_run: ESMF_StateGet(exportState) failed' )
	1293	ENDIF
	1294	CALL ESMF_FieldGet( dst_field, array=dst_array, &
	1295	rc=rc )
	1296	IF ( rc /= ESMF_SUCCESS ) THEN
	1297	CALL wrf_error_fatal ( 'WRFSSTCpl_run: ESMF_FieldGet dst_array failed' )
	1298	ENDIF
	1299
	1300
	1301
	1302	IF ( build_fromWRF_rh ) THEN
	1303	WRITE(str,*) 'WRFSSTCpl_run: creating fromWRF_rh'
	1304	CALL wrf_debug ( 100 , TRIM(str) )
	1305	fromWRF_rh = ESMF_RouteHandleCreate( rc )
	1306	IF ( rc /= ESMF_SUCCESS ) THEN
	1307	CALL wrf_error_fatal ( 'WRFSSTCpl_run: ESMF_RouteHandleCreate(fromWRF_rh) failed' )
	1308	ENDIF
	1309	WRITE(str,*) 'WRFSSTCpl_run: calling ESMF_FieldRedistStore(fromWRF_rh)'
	1310	CALL wrf_debug ( 100 , TRIM(str) )
	1311	CALL ESMF_ArrayRedistStore( src_array, dst_array, &
	1312	routehandle=fromWRF_rh, rc=rc )
	1313	IF ( rc /= ESMF_SUCCESS ) THEN
	1314	CALL wrf_error_fatal ( 'WRFSSTCpl_run: ESMF_FieldRedistStore(fromWRF_rh) failed' )
	1315	ENDIF
	1316	fromWRF_rh_ready = .TRUE.
	1317	ENDIF
	1318	IF ( build_fromSST_rh ) THEN
	1319	WRITE(str,*) 'WRFSSTCpl_run: creating fromSST_rh'
	1320	CALL wrf_debug ( 100 , TRIM(str) )
	1321	fromSST_rh = ESMF_RouteHandleCreate( rc )
	1322	IF ( rc /= ESMF_SUCCESS ) THEN
	1323	CALL wrf_error_fatal ( 'WRFSSTCpl_run: ESMF_RouteHandleCreate(fromSST_rh) failed' )
	1324	ENDIF
	1325	WRITE(str,*) 'WRFSSTCpl_run: calling ESMF_FieldRedistStore(fromSST_rh)'
	1326	CALL wrf_debug ( 100 , TRIM(str) )
	1327	CALL ESMF_ArrayRedistStore( src_array, dst_array, &
	1328	routehandle=fromSST_rh, rc=rc )
	1329	write(0,*)__FILE__,__LINE__,'rc = ',rc
	1330	IF ( rc /= ESMF_SUCCESS ) THEN
	1331	CALL wrf_error_fatal ( 'WRFSSTCpl_run: ESMF_FieldRedistStore(fromSST_rh) failed' )
	1332	ENDIF
	1333	fromSST_rh_ready = .TRUE.
	1334	ENDIF
	1335	DO i=1, datacount
	1336	WRITE(str,*) 'WRFSSTCpl_run: calling ESMF_StateSetNeeded(importState, ',TRIM(datanames(i)),')'
	1337	CALL wrf_debug ( 100 , TRIM(str) )
	1338	CALL ESMF_StateSetNeeded( importState, TRIM(datanames(i)), &
	1339	ESMF_NEEDED, rc=rc )
	1340	IF ( rc /= ESMF_SUCCESS ) THEN
	1341	WRITE(str,*) 'WRFSSTCpl_run: ESMF_StateSetNeeded(',TRIM(datanames(i)),') failed'
	1342	CALL wrf_error_fatal ( str )
	1343	ENDIF
	1344	ENDDO
	1345	ENDIF
	1346
	1347	! In this case, the coupling is symmetric - you call redist going
	1348	! both ways - so we only care about the coupling direction in order
	1349	! to get the right routehandle selected.
	1350	IF ( fromWRF ) THEN
	1351	WRITE(str,*) 'WRFSSTCpl_run: routehandle = fromWRF_rh'
	1352	CALL wrf_debug ( 100 , TRIM(str) )
	1353	routehandle = fromWRF_rh
	1354	ELSE
	1355	WRITE(str,*) 'WRFSSTCpl_run: routehandle = fromSST_rh'
	1356	CALL wrf_debug ( 100 , TRIM(str) )
	1357	routehandle = fromSST_rh
	1358	ENDIF
	1359
	1360	DO i=1, datacount
	1361	WRITE(str,*) 'WRFSSTCpl_run: grabbing field <',TRIM(datanames(i)),'>'
	1362	CALL wrf_debug ( 100 , TRIM(str) )
	1363	! check isneeded flag here
	1364	IF ( .NOT. ESMF_StateIsNeeded( importState, TRIM(datanames(i)), rc=rc ) ) THEN
	1365	IF ( rc /= ESMF_SUCCESS ) THEN
	1366	WRITE(str,*) 'WRFSSTCpl_run: ESMF_StateIsNeeded(',TRIM(datanames(i)),') failed'
	1367	CALL wrf_error_fatal ( str )
	1368	ENDIF
	1369	WRITE(str,*) 'WRFSSTCpl_run: skipping field <',TRIM(datanames(i)),'>'
	1370	CALL wrf_debug ( 100 , TRIM(str) )
	1371	CYCLE
	1372	ENDIF
	1373
	1374	WRITE(str,*) 'WRFSSTCpl_run: processing field <',TRIM(datanames(i)),'>'
	1375	CALL wrf_debug ( 100 , TRIM(str) )
	1376
	1377	! The following piece of code provides an example of calling the data
	1378	! redistribution routine between two Fields in the Coupler Component.
	1379	! Unlike regrid, which translates between
	1380	! different Grids, redist translates between different DELayouts on
	1381	! the same Grid. The first two lines get the Fields from the
	1382	! States, each corresponding to a different subcomponent. One is
	1383	! an Export State and the other is an Import State.
	1384	!
	1385	WRITE(str,*) 'WRFSSTCpl_run: calling ESMF_StateGet(importState,', &
	1386	TRIM(datanames(i)),')...'
	1387	CALL wrf_debug ( 100 , TRIM(str) )
	1388	CALL ESMF_StateGet( importState, TRIM(datanames(i)), src_field, &
	1389	rc=rc )
	1390	IF ( rc /= ESMF_SUCCESS ) THEN
	1391	WRITE(str,*) 'WRFSSTCpl_run: ESMF_StateGet(importState,', &
	1392	TRIM(datanames(i)),') failed'
	1393	CALL wrf_error_fatal ( str )
	1394	ENDIF
	1395	CALL ESMF_FieldGet( src_field, array=src_array, rc=rc )
	1396	IF ( rc /= ESMF_SUCCESS ) THEN
	1397	WRITE(str,*) 'WRFSSTCpl_run: ESMF_FieldGet(src_field,src_array,rc) failed'
	1398	CALL wrf_error_fatal ( str )
	1399	ENDIF
	1400
	1401	WRITE(str,*) 'WRFSSTCpl_run: calling ESMF_StateGet(exportState,', &
	1402	TRIM(datanames(i)),')...'
	1403	CALL wrf_debug ( 100 , TRIM(str) )
	1404	CALL ESMF_StateGet( exportState, TRIM(datanames(i)), dst_field, &
	1405	rc=rc )
	1406	IF ( rc /= ESMF_SUCCESS ) THEN
	1407	WRITE(str,*) 'WRFSSTCpl_run: ESMF_StateGet(exportState,', &
	1408	TRIM(datanames(i)),') failed'
	1409	CALL wrf_error_fatal ( str )
	1410	ENDIF
	1411	CALL ESMF_FieldGet( dst_field, array=dst_array, rc=rc )
	1412	IF ( rc /= ESMF_SUCCESS ) THEN
	1413	WRITE(str,*) 'WRFSSTCpl_run: ESMF_FieldGet(dst_field,dst_array,rc) failed'
	1414	CALL wrf_error_fatal ( str )
	1415	ENDIF
	1416
	1417	! The redist routine uses information contained in the Fields and the
	1418	! Coupler VM object to call the communication routines to move the data.
	1419	! Because many Fields may share the same Grid association, the same
	1420	! routing information may be needed repeatedly. Route information is
	1421	! saved so the precomputed information can be retained. The following
	1422	! is an example of a Field redist call:
	1423	WRITE(str,*) 'WRFSSTCpl_run: calling ESMF_FieldRedist for <', &
	1424	TRIM(datanames(i)),'>...'
	1425	CALL wrf_debug ( 100 , TRIM(str) )
	1426	CALL ESMF_ArrayRedist( src_array, dst_array, routehandle, rc=rc )
	1427	IF ( rc /= ESMF_SUCCESS ) THEN
	1428	CALL wrf_error_fatal ( 'WRFSSTCpl_run: ESMF_FieldRedist failed' )
	1429	ENDIF
	1430	WRITE(str,*) 'WRFSSTCpl_run: back from ESMF_FieldRedist for <', &
	1431	TRIM(datanames(i)),'>...'
	1432	CALL wrf_debug ( 100 , TRIM(str) )
	1433
	1434	ENDDO
	1435
	1436	WRITE(str,*) 'WRFSSTCpl_run: end'
	1437	CALL wrf_debug ( 100 , TRIM(str) )
	1438
	1439	END SUBROUTINE WRFSSTCpl_run
	1440
	1441
	1442
	1443	SUBROUTINE WRFSSTCpl_final(comp, importState, exportState, clock, rc)
	1444	TYPE(ESMF_CplComp) :: comp
	1445	TYPE(ESMF_State), INTENT(INOUT) :: importState, exportState
	1446	TYPE(ESMF_Clock), INTENT(INOUT) :: clock
	1447	INTEGER, INTENT(OUT) :: rc
	1448	!<DESCRIPTION>
	1449	! WRF-SST coupler component finalize routine.
	1450	!
	1451	! The arguments are:
	1452	! comp Component
	1453	! importState Importstate
	1454	! exportState Exportstate
	1455	! clock External clock
	1456	! rc Return code; equals ESMF_SUCCESS if there are no errors,
	1457	! otherwise ESMF_FAILURE.
	1458	!</DESCRIPTION>
	1459
	1460	PRINT *, "DEBUG: Coupler Final starting"
	1461
	1462	! guilty until proven innocent
	1463	rc = ESMF_FAILURE
	1464
	1465	! Only thing to do here is release redist and route handles
	1466	IF ( fromWRF_rh_ready ) THEN
	1467	CALL ESMF_RouteHandleDestroy(fromWRF_rh, rc)
	1468	IF ( rc /= ESMF_SUCCESS ) THEN
	1469	CALL wrf_error_fatal ( 'WRFSSTCpl_final: ESMF_RouteHandleDestroy(fromWRF_rh) failed' )
	1470	ENDIF
	1471	ENDIF
	1472	IF ( fromSST_rh_ready ) THEN
	1473	CALL ESMF_RouteHandleDestroy(fromSST_rh, rc)
	1474	IF ( rc /= ESMF_SUCCESS ) THEN
	1475	CALL wrf_error_fatal ( 'WRFSSTCpl_final: ESMF_RouteHandleDestroy(fromSST_rh) failed' )
	1476	ENDIF
	1477	ENDIF
	1478
	1479	PRINT *, "DEBUG: Coupler Final returning"
	1480
	1481	END SUBROUTINE WRFSSTCpl_final
	1482
	1483
	1484	END MODULE module_wrfsst_coupler
	1485
	1486
	1487
	1488
	1489	PROGRAM wrf_SST_ESMF
	1490
	1491	!<DESCRIPTION>
	1492	! ESMF Application Wrapper for coupling WRF with a "dummy" component
	1493	! that simply reads SSTs from a file and sends them to WRF (one-way
	1494	! coupling). Fields are returned from WRF to SST via the coupler for
	1495	! self-test only.
	1496	!
	1497	! Note that, like other WRF coupling methods (MCEL, MCT), ESMF coupling is
	1498	! supported only via auxiliary input and history streams.
	1499	!
	1500	! This is the main program that creates the ESMF Gridded and Coupler
	1501	! Component.
	1502	!
	1503	! "init" looks like this:
	1504	! 1. Init phase 1 for WRF, sets WRF exportState metadata for "time"
	1505	! and "domain" information needed by WRF IOAPI (which is called from
	1506	! the SST component). It also sets up all WRF and WSF modules. Note
	1507	! that this must be called before SST phase-1 init because SST uses
	1508	! WRF IOAPI.
	1509	! 2. Init phase 1 for SST, sets "time" metadata in SST exportState.
	1510	! 3. Initialize coupler, passing decomposition metadata from WRF exportState
	1511	! to SST importState.
	1512	! 4. Resolve any "time" metadata inconsistencies and create top-level clock.
	1513	! 5. Init phase 2 for SST, gets "domain" information from importState,
	1514	! creates an ESMF_Grid based on "domain" information using the exact same
	1515	! method as WRF (so WRF IOAPI calls will work), and sets up SST
	1516	! importState and exportState.
	1517	! 6. Init phase 2 for WRF, runs up to the end of the head_grid I/O "training"
	1518	! phase (done in med_before_solve_io()). This initializes WRF
	1519	! importState and exportState prior to the first coupling step during the
	1520	! "run" loop. Note that this only works for head_grid at present because
	1521	! recursion in WRF traversal of subdomains is not dealt with yet and
	1522	! because the code that populates the WRF importState and exportState is
	1523	! not yet sophisticated enough to handle creating and destroying nested
	1524	! domains at any time during the model run.
	1525	!TODO: ESMF auxio must begin at the start of the run. Remove this
	1526	!TODO: restriction later, if needed.
	1527	!
	1528	!TODO: Note that coupling is currently limited to one auxin plus one auxout
	1529	!TODO: streams. Extension to multiple pairs of auxio streams requires
	1530	!TODO: nested states (one for each auxio stream pair).
	1531	!TODO: For now, only support one input and/or one output stream via
	1532	!TODO: io_esmf. This condition is asserted in
	1533	!TODO: ext_esmf_open_for_read_begin() and
	1534	!TODO: ext_esmf_open_for_write_begin().
	1535	!
	1536	! "run" loop looks like this:
	1537	! 1. Run SST phase 1, reads SST from file and writes it to SST exportState
	1538	! for coupling to WRF.
	1539	! 2. Couple SST exportState -> WRF importState. First iteration: set up
	1540	! SST->WRF routeHandle via lazy evaluation.
	1541	! 3. Run WRF. First iteration: head_grid resumes after I/O "training"
	1542	! phase. Other iterations and domains: run normally.
	1543	! Read WRF importState and write WRF exportState (via med_before_solve_io()).
	1544	! Note that WRF assigns sst -> tsk for sea points in
	1545	! share/module_soil_pre.F.
	1546	! 4. Couple WRF exportState -> SST importState. First iteration: set up
	1547	! WRF->SST routeHandle via lazy evaluation.
	1548	! 5. Run SST phase 2, compare SST from file with SST from WRF (via
	1549	! SST importState) and error-exit if they differ.
	1550	! 6. Advance clock and goto step 1
	1551	!
	1552	! "finalize" is trivial, except for destruction of ESMF objects which is
	1553	! quite non-trivial at the moment.
	1554	!
	1555	!</DESCRIPTION>
	1556
	1557	! WRF registration routine
	1558	USE module_wrf_setservices, ONLY: WRF_register
	1559	! SST registration routine
	1560	USE module_sst_setservices, ONLY: SST_register
	1561	! WRF-SST coupler registration routine
	1562	USE module_wrfsst_coupler, ONLY: WRFSSTCpl_register
	1563	! ESMF module, defines all ESMF data types and procedures
	1564	USE ESMF_Mod
	1565	! Not-yet-implemented ESMF features
	1566	USE module_esmf_extensions
	1567	! Component-independent utilities
	1568	USE module_metadatautils, ONLY: GetTimesFromStates
	1569
	1570	IMPLICIT NONE
	1571
	1572	! Local variables
	1573
	1574	! Components
	1575	TYPE(ESMF_GridComp) :: compGriddedWRF ! WRF
	1576	TYPE(ESMF_GridComp) :: compGriddedSST ! SST reader
	1577	TYPE(ESMF_CplComp) :: compCplWRFSST ! WRF-SST coupler
	1578
	1579	! State, Virtual Machine, and DELayout
	1580	TYPE(ESMF_VM) :: vm
	1581	TYPE(ESMF_State) :: importStateWRF, exportStateWRF
	1582	TYPE(ESMF_State) :: importStateSST, exportStateSST
	1583
	1584	! A clock, some times, and a time step
	1585	TYPE(ESMF_Clock) :: driverClock
	1586	TYPE(ESMF_Time) :: startTime
	1587	TYPE(ESMF_Time) :: stopTime
	1588	TYPE(ESMF_TimeInterval) :: couplingInterval
	1589
	1590	! other misc stuff
	1591	TYPE(ESMF_State) :: tmpState
	1592	INTEGER :: timestepdebug
	1593
	1594	! Return codes for error checks
	1595	INTEGER :: rc
	1596	CHARACTER (ESMF_MAXSTR) :: str
	1597
	1598	! debugging
	1599	CHARACTER(LEN=256) :: couplingIntervalString
	1600	integer(ESMF_KIND_I4) :: timevals(6)
	1601
	1602
	1603	! Warn users that this is not yet ready for general use.
	1604	PRINT *, ' W A R N I N G '
	1605	PRINT *, ' ESMF COUPLING CAPABILITY IS EXPERIMENTAL AND UNSUPPORTED '
	1606	PRINT *, ' IN THIS VERSION OF WRF-CPL-SST '
	1607	PRINT *, ' U S E A T Y O U R O W N R I S K '
	1608
	1609	! Initialize ESMF, get the default Global VM, and set
	1610	! the default calendar to be Gregorian.
	1611	CALL ESMF_Initialize( vm=vm, defaultCalendar=ESMF_CAL_GREGORIAN, defaultlogtype=ESMF_LOG_MULTI,rc=rc )
	1612	IF ( rc /= ESMF_SUCCESS ) THEN
	1613	PRINT *, 'wrf_SST_ESMF: ESMF_Initialize failed'
	1614	ENDIF
	1615	! Note: wrf_debug and wrf_error_fatal are not initialized yet
	1616	PRINT *, 'DEBUG wrf_SST_ESMF: returned from ESMF_Initialize'
	1617	CALL ESMF_SetInitialized() ! eliminate this once ESMF does it internally
	1618
	1619	! Create the WRF Gridded Component, passing in the default VM.
	1620	compGriddedWRF = ESMF_GridCompCreate(parentVm=vm, name="WRF Model", rc=rc)
	1621	IF ( rc /= ESMF_SUCCESS ) THEN
	1622	PRINT *, 'wrf_SST_ESMF: ESMF_GridCompCreate(WRF Model) failed'
	1623	ENDIF
	1624
	1625	! Create the SST Gridded Component, passing in the default VM.
	1626	compGriddedSST = ESMF_GridCompCreate(parentVm=vm, name="SST Dummy Model", rc=rc)
	1627	IF ( rc /= ESMF_SUCCESS ) THEN
	1628	PRINT *, 'wrf_SST_ESMF: ESMF_GridCompCreate(WRF Dummy Model) failed'
	1629	ENDIF
	1630
	1631	! Create the WRF-SST Coupler Component, passing in the default VM.
	1632	compCplWRFSST = ESMF_CplCompCreate(parentVm=vm, name="WRF-SST Coupler", rc=rc)
	1633	IF ( rc /= ESMF_SUCCESS ) THEN
	1634	PRINT *, 'wrf_SST_ESMF: ESMF_CplCompCreate failed'
	1635	ENDIF
	1636
	1637	! Create empty import and export states for WRF
	1638	importStateWRF = ESMF_StateCreate(stateName="WRF Import State", statetype=ESMF_STATE_IMPORT, rc=rc)
	1639	IF ( rc /= ESMF_SUCCESS ) THEN
	1640	PRINT *, 'wrf_SST_ESMF: ESMF_StateCreate(WRF Import State) failed'
	1641	ENDIF
	1642	exportStateWRF = ESMF_StateCreate(stateName="WRF Export State", statetype=ESMF_STATE_EXPORT, rc=rc)
	1643	IF ( rc /= ESMF_SUCCESS ) THEN
	1644	PRINT *, 'wrf_SST_ESMF: ESMF_StateCreate(WRF Export State) failed'
	1645	ENDIF
	1646
	1647	! Create empty import and export states for SST
	1648	importStateSST = ESMF_StateCreate(stateName="SST Import State", statetype=ESMF_STATE_IMPORT, rc=rc)
	1649	IF ( rc /= ESMF_SUCCESS ) THEN
	1650	PRINT *, 'wrf_SST_ESMF: ESMF_StateCreate(SST Import State) failed'
	1651	ENDIF
	1652	exportStateSST = ESMF_StateCreate(stateName="SST Export State", statetype=ESMF_STATE_EXPORT, rc=rc)
	1653	IF ( rc /= ESMF_SUCCESS ) THEN
	1654	PRINT *, 'wrf_SST_ESMF: ESMF_StateCreate(SST Export State) failed'
	1655	ENDIF
	1656
	1657	! Register the WRF Gridded Component
	1658	CALL ESMF_GridCompSetServices(compGriddedWRF, WRF_register, rc)
	1659	IF ( rc /= ESMF_SUCCESS ) THEN
	1660	PRINT *, 'wrf_SST_ESMF: ESMF_GridCompSetServices(compGriddedWRF) failed'
	1661	ENDIF
	1662
	1663	! Register the SST Gridded Component
	1664	CALL ESMF_GridCompSetServices(compGriddedSST, SST_register, rc)
	1665	IF ( rc /= ESMF_SUCCESS ) THEN
	1666	PRINT *, 'wrf_SST_ESMF: ESMF_GridCompSetServices(compGriddedSST) failed'
	1667	ENDIF
	1668
	1669	! Register the WRF-SST Coupler Component
	1670	CALL ESMF_CplCompSetServices(compCplWRFSST, WRFSSTCpl_register, rc)
	1671	IF ( rc /= ESMF_SUCCESS ) THEN
	1672	PRINT *, 'wrf_SST_ESMF: ESMF_CplCompSetServices failed'
	1673	ENDIF
	1674
	1675	! Create top-level clock. There is no way to create an "empty" clock, so
	1676	! stuff in bogus values for start time, stop time, and time step and fix
	1677	! them after gridded component "init" phases return.
	1678	CALL ESMF_TimeSet(startTime, yy=2000, mm=1, dd=1, &
	1679	h=0, m=0, s=0, rc=rc)
	1680	IF ( rc /= ESMF_SUCCESS ) THEN
	1681	PRINT *, 'wrf_SST_ESMF: ESMF_TimeSet(startTime) failed'
	1682	ENDIF
	1683	CALL ESMF_TimeSet(stopTime, yy=2000, mm=1, dd=1, &
	1684	h=12, m=0, s=0, rc=rc)
	1685	IF ( rc /= ESMF_SUCCESS ) THEN
	1686	PRINT *, 'wrf_SST_ESMF: ESMF_TimeSet(stopTime) failed'
	1687	ENDIF
	1688	CALL ESMF_TimeIntervalSet(couplingInterval, s=2, rc=rc)
	1689	IF ( rc /= ESMF_SUCCESS ) THEN
	1690	PRINT *, 'wrf_SST_ESMF: ESMF_TimeIntervalSet failed'
	1691	ENDIF
	1692	driverClock = ESMF_ClockCreate(timeStep=couplingInterval, &
	1693	startTime=startTime, &
	1694	stopTime=stopTime, rc=rc)
	1695	IF ( rc /= ESMF_SUCCESS ) THEN
	1696	PRINT *, 'wrf_SST_ESMF: ESMF_ClockCreate failed'
	1697	ENDIF
	1698
	1699	! Init, Run, and Finalize section
	1700
	1701	! Init...
	1702	! initialize WRF, phase 1
	1703	! Phase 1 init returns WRF time and decomposition information as
	1704	! exportState metadata.
	1705	PRINT *, 'DEBUG wrf_SST_ESMF: calling phase-1 WRF init (wrf_component_init1)'
	1706	CALL ESMF_GridCompInitialize(compGriddedWRF, importStateWRF, &
	1707	exportStateWRF, driverClock, phase=1, rc=rc)
	1708	call esmf_attributeget(exportstatewrf,'ComponentCouplingInterval',size(timevals),timevals,rc=rc)
	1709	write(0,*) 'exportStateWRF year ',timevals(1),__LINE__
	1710	write(0,*) 'exportStateWRF month ',timevals(2),__LINE__
	1711	write(0,*) 'exportStateWRF day ',timevals(3),__LINE__
	1712	write(0,*) 'exportStateWRF hour ',timevals(4),__LINE__
	1713	write(0,*) 'exportStateWRF minute ',timevals(5),__LINE__
	1714	write(0,*) 'exportStateWRF second ',timevals(6),__LINE__
	1715	! Note: wrf_debug and wrf_error_fatal are now initialized
	1716	IF ( rc /= ESMF_SUCCESS ) THEN
	1717	CALL wrf_error_fatal ( 'wrf_SST_ESMF: ESMF_GridCompInitialize(WRF phase 1) failed' )
	1718	ENDIF
	1719
	1720	! initialize SST, phase 1
	1721	! Phase 1 init returns SST time information as
	1722	! exportState metadata.
	1723	PRINT *, 'DEBUG wrf_SST_ESMF: calling phase-1 SST init (sst_component_init1)'
	1724	CALL ESMF_GridCompInitialize(compGriddedSST, importStateSST, &
	1725	exportStateSST, driverClock, phase=1, rc=rc)
	1726	call esmf_attributeget(exportstatesst,'ComponentCouplingInterval',size(timevals),timevals,rc=rc)
	1727	write(0,*) 'exportStateSST year ',timevals(1),__LINE__
	1728	write(0,*) 'exportStateSST month ',timevals(2),__LINE__
	1729	write(0,*) 'exportStateSST day ',timevals(3),__LINE__
	1730	write(0,*) 'exportStateSST hour ',timevals(4),__LINE__
	1731	write(0,*) 'exportStateSST minute ',timevals(5),__LINE__
	1732	write(0,*) 'exportStateSST second ',timevals(6),__LINE__
	1733	IF ( rc /= ESMF_SUCCESS ) THEN
	1734	CALL wrf_error_fatal ( 'wrf_SST_ESMF: ESMF_GridCompInitialize(SST phase 1) failed' )
	1735	ENDIF
	1736
	1737	! Reconcile clock settings from WRF and SST components to set up
	1738	! top-level clock. These are passed back from each "init" as attributes
	1739	! on exportState*.
	1740	! Stuff both States into a single State to pass into GetTimesFromStates()
	1741	! which is smart enough to deal with a Composite.
	1742	PRINT *, 'DEBUG wrf_SST_ESMF: reconciling clock from WRF and SST components'
	1743	tmpState = ESMF_StateCreate( rc=rc )
	1744	IF ( rc /= ESMF_SUCCESS ) THEN
	1745	CALL wrf_error_fatal ( 'wrf_SST_ESMF: ESMF_StateCreate(tmpState) failed' )
	1746	ENDIF
	1747	CALL ESMF_StateAdd( tmpState, exportStateWRF, rc )
	1748	IF ( rc /= ESMF_SUCCESS ) THEN
	1749	CALL wrf_error_fatal ( 'wrf_SST_ESMF: ESMF_StateAdd(exportStateWRF) failed' )
	1750	ENDIF
	1751	CALL ESMF_StateAdd( tmpState, exportStateSST, rc )
	1752	IF ( rc /= ESMF_SUCCESS ) THEN
	1753	CALL wrf_error_fatal ( 'wrf_SST_ESMF: ESMF_StateAdd(exportStateSST) failed' )
	1754	ENDIF
	1755	CALL GetTimesFromStates( tmpState, startTime, stopTime, couplingInterval )
	1756	CALL ESMF_TimeIntervalGet( couplingInterval, TimeString=couplingIntervalString, &
	1757	rc=rc )
	1758	IF ( rc /= ESMF_SUCCESS ) THEN
	1759	CALL wrf_error_fatal ( 'wrf_SST_ESMF: ESMF_TimeIntervalGet failed' )
	1760	ENDIF
	1761	CALL wrf_debug( 100, 'wrf_SST_ESMF: couplingInterval = '//TRIM(couplingIntervalString) )
	1762	CALL ESMF_StateDestroy( tmpState, rc )
	1763	IF ( rc /= ESMF_SUCCESS ) THEN
	1764	CALL wrf_error_fatal ( 'wrf_SST_ESMF: ESMF_StateDestroy(tmpState) failed' )
	1765	ENDIF
	1766	! update driver clock
	1767	CALL ESMF_ClockDestroy(driverClock, rc)
	1768	IF ( rc /= ESMF_SUCCESS ) THEN
	1769	CALL wrf_error_fatal ( 'wrf_SST_ESMF: ESMF_ClockDestroy failed' )
	1770	ENDIF
	1771	driverClock = ESMF_ClockCreate(timeStep=couplingInterval, &
	1772	startTime=startTime, &
	1773	stopTime=stopTime, rc=rc)
	1774	IF ( rc /= ESMF_SUCCESS ) THEN
	1775	CALL wrf_error_fatal ( 'wrf_SST_ESMF: ESMF_ClockCreate(driverClock) failed' )
	1776	ENDIF
	1777	PRINT *, 'DEBUG wrf_SST_ESMF: done reconciling clock from WRF and SST components'
	1778	CALL wrf_clockprint(50, driverClock, &
	1779	'DEBUG wrf_SST_ESMF: driverClock after creation,')
	1780
	1781	! initialize WRF-SST Coupler
	1782	PRINT *, 'DEBUG wrf_SST_ESMF: calling phase-1 CPL init (WRFSSTCpl_init)'
	1783	CALL ESMF_CplCompInitialize(compCplWRFSST, exportStateWRF, &
	1784	importStateSST, driverClock, rc=rc)
	1785	IF ( rc /= ESMF_SUCCESS ) THEN
	1786	CALL wrf_error_fatal ( 'wrf_SST_ESMF: ESMF_CplCompInitialize(WRF -> SST) failed' )
	1787	ENDIF
	1788
	1789	! TBH: this bit is not needed, but would be in general
	1790	! CALL ESMF_CplCompInitialize(compCplWRFSST, exportStateSST, &
	1791	! importStateWRF, driverClock, rc=rc)
	1792	! IF ( rc /= ESMF_SUCCESS ) THEN
	1793	! CALL wrf_error_fatal ( 'wrf_SST_ESMF: ESMF_CplCompInitialize(SST -> WRF) failed' )
	1794	! ENDIF
	1795
	1796	! initialize SST, phase 2
	1797	WRITE(str,'(A)') 'PROGRAM wrf_SST_ESMF: Calling phase-2 init for SST (sst_component_init2)'
	1798	CALL wrf_debug ( 100 , TRIM(str) )
	1799	CALL ESMF_GridCompInitialize(compGriddedSST, importStateSST, &
	1800	exportStateSST, driverClock, phase=2, rc=rc)
	1801	WRITE(str,'(A)') 'PROGRAM wrf_SST_ESMF: back from phase-2 init for SST'
	1802	CALL wrf_debug ( 100 , TRIM(str) )
	1803	IF ( rc /= ESMF_SUCCESS ) THEN
	1804	CALL wrf_error_fatal ( 'wrf_SST_ESMF: ESMF_GridCompInitialize(SST phase 2) failed' )
	1805	ENDIF
	1806
	1807	! initialize WRF, phase 2
	1808	! Phase 2 init sets up WRF importState and exportState.
	1809	WRITE(str,'(A)') 'PROGRAM wrf_SST_ESMF: Calling phase-2 init for WRF (wrf_component_init2)'
	1810	CALL wrf_debug ( 100 , TRIM(str) )
	1811	CALL ESMF_GridCompInitialize(compGriddedWRF, importStateWRF, &
	1812	exportStateWRF, driverClock, phase=2, rc=rc)
	1813	WRITE(str,'(A)') 'PROGRAM wrf_SST_ESMF: back from phase-2 init for WRF'
	1814	CALL wrf_debug ( 100 , TRIM(str) )
	1815	IF ( rc /= ESMF_SUCCESS ) THEN
	1816	CALL wrf_error_fatal ( 'wrf_SST_ESMF: ESMF_GridCompInitialize(WRF phase 2) failed' )
	1817	ENDIF
	1818
	1819	CALL wrf_clockprint(50, driverClock, &
	1820	'DEBUG wrf_SST_ESMF: driverClock before main time-stepping loop,')
	1821	! Run...
	1822	! main time-stepping loop
	1823	timestepdebug = 0
	1824	DO WHILE ( .NOT. ESMF_ClockIsStopTime(driverClock, rc) )
	1825
	1826	timestepdebug = timestepdebug + 1
	1827	WRITE(str,'(A,I8)') 'PROGRAM wrf_SST_ESMF: Top of time-stepping loop, timestepdebug = ',timestepdebug
	1828	CALL wrf_debug ( 100 , TRIM(str) )
	1829	CALL wrf_clockprint(50, driverClock, &
	1830	'DEBUG wrf_SST_ESMF: driverClock at top of time-stepping loop,')
	1831
	1832	! Run SST phase 1
	1833	WRITE(str,'(A)') 'PROGRAM wrf_SST_ESMF: Calling phase-1 run for SST (sst_component_run1)'
	1834	CALL wrf_debug ( 100 , TRIM(str) )
	1835	CALL ESMF_GridCompRun(compGriddedSST, importStateSST, exportStateSST, &
	1836	driverClock, phase=1, rc=rc)
	1837	IF ( rc /= ESMF_SUCCESS ) THEN
	1838	CALL wrf_error_fatal ( 'wrf_SST_ESMF: ESMF_GridCompRun(SST phase 1) failed' )
	1839	ENDIF
	1840	WRITE(str,'(A)') 'PROGRAM wrf_SST_ESMF: back from phase-1 run for SST (sst_component_run1)'
	1841	CALL wrf_debug ( 100 , TRIM(str) )
	1842
	1843	! couple SST export -> WRF import
	1844	WRITE(str,'(A)') 'PROGRAM wrf_SST_ESMF: Calling run for CPL SST->WRF (WRFSSTCpl_run)'
	1845	CALL wrf_debug ( 100 , TRIM(str) )
	1846	CALL ESMF_CplCompRun(compCplWRFSST, exportStateSST, &
	1847	importStateWRF, driverClock, rc=rc)
	1848	IF ( rc /= ESMF_SUCCESS ) THEN
	1849	CALL wrf_error_fatal ( 'wrf_SST_ESMF: ESMF_CplCompRun(SST -> WRF) failed' )
	1850	ENDIF
	1851	WRITE(str,'(A)') 'PROGRAM wrf_SST_ESMF: back from run for CPL SST->WRF (WRFSSTCpl_run)'
	1852	CALL wrf_debug ( 100 , TRIM(str) )
	1853
	1854	! Run WRF
	1855	WRITE(str,'(A)') 'PROGRAM wrf_SST_ESMF: Calling run for WRF (wrf_component_run)'
	1856	CALL wrf_debug ( 100 , TRIM(str) )
	1857	CALL ESMF_GridCompRun(compGriddedWRF, importStateWRF, exportStateWRF, &
	1858	driverClock, rc=rc)
	1859	IF ( rc /= ESMF_SUCCESS ) THEN
	1860	CALL wrf_error_fatal ( 'wrf_SST_ESMF: ESMF_GridCompRun(WRF) failed' )
	1861	ENDIF
	1862	WRITE(str,'(A)') 'PROGRAM wrf_SST_ESMF: back from run for WRF (wrf_component_run)'
	1863	CALL wrf_debug ( 100 , TRIM(str) )
	1864
	1865	! couple WRF export -> SST import
	1866	WRITE(str,'(A)') 'PROGRAM wrf_SST_ESMF: Calling run for CPL WRF->SST (WRFSSTCpl_run)'
	1867	CALL wrf_debug ( 100 , TRIM(str) )
	1868	CALL ESMF_CplCompRun(compCplWRFSST, exportStateWRF, &
	1869	importStateSST, driverClock, rc=rc)
	1870	IF ( rc /= ESMF_SUCCESS ) THEN
	1871	CALL wrf_error_fatal ( 'wrf_SST_ESMF: ESMF_CplCompRun(WRF -> SST) failed' )
	1872	ENDIF
	1873	WRITE(str,'(A)') 'PROGRAM wrf_SST_ESMF: back from run for CPL WRF->SST (WRFSSTCpl_run)'
	1874	CALL wrf_debug ( 100 , TRIM(str) )
	1875
	1876	! Run SST phase 2
	1877	WRITE(str,'(A)') 'PROGRAM wrf_SST_ESMF: Calling phase-2 run for SST (sst_component_run2)'
	1878	CALL wrf_debug ( 100 , TRIM(str) )
	1879	CALL ESMF_GridCompRun(compGriddedSST, importStateSST, exportStateSST, &
	1880	driverClock, phase=2, rc=rc)
	1881	IF ( rc /= ESMF_SUCCESS ) THEN
	1882	CALL wrf_error_fatal ( 'wrf_SST_ESMF: ESMF_GridCompRun(SST phase 2) failed' )
	1883	ENDIF
	1884	WRITE(str,'(A)') 'PROGRAM wrf_SST_ESMF: back from phase-2 run for SST (sst_component_run2)'
	1885	CALL wrf_debug ( 100 , TRIM(str) )
	1886
	1887	! advance clock to next coupling time step
	1888	WRITE(str,'(A)') 'PROGRAM wrf_SST_ESMF: advancing clock'
	1889	CALL wrf_debug ( 100 , TRIM(str) )
	1890	CALL ESMF_ClockAdvance( driverClock, rc=rc )
	1891	IF ( rc /= ESMF_SUCCESS ) THEN
	1892	CALL wrf_error_fatal ( 'wrf_SST_ESMF: ESMF_ClockAdvance failed' )
	1893	ENDIF
	1894	WRITE(str,'(A)') 'PROGRAM wrf_SST_ESMF: done advancing clock'
	1895	CALL wrf_debug ( 100 , TRIM(str) )
	1896
	1897	CALL wrf_clockprint(50, driverClock, &
	1898	'DEBUG wrf_SST_ESMF: driverClock at end of time-stepping loop,')
	1899
	1900	ENDDO
	1901
	1902	WRITE(str,'(A)') 'PROGRAM wrf_SST_ESMF: done with time-stepping loop'
	1903	CALL wrf_debug ( 100 , TRIM(str) )
	1904
	1905	! clean up SST
	1906	CALL ESMF_GridCompFinalize(compGriddedSST, importStateSST, exportStateSST, &
	1907	driverClock, rc=rc)
	1908	IF ( rc /= ESMF_SUCCESS ) THEN
	1909	CALL wrf_error_fatal ( 'wrf_SST_ESMF: ESMF_GridCompFinalize(compGriddedSST) failed' )
	1910	ENDIF
	1911
	1912	! clean up compCplWRFSST
	1913	CALL ESMF_CplCompFinalize( compCplWRFSST, exportStateWRF, importStateSST, &
	1914	driverClock, rc=rc)
	1915	IF ( rc /= ESMF_SUCCESS ) THEN
	1916	CALL wrf_error_fatal ( 'wrf_SST_ESMF: ESMF_CplCompFinalize(compCplWRFSST) failed' )
	1917	ENDIF
	1918
	1919	! clean up WRF
	1920	! must do this AFTER clean up of SST since SST uses WRF IOAPI
	1921	CALL ESMF_GridCompFinalize(compGriddedWRF, importStateWRF, exportStateWRF, &
	1922	driverClock, rc=rc)
	1923	IF ( rc /= ESMF_SUCCESS ) THEN
	1924	CALL wrf_error_fatal ( 'wrf_SST_ESMF: ESMF_GridCompFinalize(compGriddedWRF) failed' )
	1925	ENDIF
	1926
	1927	! Clean up
	1928
	1929	CALL ESMF_GridCompDestroy(compGriddedWRF, rc)
	1930	IF ( rc /= ESMF_SUCCESS ) THEN
	1931	CALL wrf_error_fatal ( 'wrf_SST_ESMF: ESMF_GridCompDestroy(compGriddedWRF) failed' )
	1932	ENDIF
	1933	CALL ESMF_StateDestroy(importStateWRF, rc)
	1934	IF ( rc /= ESMF_SUCCESS ) THEN
	1935	CALL wrf_error_fatal ( 'wrf_SST_ESMF: ESMF_StateDestroy(importStateWRF) failed' )
	1936	ENDIF
	1937	CALL ESMF_StateDestroy(exportStateWRF, rc)
	1938	IF ( rc /= ESMF_SUCCESS ) THEN
	1939	CALL wrf_error_fatal ( 'wrf_SST_ESMF: ESMF_StateDestroy(exportStateWRF) failed' )
	1940	ENDIF
	1941	CALL ESMF_StateDestroy(importStateSST, rc)
	1942	IF ( rc /= ESMF_SUCCESS ) THEN
	1943	CALL wrf_error_fatal ( 'wrf_SST_ESMF: ESMF_StateDestroy(importStateSST) failed' )
	1944	ENDIF
	1945	CALL ESMF_StateDestroy(exportStateSST, rc)
	1946	IF ( rc /= ESMF_SUCCESS ) THEN
	1947	CALL wrf_error_fatal ( 'wrf_SST_ESMF: ESMF_StateDestroy(exportStateSST) failed' )
	1948	ENDIF
	1949	CALL ESMF_ClockDestroy(driverClock, rc)
	1950	IF ( rc /= ESMF_SUCCESS ) THEN
	1951	CALL wrf_error_fatal ( 'wrf_SST_ESMF: ESMF_ClockDestroy(driverClock) failed' )
	1952	ENDIF
	1953
	1954	CALL ESMF_Finalize( rc=rc )
	1955	IF ( rc /= ESMF_SUCCESS ) THEN
	1956	CALL wrf_error_fatal ( 'wrf_SST_ESMF: ESMF_Finalize failed' )
	1957	ENDIF
	1958
	1959	END PROGRAM wrf_SST_ESMF
	1960
	1961

Note: See TracBrowser for help on using the repository browser.

Download in other formats:

Original Format