On Friday 14 December 2007, mhampton wrote:
> I am interested - I have done some work in celestial mechanics,
> although not using poisson and fourier series.  Since I don't have a
> lot of expertise, I'm not sure I can be much help, but I thought I
> would at least make a gesture of support :)
>
> I think it would be nice, on the wiki page, if you showed an example
> calculation in which Piranha was used.  That would help me understand
> its scope better.
>
> Cheers,
> Marshall Hampton
> University of Minnesota, Duluth

Hi Marshall,

first of all let me thank you for your reply. You are right, the wiki badly 
needs more input, and I'll try to update it soon. At the moment I'm quite 
busy coding and completing my thesis, which you can find as a work in 
progress under this git tree:

http://git.tuxfamily.org/?p=gitroot/piranha/doc.git;a=summary

In the thesis, if you are interested, you can find more in-depth discussion 
about Poisson series and Piranha. In the rest of this mail I'll try, as 
tersely as possible, to explain briefly the deal with Poisson series and 
Piranha.

Poisson series are, simply put, multi-variate Fourier series in which the 
coefficients are multi-variate polynomials. In classical Celestial Mechanics, 
the subset of Poisson series in which the coefficients are purely numerical 
are sometimes called simply "Fourier series".

Such objects arise in perturbative methods in Celestial Mechanics. The 
expansion of the perturbing gravitational potential, for instance, naturally 
leads to Poisson series. Briefly put, the Poisson series form is convenient 
because it allows to determine the spectrum of the perturbation and hence 
apply the known methods of solution for the motion of systems of 
self-gravitating celestial bodies (Solar System, planetary systems, etc.).

In Celestial Mechanics research one typically has to deal with Poisson series 
in which the number of terms goes from few tens to millions, and hence 
specialized manipulators are needed. Performance is of primary concern, as 
optimal memory utilization is. The operations needed to be performed on 
Poisson sereis are typically simple conceptually: addition/subtraction, 
multiplication, square root, differentiation, etc.

Piranha is a manipulation framework: this means that it defines rules and 
provides ready-to-use routines to build your own manipulator with little 
effort. This is done through extensive use of the so-called "modern" C++ 
programming style - template (meta)programming and extensive use of 
Object-Oriented facilities (e.g., inheritance, operator-overloading, etc.). 
Performance is never sacrificed though, since runtime Object-Oriented 
programming style (e.g., dynamic polymorphism) is avoided in favour of 
a "static" (i.e., compile time) style which makes use of template-related 
design patterns (like the Curiously Recurring Template Pattern).

As a result, Piranha compares favourably performance-wise with 
well-established manipulators in the field, like the closed-source TRIP, 

http://www.imcce.fr/Equipes/ASD/trip/trip.php

but at the same time retaining a clean and well-structured architecture that 
allows for easy extensions and improvements. On of the problems of Poisson 
series manipulators is in fact that they are often either too much 
specialized or difficult to extend (when the source code is available at 
all). As far as I know, Piranha is the first OO Poisson series manipulator.

Piranha at the moments provides 4 manipulators, of which 3 are Fourier series 
manipulator and the other one is a Poisson series manipulator (at the moment 
it is broken because it is being re-worked). Code re-use between these 
manipulators is very high thanks to Piranha's architecture. SLOCs are around 
12,000.

Piranha internally uses data structures like binary search trees and 
hash-tables, and make also extensive use of the Boost C++ library:

http://www.boost.org

It also contains an implementation of a technique for the multiplication of 
Poisson series and sparse multivariate polynomials which, as _far_ as I know, 
seems original and I've called "coded arithmetics", which seems to give 
pretty good performance.

The set of Python bindings for Piranha is called Pyranha (heh), and aims to 
expose all the functionality of the underlying C++ classes 
(the "manipulators") in Python. Pyranha has some graphics capabilities in the 
form of matplotlib interaction for series plotting and a embryo GUI in PyQt.

I think it is enough for now, I hope I was not too boring ;) Surely I left 
something out but... please ask me if you want to know more.

Thanks again,

  Francesco.

Attachment: signature.asc
Description: This is a digitally signed message part.

Reply via email to