Forcing, both subsidence and large scale. More...

Functions/Subroutines
type(component_descriptor_type) function, public	forcing_get_descriptor ()
	Provides the component descriptor for the core to register. More...

subroutine	field_information_retrieval_callback (current_state, name, field_information)
	Field information retrieval callback, this returns information for a specific components published field. More...

subroutine	field_value_retrieval_callback (current_state, name, field_value)
	Field value retrieval callback, this returns the value of a specific published field. More...

subroutine	init_callback (current_state)
	Initialises the forcing data structures. More...

subroutine	timestep_callback (current_state)
	Called for each data column and will determine the forcing values in x and y which are then applied to the field source terms. More...

subroutine	apply_subsidence_to_flow_fields (current_state)

subroutine	apply_subsidence_to_theta (current_state)

subroutine	apply_subsidence_to_q_fields (current_state)

subroutine	apply_time_independent_forcing_to_theta (current_state)

subroutine	apply_time_independent_forcing_to_q (current_state)

subroutine	apply_time_independent_forcing_to_u (current_state)

subroutine	apply_time_independent_forcing_to_v (current_state)

subroutine	finalisation_callback (current_state)
	Finalises the component Current model state. More...

real(kind=default_precision) function, dimension(size(diagnostics_summed))	get_averaged_diagnostics (current_state, diagnostics_summed)
	Averages some diagnostic values across all local horizontal points. More...

Variables
integer, parameter	divergence =0

integer, parameter	subsidence =1

integer, parameter	tendency =0

integer, parameter	relaxation =1

integer, parameter	increment =2

real(kind=default_precision), dimension(:), allocatable	theta_profile

real(kind=default_precision), dimension(:), allocatable	q_profile

real(kind=default_precision), dimension(:), allocatable	u_profile

real(kind=default_precision), dimension(:), allocatable	v_profile

real(kind=default_precision), dimension(:), allocatable	dtheta_profile

real(kind=default_precision), dimension(:), allocatable	dq_profile

real(kind=default_precision), dimension(:), allocatable	du_profile

real(kind=default_precision), dimension(:), allocatable	dv_profile

real(kind=default_precision), dimension(:), allocatable	du_profile_diag

real(kind=default_precision), dimension(:), allocatable	dv_profile_diag

real(kind=default_precision), dimension(:), allocatable	dtheta_profile_diag

real(kind=default_precision), dimension(:,:), allocatable	dq_profile_diag

real(kind=default_precision)	forcing_timescale_theta

real(kind=default_precision)	forcing_timescale_q

real(kind=default_precision)	forcing_timescale_u

real(kind=default_precision)	forcing_timescale_v

logical	l_constant_forcing_theta

logical	l_constant_forcing_q

logical	l_constant_forcing_u

logical	l_constant_forcing_v

integer	constant_forcing_type_theta =TENDENCY

integer	constant_forcing_type_q =TENDENCY

integer	constant_forcing_type_u =RELAXATION

integer	constant_forcing_type_v =RELAXATION

logical	l_constant_forcing_theta_z2pressure

logical	relax_to_initial_u_profile

logical	relax_to_initial_v_profile

logical	relax_to_initial_theta_profile

logical	l_subs_pl_theta

logical	l_subs_pl_q

logical	l_subs_local_theta

logical	l_subs_local_q

character(len=string_length), dimension(:), allocatable	names_force_pl_q

Detailed Description

Forcing, both subsidence and large scale.

Function/Subroutine Documentation

◆ apply_subsidence_to_flow_fields()

subroutine forcing_mod::apply_subsidence_to_flow_fields ( type(model_state_type), intent(inout) current_state )

private

Definition at line 515 of file forcing.F90.

     type(model_state_type), intent(inout) :: current_state
 
     integer :: k
     real(kind=DEFAULT_PRECISION) :: usub, vsub    
 
 
     if (l_subs_local_theta)then ! Use local gradients not global means
       u_profile(:)=current_state%zu%data(:,current_state%column_local_y,current_state%column_local_x)
       v_profile(:)=current_state%zv%data(:,current_state%column_local_y,current_state%column_local_x)
     else
       u_profile(:)=current_state%global_grid%configuration%vertical%olzubar(:)
       v_profile(:)=current_state%global_grid%configuration%vertical%olzvbar(:)
     end if
 
     do k=2,current_state%local_grid%size(z_index)-1                                                             
 #ifdef U_ACTIVE
       usub =  2.0 * (current_state%global_grid%configuration%vertical%w_subs(k-1)*              &
          current_state%global_grid%configuration%vertical%tzc1(k)*(u_profile(k)-u_profile(k-1)) &
            + current_state%global_grid%configuration%vertical%w_subs(k)*                        &
            current_state%global_grid%configuration%vertical%tzc2(k)*                            &
            (u_profile(k+1) - u_profile(k)))
       current_state%su%data(k,current_state%column_local_y,current_state%column_local_x) =      &
            current_state%su%data(k,current_state%column_local_y,current_state%column_local_x) - usub
 #endif
 #ifdef V_ACTIVE     
       vsub =  2.0 * (current_state%global_grid%configuration%vertical%w_subs(k-1)*              &
          current_state%global_grid%configuration%vertical%tzc1(k)*(v_profile(k)-v_profile(k-1)) &
          + current_state%global_grid%configuration%vertical%w_subs(k)*                          &
          current_state%global_grid%configuration%vertical%tzc2(k)*                              &
          (v_profile(k+1) - v_profile(k)))
       current_state%sv%data(k,current_state%column_local_y,current_state%column_local_x) =      &
            current_state%sv%data(k,current_state%column_local_y,current_state%column_local_x) - vsub
 #endif
     end do
     k=current_state%local_grid%size(z_index)
 #ifdef U_ACTIVE
     usub =  2.0 * (current_state%global_grid%configuration%vertical%w_subs(k-1)*                &
          current_state%global_grid%configuration%vertical%tzc1(k)*(u_profile(k)-u_profile(k-1)))
     current_state%su%data(k,current_state%column_local_y,current_state%column_local_x) =        &
          current_state%su%data(k,current_state%column_local_y,current_state%column_local_x) - usub
 #endif
 #ifdef V_ACTIVE
     vsub =  2.0 * (current_state%global_grid%configuration%vertical%w_subs(k-1)*                &
          current_state%global_grid%configuration%vertical%tzc1(k)*(v_profile(k)-v_profile(k-1)))
     current_state%sv%data(k,current_state%column_local_y,current_state%column_local_x) =        &
          current_state%sv%data(k,current_state%column_local_y,current_state%column_local_x) - vsub
 #endif

Here is the caller graph for this function:

◆ apply_subsidence_to_q_fields()

subroutine forcing_mod::apply_subsidence_to_q_fields ( type(model_state_type), intent(inout) current_state )

private

Definition at line 596 of file forcing.F90.

     type(model_state_type), intent(inout) :: current_state
 
     integer :: k, n
     real(kind=DEFAULT_PRECISION) :: qsub
 
 
     do n=1,current_state%number_q_fields
       if (l_subs_local_q)then ! Use local gradients not global means
         q_profile(:)=current_state%zq(n)%data(:,current_state%column_local_y,current_state%column_local_x)
       else
         q_profile(:)=current_state%global_grid%configuration%vertical%olzqbar(:,n)
       end if
       do k=2,current_state%local_grid%size(z_index)-1
         qsub = current_state%global_grid%configuration%vertical%w_subs(k)*  &
            (q_profile(k+1) - q_profile(k))*                               &
            current_state%global_grid%configuration%vertical%rdzn(k+1)
         current_state%sq(n)%data(k,current_state%column_local_y,current_state%column_local_x) = &
            current_state%sq(n)%data(k,current_state%column_local_y,current_state%column_local_x) - qsub
       end do
       k=current_state%local_grid%size(z_index)
       qsub = current_state%global_grid%configuration%vertical%w_subs(k)*    &
          (q_profile(k) - q_profile(k-1))*                                   &
          current_state%global_grid%configuration%vertical%rdzn(k)
       current_state%sq(n)%data(k,current_state%column_local_y,current_state%column_local_x) = &
          current_state%sq(n)%data(k,current_state%column_local_y,current_state%column_local_x) - qsub
     end do

Here is the caller graph for this function:

◆ apply_subsidence_to_theta()

subroutine forcing_mod::apply_subsidence_to_theta ( type(model_state_type), intent(inout) current_state )

private

Definition at line 565 of file forcing.F90.

     type(model_state_type), intent(inout) :: current_state
 
     integer :: k
     real(kind=DEFAULT_PRECISION) :: thsub
 
     if (l_subs_local_theta)then ! Use local gradients not global means
       theta_profile(:)=current_state%zth%data(:,current_state%column_local_y,current_state%column_local_x) &
          + current_state%global_grid%configuration%vertical%thref(:)
     else
       theta_profile(:)=current_state%global_grid%configuration%vertical%olzthbar(:) &
          + current_state%global_grid%configuration%vertical%thref(:)
     end if
 
     do k=2,current_state%local_grid%size(z_index)-1
       thsub = current_state%global_grid%configuration%vertical%w_subs(k)*   &
          (theta_profile(k+1) - theta_profile(k))*                           &
          current_state%global_grid%configuration%vertical%rdzn(k+1)
       
       current_state%sth%data(k,current_state%column_local_y,current_state%column_local_x) = &
            current_state%sth%data(k,current_state%column_local_y,current_state%column_local_x) - thsub
     end do
     k=current_state%local_grid%size(z_index)
     thsub = current_state%global_grid%configuration%vertical%w_subs(k)* &
        (theta_profile(k) - theta_profile(k-1))*                         &
          current_state%global_grid%configuration%vertical%rdzn(k)
 
     current_state%sth%data(k,current_state%column_local_y,current_state%column_local_x) = &
          current_state%sth%data(k,current_state%column_local_y,current_state%column_local_x) - thsub

Here is the caller graph for this function:

◆ apply_time_independent_forcing_to_q()

subroutine forcing_mod::apply_time_independent_forcing_to_q ( type(model_state_type), intent(inout) current_state )

private

Definition at line 656 of file forcing.F90.

     type(model_state_type), intent(inout) :: current_state
 
     integer :: n, k
     real(kind=DEFAULT_PRECISION) :: dtm_scale
 
     do n=1,current_state%number_q_fields
       if (current_state%l_forceq(n))then
         if (constant_forcing_type_q==tendency)then
           dtm_scale=1.0_default_precision
         else !  constant_forcing_type_q==(RELAXATION or INCREMENT)
           dtm_scale=1.0_default_precision/forcing_timescale_q
         end if
         
         if (constant_forcing_type_q==relaxation)then
           dq_profile(:)=dtm_scale * (current_state%global_grid%configuration%vertical%q_force(:,n) - &
              current_state%zq(n)%data(:,current_state%column_local_y,current_state%column_local_x))
         else !  constant_forcing_type_q==(TENDENCY or INCREMENT)
           dq_profile(:)=dtm_scale * current_state%global_grid%configuration%vertical%q_force(:,n)
         end if
 
         dq_profile_diag(:,n)=dq_profile_diag(:,n)+dq_profile
 
         do k=2,current_state%local_grid%size(z_index)-1
           current_state%sq(n)%data(k,current_state%column_local_y,current_state%column_local_x) = &
              current_state%sq(n)%data(k,current_state%column_local_y,current_state%column_local_x) &
              + dq_profile(k)
         end do
       end if
     end do
 

Here is the caller graph for this function:

◆ apply_time_independent_forcing_to_theta()

subroutine forcing_mod::apply_time_independent_forcing_to_theta ( type(model_state_type), intent(inout) current_state )

private

Definition at line 625 of file forcing.F90.

     type(model_state_type), intent(inout) :: current_state
 
     integer :: k
     real(kind=DEFAULT_PRECISION) :: dtm_scale
 
     if (constant_forcing_type_theta==tendency)then
       dtm_scale=1.0_default_precision
     else !  constant_forcing_type_theta==(RELAXATION or INCREMENT)
       dtm_scale=1.0_default_precision/forcing_timescale_theta
     end if
     
     if (constant_forcing_type_theta==relaxation)then
       dtheta_profile(:)=dtm_scale * (current_state%global_grid%configuration%vertical%theta_force(:) - &
          current_state%zth%data(:,current_state%column_local_y,current_state%column_local_x) -       &
          current_state%global_grid%configuration%vertical%thref(:))
     else !  constant_forcing_type_theta==(TENDENCY or INCREMENT)
       dtheta_profile(:)=dtm_scale * current_state%global_grid%configuration%vertical%theta_force(:)
    end if
 
 
     dtheta_profile_diag=dtheta_profile_diag+(dtheta_profile)
 
     do k=2,current_state%local_grid%size(z_index)-1
       current_state%sth%data(k,current_state%column_local_y,current_state%column_local_x) = &
            current_state%sth%data(k,current_state%column_local_y,current_state%column_local_x) &
            + dtheta_profile(k)
     end do 
 

Here is the caller graph for this function:

◆ apply_time_independent_forcing_to_u()

subroutine forcing_mod::apply_time_independent_forcing_to_u ( type(model_state_type), intent(inout) current_state )

private

Definition at line 689 of file forcing.F90.

     type(model_state_type), intent(inout) :: current_state
 
     integer :: k
     real(kind=DEFAULT_PRECISION) :: dtm_scale
 
     if (constant_forcing_type_u==tendency)then
       dtm_scale=1.0_default_precision
     else !  constant_forcing_type_u==(RELAXATION or INCREMENT)
       dtm_scale=1.0_default_precision/forcing_timescale_u
     end if
     
     if (constant_forcing_type_u==relaxation)then
       du_profile(:)=dtm_scale * (current_state%global_grid%configuration%vertical%u_force(:) - &
            current_state%global_grid%configuration%vertical%olzubar(:))
     else !  constant_forcing_type_u==(TENDENCY or INCREMENT)
       du_profile(:)=dtm_scale * current_state%global_grid%configuration%vertical%u_force(:)
     end if
 
     du_profile_diag=du_profile_diag+du_profile
 
     do k=2,current_state%local_grid%size(z_index)-1
       current_state%su%data(k,current_state%column_local_y,current_state%column_local_x) = &
            current_state%su%data(k,current_state%column_local_y,current_state%column_local_x) &
            + du_profile(k)
     end do
 

Here is the caller graph for this function:

◆ apply_time_independent_forcing_to_v()

subroutine forcing_mod::apply_time_independent_forcing_to_v ( type(model_state_type), intent(inout) current_state )

private

Definition at line 718 of file forcing.F90.

     type(model_state_type), intent(inout) :: current_state
 
     integer :: k
     real(kind=DEFAULT_PRECISION) :: dtm_scale
 
     if (constant_forcing_type_v==tendency)then
       dtm_scale=1.0_default_precision
     else !  constant_forcing_type_v==(RELAXATION or INCREMENT)
       dtm_scale=1.0_default_precision/forcing_timescale_v
     end if
     
     if (constant_forcing_type_v==relaxation)then
       dv_profile(:)=dtm_scale * (current_state%global_grid%configuration%vertical%v_force(:) - &
            current_state%global_grid%configuration%vertical%olzvbar(:) )
     else !  constant_forcing_type_v==(TENDENCY or INCREMENT)
       dv_profile(:)=dtm_scale * current_state%global_grid%configuration%vertical%v_force(:)
     end if
 
     dv_profile_diag=dv_profile_diag+dv_profile
 
     do k=2,current_state%local_grid%size(z_index)-1
       current_state%sv%data(k,current_state%column_local_y,current_state%column_local_x) = &
            current_state%sv%data(k,current_state%column_local_y,current_state%column_local_x) &
            + dv_profile(k)
     end do

Here is the caller graph for this function:

◆ field_information_retrieval_callback()

subroutine forcing_mod::field_information_retrieval_callback	(	type(model_state_type), intent(inout), target	current_state,
		character(len=*), intent(in)	name,
		type(component_field_information_type), intent(out)	field_information
	)

private

Field information retrieval callback, this returns information for a specific components published field.

Parameters

current_state	Current model state
name	The name of the field to retrieve information for
field_information	Populated with information about the field

Definition at line 103 of file forcing.F90.

     type(model_state_type), target, intent(inout) :: current_state
     character(len=*), intent(in) :: name
     type(component_field_information_type), intent(out) :: field_information
 
     field_information%field_type=component_array_field_type
     field_information%data_type=component_double_data_type
     field_information%number_dimensions=1
     field_information%dimension_sizes(1)=current_state%local_grid%size(z_index)
 
     if (name .eq. "u_subsidence") then
       field_information%enabled=current_state%u%active .and. l_subs_pl_theta .and. &
            allocated(current_state%global_grid%configuration%vertical%olzubar)
     else if (name .eq. "v_subsidence") then
       field_information%enabled=current_state%v%active .and. l_subs_pl_theta .and. &
            allocated(current_state%global_grid%configuration%vertical%olzvbar)
     else if (name .eq. "th_subsidence") then
       field_information%enabled=current_state%th%active .and. l_subs_pl_theta .and. &
            allocated(current_state%global_grid%configuration%vertical%olzthbar)
     else if (name .eq. "q_subsidence") then
       field_information%number_dimensions=2
       field_information%dimension_sizes(2)=current_state%number_q_fields
       field_information%enabled=current_state%number_q_fields .gt. 0 .and. l_subs_pl_q .and. &
            allocated(current_state%global_grid%configuration%vertical%olzqbar)
     else if (name .eq. "u_large_scale") then
       field_information%enabled=current_state%u%active .and. l_constant_forcing_u
     else if (name .eq. "v_large_scale") then
       field_information%enabled=current_state%v%active .and. l_constant_forcing_v
     else if (name .eq. "th_large_scale") then
       field_information%enabled=current_state%th%active .and. l_constant_forcing_theta
     else if (name .eq. "q_large_scale") then
       field_information%number_dimensions=2
       field_information%dimension_sizes(2)=current_state%number_q_fields
       field_information%enabled=current_state%number_q_fields .gt. 0 .and. l_constant_forcing_q
     end if   

Here is the caller graph for this function:

◆ field_value_retrieval_callback()

subroutine forcing_mod::field_value_retrieval_callback	(	type(model_state_type), intent(inout), target	current_state,
		character(len=*), intent(in)	name,
		type(component_field_value_type), intent(out)	field_value
	)

private

Field value retrieval callback, this returns the value of a specific published field.

Parameters

current_state	Current model state
name	The name of the field to retrieve the value for
field_value	Populated with the value of the field

Definition at line 144 of file forcing.F90.

     type(model_state_type), target, intent(inout) :: current_state
     character(len=*), intent(in) :: name
     type(component_field_value_type), intent(out) :: field_value
 
     integer :: k, n, column_size
 
     column_size=current_state%local_grid%size(z_index)
 
     if (name .eq. "u_subsidence") then
       allocate(field_value%real_1d_array(column_size))
       do k=2, column_size-1
         field_value%real_1d_array(k)=0.0_default_precision-2.0*&
              current_state%global_grid%configuration%vertical%w_subs(k-1)*&
              current_state%global_grid%configuration%vertical%tzc1(k)*(&
              current_state%global_grid%configuration%vertical%olzubar(k)-&
              current_state%global_grid%configuration%vertical%olzubar(k-1))+&
              current_state%global_grid%configuration%vertical%w_subs(k)*&
              current_state%global_grid%configuration%vertical%tzc2(k)*&
              (current_state%global_grid%configuration%vertical%olzubar(k+1)-&
              current_state%global_grid%configuration%vertical%olzubar(k))
       end do
     else if (name .eq. "v_subsidence") then
       allocate(field_value%real_1d_array(column_size))
       do k=2, column_size-1
         field_value%real_1d_array(k)=0.0_default_precision-2.0*&
              current_state%global_grid%configuration%vertical%w_subs(k-1)*&
              current_state%global_grid%configuration%vertical%tzc1(k)*(&
              current_state%global_grid%configuration%vertical%olzvbar(k)-&
              current_state%global_grid%configuration%vertical%olzvbar(k-1))+&
              current_state%global_grid%configuration%vertical%w_subs(k)*&
              current_state%global_grid%configuration%vertical%tzc2(k)*(&
              current_state%global_grid%configuration%vertical%olzvbar(k+1)-&
              current_state%global_grid%configuration%vertical%olzvbar(k))
       end do
     else if (name .eq. "th_subsidence") then
       allocate(field_value%real_1d_array(column_size))
       do k=2, column_size-1
         field_value%real_1d_array(k)=0.0_default_precision-2.0*&
              current_state%global_grid%configuration%vertical%w_subs(k-1)*&
              current_state%global_grid%configuration%vertical%tzc1(k)*(&
              current_state%global_grid%configuration%vertical%olzthbar(k)-&
              current_state%global_grid%configuration%vertical%olzthbar(k-1)+&
              current_state%global_grid%configuration%vertical%dthref(k-1))+&
              current_state%global_grid%configuration%vertical%w_subs(k)*&
              current_state%global_grid%configuration%vertical%tzc2(k)*(&
              current_state%global_grid%configuration%vertical%olzthbar(k+1)-&
              current_state%global_grid%configuration%vertical%olzthbar(k)+&
              current_state%global_grid%configuration%vertical%dthref(k))
       end do
     else if (name .eq. "q_subsidence") then
       allocate(field_value%real_2d_array(column_size, current_state%number_q_fields))
       do n=1, current_state%number_q_fields
         do k=2, column_size-1
           field_value%real_2d_array(k,n)=0.0_default_precision-2.0*&
                current_state%global_grid%configuration%vertical%w_subs(k-1)*&
                current_state%global_grid%configuration%vertical%tzc1(k)*(&
                current_state%global_grid%configuration%vertical%olzqbar(k,n)-&
                current_state%global_grid%configuration%vertical%olzqbar(k-1,n))+&
                current_state%global_grid%configuration%vertical%w_subs(k)&
                *current_state%global_grid%configuration%vertical%tzc2(k)*(&
                current_state%global_grid%configuration%vertical%olzqbar(k+1,n)-&
                current_state%global_grid%configuration%vertical%olzqbar(k,n))
         end do
       end do
     else if (name .eq. "u_large_scale") then
       allocate(field_value%real_1d_array(column_size))
       field_value%real_1d_array=get_averaged_diagnostics(current_state, du_profile_diag)
     else if (name .eq. "v_large_scale") then
       allocate(field_value%real_1d_array(column_size))
       field_value%real_1d_array=get_averaged_diagnostics(current_state, dv_profile_diag)
     else if (name .eq. "th_large_scale") then
       allocate(field_value%real_1d_array(column_size))
       field_value%real_1d_array=dtheta_profile_diag
     else if (name .eq. "q_large_scale") then
       allocate(field_value%real_2d_array(column_size, current_state%number_q_fields))
       do n=1, current_state%number_q_fields
         field_value%real_2d_array(:,n)=get_averaged_diagnostics(current_state, dq_profile_diag(:,n))
       end do
     end if

Here is the call graph for this function:

Here is the caller graph for this function:

◆ finalisation_callback()

subroutine forcing_mod::finalisation_callback ( type(model_state_type), intent(inout), target current_state )

private

Finalises the component Current model state.

Definition at line 748 of file forcing.F90.

     type(model_state_type), target, intent(inout) :: current_state
     deallocate(theta_profile, q_profile, u_profile, v_profile)
     deallocate(dtheta_profile, dq_profile, du_profile, dv_profile)
     if (allocated(du_profile_diag)) deallocate(du_profile_diag)
     if (allocated(dv_profile_diag)) deallocate(dv_profile_diag)
     if (allocated(dtheta_profile_diag)) deallocate(dtheta_profile_diag)
     if (allocated(dq_profile_diag)) deallocate(dq_profile_diag)

Here is the caller graph for this function:

◆ forcing_get_descriptor()

type(component_descriptor_type) function, public forcing_mod::forcing_get_descriptor ( )

Provides the component descriptor for the core to register.

Returns: The descriptor describing this component

Definition at line 78 of file forcing.F90.

     forcing_get_descriptor%name="forcing"
     forcing_get_descriptor%version=0.1
     forcing_get_descriptor%initialisation=>init_callback
     forcing_get_descriptor%timestep=>timestep_callback
     forcing_get_descriptor%finalisation=>finalisation_callback
 
     forcing_get_descriptor%field_value_retrieval=>field_value_retrieval_callback
     forcing_get_descriptor%field_information_retrieval=>field_information_retrieval_callback
     allocate(forcing_get_descriptor%published_fields(8))
 
     forcing_get_descriptor%published_fields(1)="u_subsidence"
     forcing_get_descriptor%published_fields(2)="v_subsidence"
     forcing_get_descriptor%published_fields(3)="th_subsidence"
     forcing_get_descriptor%published_fields(4)="q_subsidence"
     forcing_get_descriptor%published_fields(5)="u_large_scale"
     forcing_get_descriptor%published_fields(6)="v_large_scale"
     forcing_get_descriptor%published_fields(7)="th_large_scale"
     forcing_get_descriptor%published_fields(8)="q_large_scale"

Here is the call graph for this function:

◆ get_averaged_diagnostics()

real(kind=default_precision) function, dimension(size(diagnostics_summed)) forcing_mod::get_averaged_diagnostics	(	type(model_state_type), intent(inout), target	current_state,
		real(kind=default_precision), dimension(:), intent(in)	diagnostics_summed
	)

private

Averages some diagnostic values across all local horizontal points.

Parameters

current_state	Current model state
diagnostics_summed	The diagnostics, which are summed up values from each local point, which need to be averaged

Returns: The averaged diagnostics across all local horizontal points

Definition at line 762 of file forcing.F90.

     type(model_state_type), target, intent(inout) :: current_state
     real(kind=DEFAULT_PRECISION), dimension(:), intent(in) :: diagnostics_summed
     real(kind=DEFAULT_PRECISION), dimension(size(diagnostics_summed)) :: get_averaged_diagnostics
 
     integer :: horizontal_points
 
     horizontal_points=current_state%local_grid%size(x_index) * current_state%local_grid%size(y_index)
 
     get_averaged_diagnostics(:)=diagnostics_summed(:)/horizontal_points

Here is the caller graph for this function:

◆ init_callback()

subroutine forcing_mod::init_callback ( type(model_state_type), intent(inout), target current_state )

private

Initialises the forcing data structures.

Definition at line 227 of file forcing.F90.

     type(model_state_type), target, intent(inout) :: current_state
 
     integer :: nq_force ! The number of q fields apply large-scale time-independent forcing
     integer :: nzq      ! The number of input levels for subsidence/divergence profile
     integer :: i,n  ! loop counters
     integer :: iq       ! temporary q varible index
  
     ! Input arrays for subsidence profile
     real(kind=DEFAULT_PRECISION), dimension(:), allocatable :: f_subs_pl  ! subsidence node for q variables
     real(kind=DEFAULT_PRECISION), dimension(:), allocatable :: z_subs_pl  ! subsidence node height values for q variables
 
     ! Input arrays for time-independent forcing
     real(kind=DEFAULT_PRECISION), dimension(:, :), allocatable :: f_force_pl_q   ! Forcing values for q variables
     real(kind=DEFAULT_PRECISION), dimension(:), allocatable :: z_force_pl_q      ! Forcing height values for q variables
     real(kind=DEFAULT_PRECISION), dimension(:), allocatable :: f_force_pl_theta  ! Forcing values for theta variable
     real(kind=DEFAULT_PRECISION), dimension(:), allocatable :: z_force_pl_theta  ! Forcing height values for theta variable
     real(kind=DEFAULT_PRECISION), dimension(:), allocatable :: f_force_pl_u      ! Forcing values for u variable
     real(kind=DEFAULT_PRECISION), dimension(:), allocatable :: z_force_pl_u      ! Forcing height values for u variable
     real(kind=DEFAULT_PRECISION), dimension(:), allocatable :: f_force_pl_v      ! Forcing values for v variable
     real(kind=DEFAULT_PRECISION), dimension(:), allocatable :: z_force_pl_v      ! Forcing height values for v variabl
 
     integer :: subsidence_input_type=divergence  ! Determines if we're reading in a subsidence velocity or divergence
     
     real(kind=DEFAULT_PRECISION), allocatable :: f_force_pl_q_tmp(:) !temporary 1D storage of forcing for q fields
     real(kind=DEFAULT_PRECISION), allocatable :: zgrid(:)            ! z grid to use in interpolation   
 
     character(len=STRING_LENGTH), dimension(:), allocatable :: units_q_force  ! units of q variable forcing
     character(len=STRING_LENGTH) :: units_theta_force='unset'  ! units of theta variable forcing
     character(len=STRING_LENGTH) :: units_u_force='unset'  ! units of theta variable forcing
     character(len=STRING_LENGTH) :: units_v_force='unset'  ! units of theta variable forcing
 
     logical :: convert_input_theta_from_temperature=.false. ! If .true. input forcing data is for temperature and should
                                                             ! be converted to theta (potential temerature).
 
    integer :: k
 
     allocate(theta_profile(current_state%local_grid%size(z_index)), &
        q_profile(current_state%local_grid%size(z_index)),           &
        u_profile(current_state%local_grid%size(z_index)),           &
        v_profile(current_state%local_grid%size(z_index)))
 
     allocate(dtheta_profile(current_state%local_grid%size(z_index)), &
        dq_profile(current_state%local_grid%size(z_index)),           &
        du_profile(current_state%local_grid%size(z_index)),           &
        dv_profile(current_state%local_grid%size(z_index)))
 
     allocate(du_profile_diag(current_state%local_grid%size(z_index)), dv_profile_diag(current_state%local_grid%size(z_index)), &
          dtheta_profile_diag(current_state%local_grid%size(z_index)), &
          dq_profile_diag(current_state%local_grid%size(z_index), current_state%number_q_fields))
 
     allocate(zgrid(current_state%local_grid%size(z_index)))
 
     ! Subsidence forcing initialization
 
     l_subs_pl_theta=options_get_logical(current_state%options_database, "l_subs_pl_theta")
     l_subs_pl_q=options_get_logical(current_state%options_database, "l_subs_pl_q")
     subsidence_input_type=options_get_integer(current_state%options_database, "subsidence_input_type")
     l_subs_local_theta=options_get_logical(current_state%options_database, "subsidence_local_theta")
     l_subs_local_q=options_get_logical(current_state%options_database, "subsidence_local_q")
 
 
     if ((l_subs_pl_theta .and. .not. l_subs_local_theta) .or. &
        (l_subs_pl_q .and. .not. l_subs_local_q))then
       if (.not. is_component_enabled(current_state%options_database, "mean_profiles")) then
         call log_master_log(log_error, "Damping requires the mean profiles component to be enabled")
       end if
     end if
 
     if (l_subs_pl_theta .or. l_subs_pl_q)then
       allocate(z_subs_pl(options_get_array_size(current_state%options_database, "z_subs_pl")), &
            f_subs_pl(options_get_array_size(current_state%options_database, "f_subs_pl")))
       call options_get_real_array(current_state%options_database, "z_subs_pl", z_subs_pl)
       call options_get_real_array(current_state%options_database, "f_subs_pl", f_subs_pl)      
       ! Get profiles
       zgrid=current_state%global_grid%configuration%vertical%z(:)
       call piecewise_linear_1d(z_subs_pl(1:size(z_subs_pl)), f_subs_pl(1:size(f_subs_pl)), zgrid, &
          current_state%global_grid%configuration%vertical%w_subs)
       if (subsidence_input_type==divergence) then
         current_state%global_grid%configuration%vertical%w_subs(:) = &
            -1.0*current_state%global_grid%configuration%vertical%w_subs(:)*zgrid(:)
       end if
       deallocate(z_subs_pl, f_subs_pl)
     end if
 
     ! Time independent large-scale forcing (proxy for e.g. advection/radiation)
 
     ! This probably isn't the right place to be doing this
     if (.not. allocated(current_state%l_forceq))then
       allocate(current_state%l_forceq(current_state%number_q_fields))
       current_state%l_forceq=.false.
     end if
 
     l_constant_forcing_theta=options_get_logical(current_state%options_database, "l_constant_forcing_theta")
     l_constant_forcing_q=options_get_logical(current_state%options_database, "l_constant_forcing_q")
     l_constant_forcing_u=options_get_logical(current_state%options_database, "l_constant_forcing_u")
     l_constant_forcing_v=options_get_logical(current_state%options_database, "l_constant_forcing_v")
 
     if (l_constant_forcing_q) then
       allocate(names_force_pl_q(options_get_array_size(current_state%options_database, "names_constant_forcing_q")))
       call options_get_string_array(current_state%options_database, "names_constant_forcing_q", names_force_pl_q)
     end if
     
     if (l_constant_forcing_theta)then
       constant_forcing_type_theta=options_get_integer(current_state%options_database, "constant_forcing_type_theta")
       forcing_timescale_theta=options_get_real(current_state%options_database, "forcing_timescale_theta")
       l_constant_forcing_theta_z2pressure=options_get_logical(current_state%options_database, "l_constant_forcing_theta_z2pressure")
 
       allocate(z_force_pl_theta(options_get_array_size(current_state%options_database, "z_force_pl_theta")), &
            f_force_pl_theta(options_get_array_size(current_state%options_database, "f_force_pl_theta")))
       call options_get_real_array(current_state%options_database, "z_force_pl_theta", z_force_pl_theta)
       call options_get_real_array(current_state%options_database, "f_force_pl_theta", f_force_pl_theta)
       ! Get profiles
       relax_to_initial_theta_profile=options_get_logical(current_state%options_database, "relax_to_initial_theta_profile")
       if (relax_to_initial_theta_profile)then
         current_state%global_grid%configuration%vertical%theta_force(:) = &
            current_state%global_grid%configuration%vertical%theta_init(:)
       else
         if (l_constant_forcing_theta_z2pressure)then
           zgrid=current_state%global_grid%configuration%vertical%zn(:)
         else
           zgrid=current_state%global_grid%configuration%vertical%prefn(:)
         end if
         call piecewise_linear_1d(z_force_pl_theta(1:size(z_force_pl_theta)), f_force_pl_theta(1:size(f_force_pl_theta)), zgrid, &
            current_state%global_grid%configuration%vertical%theta_force)
       end if
       
       ! Unit conversions...
       if (convert_input_theta_from_temperature)then ! Input is temperature not theta
         current_state%global_grid%configuration%vertical%theta_force(:) =   &
            current_state%global_grid%configuration%vertical%theta_force(:)* &
            current_state%global_grid%configuration%vertical%prefrcp(:)
       end if
       
       if (constant_forcing_type_theta==tendency)then
         units_theta_force=options_get_string(current_state%options_database, "units_theta_force")
         select case(trim(units_theta_force))
         case(k_per_day)
           current_state%global_grid%configuration%vertical%theta_force(:) = &
              current_state%global_grid%configuration%vertical%theta_force(:)/seconds_in_a_day
         case default !(k_per_second)
         end select
       end if
       deallocate(z_force_pl_theta, f_force_pl_theta)
    end if
                                                            
 #ifdef U_ACTIVE
     if (l_constant_forcing_u)then
       constant_forcing_type_u=options_get_integer(current_state%options_database, "constant_forcing_type_u")
       forcing_timescale_u=options_get_real(current_state%options_database, "forcing_timescale_u")
       relax_to_initial_u_profile=options_get_logical(current_state%options_database, "relax_to_initial_u_profile")
       if (relax_to_initial_u_profile)then
         current_state%global_grid%configuration%vertical%u_force(:) = &
            current_state%global_grid%configuration%vertical%u_init(:)
       else
         allocate(z_force_pl_u(options_get_array_size(current_state%options_database, "z_force_pl_u")), &
            f_force_pl_u(options_get_array_size(current_state%options_database, "f_force_pl_u")))
         call options_get_real_array(current_state%options_database, "z_force_pl_u", z_force_pl_u)
         call options_get_real_array(current_state%options_database, "f_force_pl_u", f_force_pl_u)
         ! Get profiles
         zgrid=current_state%global_grid%configuration%vertical%zn(:)
         call piecewise_linear_1d(z_force_pl_u(1:size(z_force_pl_u)), f_force_pl_u(1:size(f_force_pl_u)), zgrid, &
            current_state%global_grid%configuration%vertical%u_force)
         deallocate(z_force_pl_u, f_force_pl_u)
       end if
 
 
       if (constant_forcing_type_u==tendency)then
         ! Unit conversions...
         units_u_force=options_get_string(current_state%options_database, "units_u_force")
         select case(trim(units_u_force))
         case(m_per_second_per_day)
           current_state%global_grid%configuration%vertical%u_force(:) = &
              current_state%global_grid%configuration%vertical%u_force(:)/seconds_in_a_day
         case default  !(m_per_second_per_second)
         end select
       end if
     end if
 #endif
                                                            
 #ifdef V_ACTIVE
     if (l_constant_forcing_v)then
       constant_forcing_type_v=options_get_integer(current_state%options_database, "constant_forcing_type_v")
       forcing_timescale_v=options_get_real(current_state%options_database, "forcing_timescale_v")
       relax_to_initial_v_profile=options_get_logical(current_state%options_database, "relax_to_initial_v_profile")
       if (relax_to_initial_v_profile)then
         current_state%global_grid%configuration%vertical%v_force(:) = &
            current_state%global_grid%configuration%vertical%v_init(:)
       else
         allocate(z_force_pl_v(options_get_array_size(current_state%options_database, "z_force_pl_v")), &
            f_force_pl_v(options_get_array_size(current_state%options_database, "f_force_pl_v")))
         call options_get_real_array(current_state%options_database, "z_force_pl_v", z_force_pl_v)
         call options_get_real_array(current_state%options_database, "f_force_pl_v", f_force_pl_v)
         ! Get profiles
         zgrid=current_state%global_grid%configuration%vertical%zn(:)
         call piecewise_linear_1d(z_force_pl_v(1:size(z_force_pl_v)), f_force_pl_v(1:size(f_force_pl_v)), zgrid, &
            current_state%global_grid%configuration%vertical%v_force)
         deallocate(z_force_pl_v, f_force_pl_v)
       end if
 
 
       if (constant_forcing_type_v==tendency)then
         ! Unit conversions...
         units_v_force=options_get_string(current_state%options_database, "units_v_force")
         select case(trim(units_v_force))
         case(m_per_second_per_day)
           current_state%global_grid%configuration%vertical%v_force(:) = &
              current_state%global_grid%configuration%vertical%v_force(:)/seconds_in_a_day
         case default !(m_per_second_per_second)
         end select
       end if
     end if 
 #endif   
         
     if (l_constant_forcing_q) then
       constant_forcing_type_q=options_get_integer(current_state%options_database, "constant_forcing_type_q")
       forcing_timescale_q=options_get_real(current_state%options_database, "forcing_timescale_q")
       nq_force=size(names_force_pl_q)
       allocate(z_force_pl_q(options_get_array_size(current_state%options_database, "z_force_pl_q")))
       call options_get_real_array(current_state%options_database, "z_force_pl_q", z_force_pl_q)
       nzq=size(z_force_pl_q)
       zgrid=current_state%global_grid%configuration%vertical%zn(:)
       allocate(f_force_pl_q_tmp(nq_force*nzq))
       call options_get_real_array(current_state%options_database, "f_force_pl_q", f_force_pl_q_tmp)
       allocate(f_force_pl_q(nzq, nq_force))
       f_force_pl_q(1:nzq, 1:nq_force)=reshape(f_force_pl_q_tmp, (/nzq, nq_force/))
 
       allocate(units_q_force(options_get_array_size(current_state%options_database, "units_q_force")))
       call options_get_string_array(current_state%options_database, "units_q_force", units_q_force)
       do n=1, nq_force
         iq=get_q_index(trim(names_force_pl_q(n)), 'forcing:time-independent')
         call piecewise_linear_1d(z_force_pl_q(1:nzq), f_force_pl_q(1:nzq,n), zgrid, &
            current_state%global_grid%configuration%vertical%q_force(:,iq))
         
         current_state%l_forceq(iq)=.true.
 
         ! Unit conversions...
         if (constant_forcing_type_u==tendency)then
           select case(trim(units_q_force(n)))
           case(kg_per_kg_per_day)
             current_state%global_grid%configuration%vertical%q_force(:,iq) = &
                current_state%global_grid%configuration%vertical%q_force(:,iq)/seconds_in_a_day
           case(g_per_kg_per_day)
             current_state%global_grid%configuration%vertical%q_force(:,iq) = &
                0.001*current_state%global_grid%configuration%vertical%q_force(:,iq)/seconds_in_a_day
           case(g_per_kg_per_second)
             current_state%global_grid%configuration%vertical%q_force(:,iq) = &
                0.001*current_state%global_grid%configuration%vertical%q_force(:,iq)
           case default !(kg_per_kg_per_second)
           end select
         end if
       end do
       deallocate(f_force_pl_q_tmp, units_q_force, f_force_pl_q, z_force_pl_q)  
     end if
 
     deallocate(zgrid)

Here is the caller graph for this function:

◆ timestep_callback()

subroutine forcing_mod::timestep_callback ( type(model_state_type), intent(inout), target current_state )

private

Called for each data column and will determine the forcing values in x and y which are then applied to the field source terms.

Parameters

current_state The current model state_mod

Definition at line 488 of file forcing.F90.

     type(model_state_type), target, intent(inout) :: current_state
 
     if (current_state%first_timestep_column) then
       du_profile_diag=0.0_default_precision
       dv_profile_diag=0.0_default_precision
       dtheta_profile_diag=0.0_default_precision
       dq_profile_diag=0.0_default_precision
     end if    
 
     if (current_state%halo_column .or. current_state%timestep<3) return
     if (l_subs_pl_theta) then
       call apply_subsidence_to_flow_fields(current_state)
       call apply_subsidence_to_theta(current_state)
     end if
     if (l_subs_pl_q) call apply_subsidence_to_q_fields(current_state)
 
     if (l_constant_forcing_theta)call apply_time_independent_forcing_to_theta(current_state)                                                         
 #ifdef U_ACTIVE
     if (l_constant_forcing_u)call apply_time_independent_forcing_to_u(current_state)
 #endif                                                       
 #ifdef V_ACTIVE
     if (l_constant_forcing_v)call apply_time_independent_forcing_to_v(current_state)
 #endif
     if (l_constant_forcing_q)call apply_time_independent_forcing_to_q(current_state)

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

◆ constant_forcing_type_q

integer forcing_mod::constant_forcing_type_q =TENDENCY

private

Definition at line 53 of file forcing.F90.

53 integer :: constant_forcing_type_q=tendency ! Method for large-scale forcing of q

◆ constant_forcing_type_theta

integer forcing_mod::constant_forcing_type_theta =TENDENCY

private

Definition at line 52 of file forcing.F90.

52 integer :: constant_forcing_type_theta=tendency ! Method for large-scale forcing of theta

◆ constant_forcing_type_u

integer forcing_mod::constant_forcing_type_u =RELAXATION

private

Definition at line 54 of file forcing.F90.

54 integer :: constant_forcing_type_u=relaxation ! Method for large-scale forcing of u

◆ constant_forcing_type_v

integer forcing_mod::constant_forcing_type_v =RELAXATION

private

Definition at line 55 of file forcing.F90.

55 integer :: constant_forcing_type_v=relaxation ! Method for large-scale forcing of v

◆ divergence

integer, parameter forcing_mod::divergence =0

private

Definition at line 23 of file forcing.F90.

23 integer, parameter :: divergence=0 ! Input for subsidence forcing is a divergence profile

◆ dq_profile

real(kind=default_precision), dimension(:), allocatable forcing_mod::dq_profile

private

Definition at line 36 of file forcing.F90.

36 real(kind=DEFAULT_PRECISION), allocatable :: dq_profile(:) ! Local profile to be used in the time-indpendent forcing

◆ dq_profile_diag

real(kind=default_precision), dimension(:,:), allocatable forcing_mod::dq_profile_diag

private

Definition at line 39 of file forcing.F90.

◆ dtheta_profile

real(kind=default_precision), dimension(:), allocatable forcing_mod::dtheta_profile

private

Definition at line 35 of file forcing.F90.

35 real(kind=DEFAULT_PRECISION), allocatable :: dtheta_profile(:) ! Local profile to be used in time-indpendent forcing

◆ dtheta_profile_diag

real(kind=default_precision), dimension(:), allocatable forcing_mod::dtheta_profile_diag

private

Definition at line 39 of file forcing.F90.

◆ du_profile

real(kind=default_precision), dimension(:), allocatable forcing_mod::du_profile

private

Definition at line 37 of file forcing.F90.

37 real(kind=DEFAULT_PRECISION), allocatable :: du_profile(:) ! Local profile to be used in the time-indpendent forcing

◆ du_profile_diag

real(kind=default_precision), dimension(:), allocatable forcing_mod::du_profile_diag

private

Definition at line 39 of file forcing.F90.

39 real(kind=DEFAULT_PRECISION), allocatable :: du_profile_diag(:), dv_profile_diag(:), dtheta_profile_diag(:), &

40 dq_profile_diag(:,:)

◆ dv_profile

real(kind=default_precision), dimension(:), allocatable forcing_mod::dv_profile

private

Definition at line 38 of file forcing.F90.

38 real(kind=DEFAULT_PRECISION), allocatable :: dv_profile(:) ! Local profile to be used in the time-indpendent forcing

◆ dv_profile_diag

real(kind=default_precision), dimension(:), allocatable forcing_mod::dv_profile_diag

private

Definition at line 39 of file forcing.F90.

◆ forcing_timescale_q

real(kind=default_precision) forcing_mod::forcing_timescale_q

private

Definition at line 43 of file forcing.F90.

43 real(kind=DEFAULT_PRECISION) :: forcing_timescale_q ! Timescale for forcing of q

◆ forcing_timescale_theta

real(kind=default_precision) forcing_mod::forcing_timescale_theta

private

Definition at line 42 of file forcing.F90.

42 real(kind=DEFAULT_PRECISION) :: forcing_timescale_theta ! Timescale for forcing of theta

◆ forcing_timescale_u

real(kind=default_precision) forcing_mod::forcing_timescale_u

private

Definition at line 44 of file forcing.F90.

44 real(kind=DEFAULT_PRECISION) :: forcing_timescale_u ! Timescale for forcing of u

◆ forcing_timescale_v

real(kind=default_precision) forcing_mod::forcing_timescale_v

private

Definition at line 45 of file forcing.F90.

45 real(kind=DEFAULT_PRECISION) :: forcing_timescale_v ! Timescale for forcing of v

◆ increment

integer, parameter forcing_mod::increment =2

private

Definition at line 28 of file forcing.F90.

28 integer, parameter :: increment=2 ! Input for large-scale forcing: values are increments (deltas) over timescale

◆ l_constant_forcing_q

logical forcing_mod::l_constant_forcing_q

private

Definition at line 48 of file forcing.F90.

48 logical :: l_constant_forcing_q ! Use a time-independent forcing for q

◆ l_constant_forcing_theta

logical forcing_mod::l_constant_forcing_theta

private

Definition at line 47 of file forcing.F90.

47 logical :: l_constant_forcing_theta ! Use a time-independent forcing for theta

◆ l_constant_forcing_theta_z2pressure

logical forcing_mod::l_constant_forcing_theta_z2pressure

private

Definition at line 57 of file forcing.F90.

57 logical :: l_constant_forcing_theta_z2pressure ! profile is a function of pressure not height

◆ l_constant_forcing_u

logical forcing_mod::l_constant_forcing_u

private

Definition at line 49 of file forcing.F90.

49 logical :: l_constant_forcing_u ! Use a time-independent forcing for u

◆ l_constant_forcing_v

logical forcing_mod::l_constant_forcing_v

private

Definition at line 50 of file forcing.F90.

50 logical :: l_constant_forcing_v ! Use a time-independent forcing for v

◆ l_subs_local_q

logical forcing_mod::l_subs_local_q

private

Definition at line 67 of file forcing.F90.

67 logical :: l_subs_local_q ! if .true. then subsidence applied locally (i.e. not with mean fields) to q fields

◆ l_subs_local_theta

logical forcing_mod::l_subs_local_theta

private

Definition at line 66 of file forcing.F90.

66 logical :: l_subs_local_theta ! if .true. then subsidence applied locally (i.e. not with mean fields) to theta field

◆ l_subs_pl_q

logical forcing_mod::l_subs_pl_q

private

Definition at line 64 of file forcing.F90.

64 logical :: l_subs_pl_q ! if .true. then subsidence applied to q fields

◆ l_subs_pl_theta

logical forcing_mod::l_subs_pl_theta

private

Definition at line 63 of file forcing.F90.

63 logical :: l_subs_pl_theta ! if .true. then subsidence applied to theta field

◆ names_force_pl_q

character(len=string_length), dimension(:), allocatable forcing_mod::names_force_pl_q

private

Definition at line 69 of file forcing.F90.

69 character(len=STRING_LENGTH), dimension(:), allocatable :: names_force_pl_q ! names of q variables to force

◆ q_profile

real(kind=default_precision), dimension(:), allocatable forcing_mod::q_profile

private

Definition at line 31 of file forcing.F90.

31 real(kind=DEFAULT_PRECISION), allocatable :: q_profile(:) ! Local profile to be used in the subsidence calculation

◆ relax_to_initial_theta_profile

logical forcing_mod::relax_to_initial_theta_profile

private

Definition at line 61 of file forcing.F90.

61 logical :: relax_to_initial_theta_profile ! For relaxation, use initial profile as the target

◆ relax_to_initial_u_profile

logical forcing_mod::relax_to_initial_u_profile

private

Definition at line 59 of file forcing.F90.

59 logical :: relax_to_initial_u_profile ! For relaxation, use initial profile as the target

◆ relax_to_initial_v_profile

logical forcing_mod::relax_to_initial_v_profile

private

Definition at line 60 of file forcing.F90.

60 logical :: relax_to_initial_v_profile ! For relaxation, use initial profile as the target

◆ relaxation

integer, parameter forcing_mod::relaxation =1

private

Definition at line 27 of file forcing.F90.

27 integer, parameter :: relaxation=1 ! Input for large-scale forcing: values are target values to relax to over timescale

◆ subsidence

integer, parameter forcing_mod::subsidence =1

private

Definition at line 24 of file forcing.F90.

24 integer, parameter :: subsidence=1 ! Input for subsidence forcing is the subsidence velocity profile

◆ tendency

integer, parameter forcing_mod::tendency =0

private

Definition at line 26 of file forcing.F90.

26 integer, parameter :: tendency=0 ! Input for large-scale forcing: values are tendencies (time derivatives)

◆ theta_profile

real(kind=default_precision), dimension(:), allocatable forcing_mod::theta_profile

private

Definition at line 30 of file forcing.F90.

30 real(kind=DEFAULT_PRECISION), allocatable :: theta_profile(:) ! Local profile to be used in the subsidence calculation

◆ u_profile

real(kind=default_precision), dimension(:), allocatable forcing_mod::u_profile

private

Definition at line 32 of file forcing.F90.

32 real(kind=DEFAULT_PRECISION), allocatable :: u_profile(:) ! Local profile to be used in the subsidence calculation

◆ v_profile

real(kind=default_precision), dimension(:), allocatable forcing_mod::v_profile

private

Definition at line 33 of file forcing.F90.

33 real(kind=DEFAULT_PRECISION), allocatable :: v_profile(:) ! Local profile to be used in the subsidence calculation

Functions/Subroutines

Variables

Detailed Description

Function/Subroutine Documentation

◆ apply_subsidence_to_flow_fields()

◆ apply_subsidence_to_q_fields()

◆ apply_subsidence_to_theta()

◆ apply_time_independent_forcing_to_q()

◆ apply_time_independent_forcing_to_theta()

◆ apply_time_independent_forcing_to_u()

◆ apply_time_independent_forcing_to_v()

◆ field_information_retrieval_callback()

◆ field_value_retrieval_callback()

◆ finalisation_callback()

◆ forcing_get_descriptor()

◆ get_averaged_diagnostics()

◆ init_callback()

◆ timestep_callback()

Variable Documentation

◆ constant_forcing_type_q

◆ constant_forcing_type_theta

◆ constant_forcing_type_u

◆ constant_forcing_type_v

◆ divergence

◆ dq_profile

◆ dq_profile_diag

◆ dtheta_profile

◆ dtheta_profile_diag

◆ du_profile

◆ du_profile_diag

◆ dv_profile

◆ dv_profile_diag

◆ forcing_timescale_q

◆ forcing_timescale_theta

◆ forcing_timescale_u

◆ forcing_timescale_v

◆ increment

◆ l_constant_forcing_q

◆ l_constant_forcing_theta

◆ l_constant_forcing_theta_z2pressure

◆ l_constant_forcing_u

◆ l_constant_forcing_v

◆ l_subs_local_q

◆ l_subs_local_theta

◆ l_subs_pl_q

◆ l_subs_pl_theta

◆ names_force_pl_q

◆ q_profile

◆ relax_to_initial_theta_profile

◆ relax_to_initial_u_profile

◆ relax_to_initial_v_profile

◆ relaxation

◆ subsidence

◆ tendency

◆ theta_profile

◆ u_profile

◆ v_profile