# Porting a problem from Clawpack 4.6.x to PyClaw¶

The script pyclaw/development/clawdata2pyclaw.py is intended to aid in converting a Clawpack 4.6 problem setup to PyClaw. However, some manual conversion is necessary, especially if the problem includes custom fortran routines.

In PyClaw, the high-level portions of the Fortran routines are reorganized in an object-oriented Python framework, while the low-level ones are bound through the Fortran to Python interface generator f2py. Therefore, for simple problems you won’t need to call f2py directly. However, if you want to reutilize some problem-specific fortran routines that were set up and tested in a Clawpack problem, you can easily do it. Indeed, if those routines are complicated and/or computationally intensive, you should consider directly using the f2py interface in the initialization script (see Setting up your own problem). The example in clawpack/pyclaw/examples/shallow_sphere, which solves the shallow water equations on the surface of a sphere, is a complete example that relies heavily on the use of problem-specific Fortran routines. In that problem setup, a few Fortran routines have been used to provide the following functionality:

Initialize the solution

`state.q[:,:,:]`

Provide the mapping from a uniform Cartesian domain to the desired physical domain, i.e. the mapc2p function

Setup the auxiliary variables

`state.aux[:,:,:]`

Compute the (non-hyperbolic) contribution of a source term

Impose custom boundary conditions to both solution and auxiliary variables

The first step to succesfully interface the Fortran functions with PyClaw is to automate the extension module generation of these routines through f2py. You can use clawpack/pyclaw/examples/shallow_sphere/Makefile as a template:

```
# Problem's source Fortran files
INITIALIZE_SOURCE = mapc2p.f setaux.f qinit.f src2.f
problem.so: $(INITIALIZE_SOURCE)
$(F2PY) -m problem -c $^
```

The code above, calls f2py to compile a set of Fortran routines
and build a module
(`problem.so`

) which can then be imported as a function in Python.
The argument following the ‘’-m’’ flag is the name the python module should have (i.e.
the name of the target). f2py uses the `numpy.distutils`

module from NumPy
that supports a number of major Fortran compilers. For more information
see http://www.scipy.org/F2py.

After compilation, it is useful to check the signature of each
function contained in `problem.so`

, which may be different than
that of the original Fortran function, since f2py eliminates dummy variables.
One can easily achieve that by using the following commands:

```
$ ipython
>>> import problem
>>> problem?
```

The last command queries the content of the module and outputs the functions’ signature that must be used in the initialization script to correctly call the fortran functions. In the shallow water equations on a sphere example, we get the following output:

```
>>> Type: module
>>> Base Class: <type 'module'>
>>> String Form: <module 'problem' from 'problem.so'>
>>> Namespace: Interactive
>>> File: /Users/../../../clawpack/pyclaw/examples/shallow-sphere/problem.so
>>> Docstring:
This module 'problem' is auto-generated with f2py (version:1).
Functions:
mapc2p(x1,y1,xp,yp,zp,rsphere)
aux = setaux(maxmx,maxmy,num_ghost,mx,my,xlower,ylower,dxc,dyc,aux,rsphere,num_aux=shape(aux,0))
q = qinit(maxmx,maxmy,num_ghost,mx,my,xlower,ylower,dx,dy,q,aux,rsphere,num_eqn=shape(q,0),num_aux=shape(aux,0))
q = src2(maxmx,maxmy,num_ghost,xlower,ylower,dx,dy,q,aux,t,dt,rsphere,num_eqn=shape(q,0),mx=shape(q,1),my=shape(q,2),num_aux=shape(aux,0))
```

For instance, the function `src2`

, which computes the contribution of the
(non-hyperbolic) source term, has the following intent variables:

```
>>> cf2py integer intent(in) maxmx
>>> cf2py integer intent(in) maxmy
>>> cf2py integer optional, intent(in) num_eqn
>>> cf2py integer intent(in) num_ghost
>>> cf2py integer intent(in) mx
>>> cf2py integer intent(in) my
>>> cf2py double precision intent(in) xlower
>>> cf2py double precision intent(in) ylower
>>> cf2py double precision intent(in) dx
>>> cf2py double precision intent(in) dy
>>> cf2py intent(in,out) q
>>> cf2py integer optional, intent(in) num_aux
>>> cf2py intent(in) aux
>>> cf2py double precision intent(in) t
>>> cf2py double precision intent(in) dt
>>> cf2py double precision intent(in) Rsphere
```

Note that `num_eqn`

, `mx`

, `my`

`num_aux`

are identified by f2py as optional
arguments since their values can be retrieved by looking at the dimensions of
other multidimensional arrays, i.e. `q`

and `aux`

.

We are now ready to call and use the Fortran functions in the initialization
script. For instance, the `src2`

function is called in the
script by using a fortran_src_wrapper function whose main part reads:

```
>>> # Call src2 function
>>> import problem
>>> state.q = problem.src2(mx,my,num_ghost,xlowerg,ylowerg,dx,dy,q,aux,t,dt,Rsphere)
```

A similar approach is used to call other wrapped Fortran functions like
`qinit`

, `setaux`

, etc.

An important feature that makes PyClaw more flexible is the
capability to replace the standard low-level Fortran routines whith some
problem-specific routines. Binding new low-level functions and replacing the
standard ones is very easy; the user just needs to modify the problem-specific
Makefile. The shallow water equations on a sphere is again a
typical example that uses this nice feature. Indeed, to run correctly the problem an
ad-hoc `step2`

function (i.e. the `step2qcor`

) is required. For that problem
the interesting part of the Makefile
reads:

```
# Override step2.f with a new function that contains a call to an additional
# function, i.e. qcor.f
# ==========================================================================
override TWO_D_CLASSIC_SOURCES = step2qcor.f qcor.o flux2.o limiter.o philim.o
qcor.o: qcor.f
$(FC) $(FFLAGS) -o qcor.o -c qcor.f
```

The user has just to override `step2.f`

with the new function `step2qcor.f`

and provide new:

```
output_filenames : input_filenames
actions
```

rules to create the targets required by the new Fortran routine. Similar changes to the problem-specific Makefile can be used to replace other low-level Fortran routines.