connectionbuildermodule Module Reference

Data Types
type	connectionbuildertype

Functions/Subroutines
subroutine	processsolution (this, solution)
	Process the exchanges in the solution into model connections.
subroutine	processexchanges (this, exchanges, newconnections)
	Create connections from exchanges.
class(spatialmodelconnectiontype) function, pointer	createmodelconnection (model, exchange)
	Create a model connection of a given type.
subroutine	setconnectionstosolution (this, connections, solution)
	Set connections to the solution.
subroutine	createmodelconnectivity (this, connections)
	Create connectivity of models which contribute to the interface.

Function/Subroutine Documentation

createmodelconnection()

class(spatialmodelconnectiontype) function, pointer connectionbuildermodule::createmodelconnection ( class(numericalmodeltype), intent(in), pointer model, class(disconnexchangetype), intent(in), pointer exchange )

private

This is a factory method to create the various types of model connections

Parameters

[in]	model	the model for which the connection will be created
[in]	exchange	the type of connection

Returns

the created connection

Definition at line 147 of file ConnectionBuilder.f90.

    use gwfgwfconnectionmodule, only: gwfgwfconnectiontype
    use gwtgwtconnectionmodule, only: gwtgwtconnectiontype
    use gwegweconnectionmodule, only: gwegweconnectiontype
    use gwfmodule, only: gwfmodeltype
 
    class(NumericalModelType), pointer, intent(in) :: model !< the model for which the connection will be created
    class(DisConnExchangeType), pointer, intent(in) :: exchange !< the type of connection
    class(SpatialModelConnectionType), pointer :: connection !< the created connection
 
    ! different concrete connection types:
    class(GwfGwfConnectionType), pointer :: flowConnection => null()
    class(GwtGwtConnectionType), pointer :: transportConnection => null()
    class(GweGweConnectionType), pointer :: energyTransportConnection => null()
 
    connection => null()
 
    ! select on type of connection to create
    select case (exchange%typename)
    case ('GWF-GWF')
      allocate (gwfgwfconnectiontype :: flowconnection)
      call flowconnection%construct(model, exchange)
      connection => flowconnection
      flowconnection => null()
    case ('GWT-GWT')
      allocate (gwtgwtconnectiontype :: transportconnection)
      call transportconnection%construct(model, exchange)
      connection => transportconnection
      transportconnection => null()
    case ('GWE-GWE')
      allocate (gwegweconnectiontype :: energytransportconnection)
      call energytransportconnection%construct(model, exchange)
      connection => energytransportconnection
      energytransportconnection => null()
    case default
      write (*, *) 'Error (which should never happen): '// &
        'undefined exchangetype found'
      call ustop()
    end select
 

Here is the call graph for this function:

Here is the caller graph for this function:

createmodelconnectivity()

subroutine connectionbuildermodule::createmodelconnectivity ( class(connectionbuildertype) this, type(listtype), intent(inout) connections )

private

This loops over all connections and creates a halo with all models from the numerical solution. The model halo will be used to extend the interface grid to include cells from models which are

Parameters

	this	the connection builder object
[in,out]	connections	all connections that are created for this solution

Definition at line 249 of file ConnectionBuilder.f90.

    class(ConnectionBuilderType) :: this !< the connection builder object
    type(ListType), intent(inout) :: connections !< all connections that are created for this solution
    ! local
    integer(I4B) :: iconn
    class(SpatialModelConnectionType), pointer :: modelConn
 
    ! create halo for the model connections
    do iconn = 1, connections%Count()
      modelconn => get_smc_from_list(connections, iconn)
      call modelconn%createModelHalo()
    end do
 

Here is the call graph for this function:

processexchanges()

subroutine connectionbuildermodule::processexchanges ( class(connectionbuildertype) this, type(listtype), intent(in), pointer exchanges, type(listtype), intent(inout) newconnections )

private

If the configuration demands it, this will create connections, for the exchanges (one connection per exchange) add them to the global list, and return them as newConnections

Parameters

	this	the connection builder object
[in]	exchanges	the list of exchanges to process
[in,out]	newconnections	the newly created connections

Definition at line 81 of file ConnectionBuilder.f90.

    use listsmodule, only: baseconnectionlist, baseexchangelist
    class(ConnectionBuilderType) :: this !< the connection builder object
    type(ListType), pointer, intent(in) :: exchanges !< the list of exchanges to process
    type(ListType), intent(inout) :: newConnections !< the newly created connections
    ! local
    class(DisConnExchangeType), pointer :: conEx
    class(BaseExchangeType), pointer :: baseEx
    integer(I4B) :: iex, ibasex
    class(SpatialModelConnectionType), pointer :: modelConnection
    logical(LGP) :: isPeriodic
 
    do iex = 1, exchanges%Count()
      conex => getdisconnexchangefromlist(exchanges, iex)
      if (.not. associated(conex)) then
        ! if it is not DisConnExchangeType, we can skip it
        cycle
      end if
 
      ! for now, if we have XT3D on the interface, we use a connection,
      ! (this will be more generic in the future)
      if (conex%use_interface_model() .or. conex%dev_ifmod_on &
          .or. this%dev_always_ifmod) then
 
        ! we should not get period connections here
        isperiodic = (conex%v_model1 == conex%v_model2)
        if (isperiodic) then
          write (*, *) 'Error (which should never happen): interface model '// &
            'does not support periodic boundary condition'
          call ustop()
        end if
 
        if (conex%v_model1%is_local) then
          ! create model connection for model 1
          modelconnection => createmodelconnection(conex%model1, conex)
          call add_smc_to_list(baseconnectionlist, modelconnection)
          call add_smc_to_list(newconnections, modelconnection)
        end if
 
        ! and for model 2
        if (conex%v_model2%is_local) then
          modelconnection => createmodelconnection(conex%model2, conex)
          call add_smc_to_list(baseconnectionlist, modelconnection)
          call add_smc_to_list(newconnections, modelconnection)
        end if
 
        ! remove this exchange from the base list, ownership
        ! now lies with the connection
        do ibasex = 1, baseexchangelist%Count()
          baseex => getbaseexchangefromlist(baseexchangelist, ibasex)
          if (conex%id == baseex%id) then
            call baseexchangelist%RemoveNode(ibasex, .false.)
            exit
          end if
        end do
 
      end if
    end do
 

Here is the call graph for this function:

processsolution()

subroutine connectionbuildermodule::processsolution	(	class(connectionbuildertype)	this,
		class(basesolutiontype), pointer	solution )

This routine processes all exchanges in a solution and, when required, creates model connections of the proper type (GWF-GWF, GWT-GWT, ...) for a subset. It removes this subset of exchanges from the solution and replaces them with the created connections.

Parameters

this	the connection builder object
solution	the solution for which the exchanges are processed

Definition at line 40 of file ConnectionBuilder.f90.

    class(ConnectionBuilderType) :: this !< the connection builder object
    class(BaseSolutionType), pointer :: solution !< the solution for which the exchanges are processed
    ! local
    class(NumericalSolutionType), pointer :: numSol
    type(ListType) :: newConnections
 
    ! we only deal with Num. Sol. here
    select type (solution)
    class is (numericalsolutiontype)
      numsol => solution
    class default
      return
    end select
 
    ! create the connections and add local exchanges
    call this%processExchanges(numsol%exchangelist, newconnections)
    if (newconnections%Count() == 0) then
      return
    end if
 
    write (iout, '(1x,a,i0,a,a)') 'Created ', newconnections%Count(), &
      ' model connections for solution ', trim(solution%name)
 
    ! create the topology of models participating in the interfaces
    call this%createModelConnectivity(newconnections)
 
    ! replace numerical exchanges in solution with connections
    call this%setConnectionsToSolution(newconnections, numsol)
 
    ! clean up local resources
    call newconnections%Clear(destroy=.false.)
 

setconnectionstosolution()

subroutine connectionbuildermodule::setconnectionstosolution ( class(connectionbuildertype) this, type(listtype), intent(inout) connections, class(numericalsolutiontype), intent(in), pointer solution )

private

This adds the connections to the solution and removes those exchanges which are replaced by a connection

Parameters

	this	the connection builder object
[in,out]	connections	the connections created for the solution
[in]	solution	the solution to which the connections are set

Definition at line 194 of file ConnectionBuilder.f90.

    class(ConnectionBuilderType) :: this !< the connection builder object
    type(ListType), intent(inout) :: connections !< the connections created for the solution
    class(NumericalSolutionType), pointer, intent(in) :: solution !< the solution to which the connections are set
    ! local
    type(ListType) :: keepList
    class(*), pointer :: exPtr, exPtr2, connPtr
    class(SpatialModelConnectionType), pointer :: conn
    integer(I4B) :: iex, iconn
    logical(LGP) :: keepExchange
 
    ! first add all exchanges not replaced by the connections to a list
    do iex = 1, solution%exchangelist%Count()
      exptr => solution%exchangelist%GetItem(iex)
      ! will this exchange be replaced by a connection?
      keepexchange = .true.
      do iconn = 1, connections%Count()
        conn => get_smc_from_list(connections, iconn)
        exptr2 => conn%prim_exchange
        if (associated(exptr2, exptr)) then
          ! if so, don't add it to the list
          keepexchange = .false.
          exit
        end if
      end do
 
      if (keepexchange) then
        call keeplist%Add(exptr)
      end if
    end do
 
    ! first add persisting exchanges
    call solution%exchangelist%Clear(destroy=.false.)
    do iex = 1, keeplist%Count()
      exptr => keeplist%GetItem(iex)
      call solution%exchangelist%Add(exptr)
    end do
 
    ! now add connections
    do iconn = 1, connections%Count()
      connptr => connections%GetItem(iconn)
      call solution%exchangelist%Add(connptr)
    end do
 
    ! clean up
    call keeplist%Clear(destroy=.false.)
 

Here is the call graph for this function: