More aperture is better. I’ve started to build a 240 mm Newtonian with some mirror blanks from Tammilasi and knowledgeable help and grinding materials from Teknofokus.

The first task was to grind the 240 mm diameter (40 mm thick) borosilicate mirror blanks flat on each side. This took around 1.5 hours per side using 60-grit silicon carbide and grinding against a flat steel plate.

See also mirror grinding video by The Sky at Night/BBC.

Update: Thanks to everyone who replied! It’s a Grey Heron, Ardea cinerea.

Ilkka (who runs kiteile.com) decided to make a kite-board by infusion moulding. He made 3-4 trials first, and this is the first full-size real kite-board. It’s now cured and out of the bag and it looks like everything worked fine.

En motorbåt körde på Skåldö färjans vajer ca 19:30 tiden. Alla ombord verkade ha klarat sig utan större skador och fördes bort med ambulans. Motorbåten satt fast i vajern och brandkår + färj-kapten försökte först få loss båten, men det slutade med att färjan togs loss från vajern och båt+vajer sjönk till bottnen! Färj trafiken löpte normalt igen ca 20:45.

Här en animation där man ser båten sjunka: farjan_animation2 (5 Mb AVI-fil)

With the servo-upgrade of the cnc-mill complete we are now beginning to run the kind of jobs that weren’t previously possible. Stepper motors simply don’t give the kind of 3D contouring capability and reliability for running 3-4 hour finish jobs like these. The finmould is finished with a 6 mm ball-nose cutter.

Jari made these moulds in steel, but it’s possible to cut them in aluminium too. The fin mould here has a NACA 0010 section and the rudder has a thicker NACA 0015 section. With the precision that cnc-cutting provides we hope that the fin can come out of the mould quite complete and fit a cnc-cut finbox/bulb without much manual fitting.

We can produce fin, rudder, and bulb moulds in steel or aluminium on a small scale. Get in touch by email or by commenting below if you are an interested IOM-builder.

In an attempt to image the acoustic fields emerging from ultrasound transducers we’ve built a small Schlieren setup with stroboscopic LED illumination. There’s a 10-cycle 7.5 MHz sound-wave coming in from the top at a velocity of around 1500 m/s, and if you illuminate it at just the right time with a 500 ns pulse of light you see the change in refractive index due to the pressure change. In the videos we are adjusting the delay between the acoustic pulse and the light-pulse from about 0 us up to 10 us to see how the sound propagates through the ~15 mm field of view.

Here’s another one with a reflecting metal piece at the bottom. The reflected pulse shows quite nicely! If you look carefully between 3 and 4 s you can see an interference pattern between the incoming and reflected pulse.

But then I found Mark Dufour’s project shedskin (see also blog here and Mark’s MSc thesis here), a Python to C++ compiler! Can you have the best of both worlds? Develop and debug your code interactively with Python and then, when you’re happy with it, translate it automagically over to C++ and have it run as fast as native code?

Well, shedskin doesn’t support any and all python constructs (yet?), and only a limited number of modules from the standard library are supported. But still I think it’s a pretty cool tool. For someone who doesn’t look forward to learning C++ from the ground up typing ‘shedskin -e myprog.py‘ followed by ‘make‘ is just a very simple way to create fast python extensions! As a test, I ran shedskin on the pystone benchmark and called both the python and c++ version from my multiprocessing test-code:

Python version

Processes	Pystones	Wall time	pystones/s	Speedup
1		50000		0.7		76171		1.0X
2		100000		0.7		143808		1.9X
3		150000		0.7		208695		2.7X
4		200000		0.8		264410		3.5X
5		250000		1.0		244635		3.2X
6		300000		1.2		259643		3.4X

’shedskinned’ C++ version

Processes	Pystones	Wall time		pystones/s	Speedup
1		5000000			2.9		1696625		1.0X
2		10000000		3.1		3234625		1.9X
3		15000000		3.1		4901829		2.9X
4		20000000		3.4		5968676		3.5X
5		25000000		4.4		5714151		3.4X
6		30000000		5.1		5890737		3.5X

A speedup of around 20x.

I’ve been playing around with vpython, so you can expect some CAM-related posts on drop-cutter in Python and associated 3D views or animations in the not too distant future.

" Simple multiprocessing test.pystones benchmark "
" Anders Wallin 2008Jun15 anders.e.e.wallin (at) gmail.com "
from test import pystone
import processing
import time

STONES_PER_PROCESS= 10*pystone.LOOPS

def f(q):
    t=pystone.pystones(STONES_PER_PROCESS)
    q.put(t,block=True)

if __name__ == '__main__':
    print 'multiprocessing test.pystones() benchmark'
    print 'You have '+str(processing.cpuCount()) + ' CPU(s)'
    print 'Processes\tPystones\tWall time\tpystones/s'

    results = processing.Queue()
    for N in range(1,processing.cpuCount()+3):
        p=[]
        q=processing.Queue()
        results=[]

        for m in range(1,N+1):
            p.append( processing.Process(target=f,args=(q,)) )

        start=time.time()
        for pr in p:
            pr.start()
        for r in p:
            results.append( q.get() )
        stop=time.time()

        cputime = stop-start    

        print str(N)+’\t\t’+str(N*STONES_PER_PROCESS) \
              +’\t\t’+ str(cputime)+’\t’+str( N*STONES_PER_PROCESS / cputime )