# Dissecting the Poisson Codes¶

Objective: At the end of this tutorial you will understand how a simple linear solver works in PetIGA.

Assumptions: I assume that you are familiar with C and in particular understand pointers.

## Detailed Look at `Poisson1D.c`¶

In this tutorial we will look at the Poisson codes and explain each portion in more detail. It is my hope that in explaining how the demo codes work, this will help you see how you can use PetIGA to address your own problems. In this demo I will be discussing this demo code in sections. It might be useful to first scan through this code to familiarize yourself with its organization.

In most PetIGA applications, you only need to include `petiga.h`. Including this file will also automatically include `petsc.h`.

```#include "petiga.h"
```

The first function we encounter is the `System` function. This function is the key to understanding how to use PetIGA to solve your own problems. For a linear, steady problem, this function represents the evaluation of the bilinear and linear form at a quadrature point.

At a glance, a few things may strike you as strange particularly if you are not familiar with PETSc. First, you will note the `#undef` and `#define` lines before the function declaration. This is a mechanism that PETSc uses such that when its functions fail, the entire call stack is returned to the user. This is typically something that you only get when running the debugger. Having it always return on error reduces the time it takes you to locate errors.

You will also see variable types `PetscReal` and `PetscScalar` instead of the expected `double`. These are PETSc types which for most applications are actually of the type `double`. However, you can configure PETSc to use, for example, quadruple precision or complex numbers. In this case, using PETSc types means that your code automatically ports to these situations with no additional work for you.

The function has as its arguments a `IGAPoint`, two PetscScalars and a void pointer. For now, ignore the existence of the void pointer. The `IGAPoint p` is the quadrature/collocation point. We have built in all the information that you will need to evaluate the bilinear and linear form at this point. The two PetscScalar pointers are for the discretized bilnear and linear form respectively. The variable `K` can be thought of as a flattened point contribution to the element stiffness matrix. The variable `F` is the point contribution to the element load vector.

The basis functions are part of the IGAPoint `p` and so we need to simply assign some pointers to their location. The pointers `N0` and `N1` represent the 0th and 1st order derivative of the basis functions respectively. The pointers used and their casting is a bit technical and ugly, a consequence of using the C language. However, we emphasize that it is sufficient to copy these lines into your own code and understand what it is the pointers address. If a geometry is used, then the basis is mapped and/or made rational if using NURBS. Otherwise, these are just the B-spline basis functions in the parametric space. Your code does not need to know the difference, it is all handled internally.

Then we simply code a double loop over the local number of basis functions, `nen`. As a convention, we use `a` to loop over the test functions and `b` to loop over the trial functions. A dot product of the basis function derivatives is assembled into the stiffness matrix and the unit body force is assembled into the load vector. The quadrature weights and potential Jacobian of the mapping are applied internally.

```#undef  __FUNCT__
#define __FUNCT__ "System"
PetscErrorCode System(IGAPoint p,PetscScalar *K,PetscScalar *F,void *ctx)
{
const PetscReal *N0,(*N1);
IGAPointGetShapeFuns(p,0,(const PetscReal**)&N0);
IGAPointGetShapeFuns(p,1,(const PetscReal**)&N1);
PetscInt a,b,nen=p->nen;
for (a=0; a<nen; a++) {
PetscReal Na   = N0[a];
PetscReal Na_x = N1[a];
for (b=0; b<nen; b++) {
PetscReal Nb_x = N1[b];
K[a*nen+b] = Na_x * Nb_x;
}
F[a] = Na * 1.0;
}
return 0;
}
```

Below this we code the program’s main function. As in all PETSc codes, we intially call an initialization routine. Consider this a rite-of-passage which is required for PETSc’s internals and parallelism. However, another oddity may jump out at you. You will see that we have defined an error code `ierr` and then after the PETSc call, we postpend a function call `CHKERRQ(ierr)`. If you glance at the rest of the code, you will see this pattern appears at most every line of the code (yes they are ugly, be patient, eventually you won’t notice them). Every function in PETSc/PetIGA returns such a code which is really just an integer whose value corresponds to a error type. The function call at the end is really a macro which will cause the application to fail and report the proper error messages/stack.

```#undef __FUNCT__
#define __FUNCT__ "main"
int main(int argc, char *argv[]) {

PetscErrorCode  ierr;
ierr = PetscInitialize(&argc,&argv,0,0);CHKERRQ(ierr);
```

Now we create an `IGA`, your one-stop-shop for the IGA-discretization. We set the dimensions of the space as well as the number of degrees of freedom per basis. Basic usuage of an `IGA` in PetIGA assume that the same function space is used for all test/trial spaces in the problem. This is a constraint that we will later show how to relax. The `XXXSetFromOptions` calls in PETSc are very important. This call is what populates the list of options that you see when you run the code with the `-help` option. The final call is an internal setup of many data structures which we need to compute. This is considered a final step of creating the `IGA`. There are many other ways to initialize an `IGA`, this way is just the simplest and uses the default discretizations.

```IGA iga;
ierr = IGACreate(PETSC_COMM_WORLD,&iga);CHKERRQ(ierr);
ierr = IGASetDim(iga,1);CHKERRQ(ierr);
ierr = IGASetDof(iga,1);CHKERRQ(ierr);
ierr = IGASetFromOptions(iga);CHKERRQ(ierr);
ierr = IGASetUp(iga);CHKERRQ(ierr);
```

In this block we set the boundary conditions. Again, there are many ways you can set boundary conditions in PetIGA. Here we will set a single value on all basis functions on the boundaries. The `IGABoundary` represents a side in 1D, a boundary edge in 2D, and a boundary face in 3D. You get the boundary object from the `IGA` itself by specifying a direction (which parametric dimension) and then a side (0 or 1 reflecting the min and max of the axis). With the `IGABoundary` in hand, then you can set a constant value on all associated basis functions of a particular component of the solution. Since this is a scalar problem, we set the 0th component.

```IGABoundary bnd;
PetscInt dir=0,side;
PetscScalar value = 1.0;
for (side=0; side<2; side++) {
ierr = IGAGetBoundary(iga,dir,side,&bnd);CHKERRQ(ierr);
ierr = IGABoundarySetValue(bnd,0,value);CHKERRQ(ierr);
}
```

Now we setup and compute the linear system of our problem, `Ax=b`. Both `Mat` and `Vec` are PETSc types which encapsulate sparsity and parallel communication. You do not need to understand how these work internally–they are given to you by the `IGA`. The call to `IGASetUserSystem` associates the `System` function we wrote earlier to the discretization. The `IGA` uses this function in the next call to assemble the linear system.

```Mat A;
Vec x,b;
ierr = IGACreateMat(iga,&A);CHKERRQ(ierr);
ierr = IGACreateVec(iga,&x);CHKERRQ(ierr);
ierr = IGACreateVec(iga,&b);CHKERRQ(ierr);
ierr = IGASetUserSystem(iga,System,NULL);CHKERRQ(ierr);
ierr = IGAComputeSystem(iga,A,b);CHKERRQ(ierr);
```

Then we need a `KSP` to solve the linear system. This we also get from our `IGA`. This merely ensures that the `KSP` and the `IGA` use the same communicator (a detail of parallelism which you can ignore). Then we need to set the problem operators by KSPSetOperators. The first assignment of `A` is for the problem operator. The second assignment of `A` specifies the matrix from which PETSc will create a preconditioner. In this case, and in many cases, we want the preconditioner to be created from original system matrix. We also specify a flag for the `KSP` that our preconditioner has the same nonzero pattern as the matrix `A`. As before with the `IGA`, we add the `XXXSetFromOptions` call which will allows us to control everything about the `KSP` from the commandline. Finally, we solve.

```KSP ksp;
ierr = IGACreateKSP(iga,&ksp);CHKERRQ(ierr);
ierr = KSPSetOperators(ksp,A,A,SAME_NONZERO_PATTERN);CHKERRQ(ierr);
ierr = KSPSetFromOptions(ksp);CHKERRQ(ierr);
ierr = KSPSolve(ksp,b,x);CHKERRQ(ierr);
```

This call to file:VecView is optional. It is what will draw a rough plot of the degrees of freedom, as described in Post-processing Results with igakit

```ierr = VecView(x,PETSC_VIEWER_DRAW_WORLD);CHKERRQ(ierr);
```

Finally, we destroy the objects that we created and issue a finalize call to PETSc.

``` ierr = KSPDestroy(&ksp);CHKERRQ(ierr);
ierr = MatDestroy(&A);CHKERRQ(ierr);
ierr = VecDestroy(&x);CHKERRQ(ierr);
ierr = VecDestroy(&b);CHKERRQ(ierr);
ierr = PetscFinalize();CHKERRQ(ierr);
return 0;
}
```

That is all that you need to do, everything else in handled internally in the PetIGA library. We feel that our approach is beneficial because it leads to shorter codes which focus on the physics of the problem. We also emphasize that this code will work in serial or in parallel without the author needing to know anything about parallelism aside from having to initialize objects with communicators.

## Higher Dimensions and Dimension Independent¶

How different is the code when changing dimensions of the problem? There is very little which depends on the problem dimension in the application code. If we compare to `PETIGA_DIR/demo/Poisson2d.c`, we have a few lines in our `System` function which are different. The pointers to the shape function gradients are now 2D:

```const PetscReal *N0,(*N1);
```
```const PetscReal *N0,(*N1);
```

and the dot product is now 2D:

```K[a*nen+b] = Na_x * Nb_x;
```
```K[a*nen+b] = Na_x*Nb_x + Na_y*Nb_y;
```

In `main` we also have a few lines:

```ierr = IGASetDim(iga,1);CHKERRQ(ierr);
```
```ierr = IGASetDim(iga,2);CHKERRQ(ierr);
```

and we need to set more boundary conditions. In fact, this reflects that a dimension independent code is simple to obtain.