Multigridding is a technique for increasing the speed of convergence of a finite element solution. The high level motivation is that within a coarse discretization of a problem, unresolved forces travel quickly throughout the environment, but are inaccurate. With a fine discretization, accuracy is high, but forces travel very slowly throughout the environment. Multigridding takes advantage of this by change levels in the hierarchy in some regular way, bouncing between coarse, large scale distributions of forces, and fine, accurate resolving of the forces.
An example of this is a large system of springs. Unresolved forces in a discretized system can travel from one node to it's neighbors. If the system is discretized very finely, and one element is moved, the forces will take a long time to move across the system, and even longer to finally converge. In a coarse distribution, they will move much faster, but can't converge to an accurate enough solution. By spending some time at a coarse level, some at a finer level, and moving back and forth between them, the solution converges much more quickly.
The details of multigridding are much more complicated than this. But they aren't important to what we are trying to do. The idea we want to take out of this is that with a coarse discretization we can get a coarse solution that can provide information that can be used to create a more accurate solution more efficiently. The coarse solution is computationally cheap, so we don't loose anything by it. In fact, for hierarchical radiosity, the overhead is insignificant.
The overall idea is to create a set of links using a very coarse (large) error bound, and solve the system. Now we have a rough idea of where there is a lot of energy in the environment, and where there is a lot of error. We then refine those links that have a lot of error, often reducing the error bound some at the same time, and solve again, getting a better idea of where more work needs to be done. The goal is that the final system of links will have no link that was subdivided needlessly.
We can express this in pseudocode as follows:
foreach rec,src
CreateLinks(rec,src,epsilon)
SolveSystem()
repeat
decrease epsilon
foreach link
if(link->ComputeError() > epsilon)
rec->Delete(link)
CreateLinks(rec,link->src,epsilon)
SolveSystem()
until (epsilon <= finalEpsilon)
This is pseudocode, you need to make sure you have the right information available to you when you need it.