Das Plücker Konoid

Mag. Katrin Brunnthaler & Mag. Martin Pfurner

Definition

Das Plücker Konoid ist ein gerades Konoid.

Im folgenden werden drei unterschiedliche Möglichkeiten, diese Regelfläche zu erzeugen, angeführt:

1.) Gegeben seien zwei windschiefe Geraden e und f, weiters sei das Gemeinlot d auf diese beiden Geraden

.    bestimmt. Man wähle auf der Erzeugenden e einen Punkt und lege durch diesen Punkt all jene

     Geraden, die die zweite Gerade f treffen. Die Geraden der Regelfläche ergeben sich als jene Geraden, die die

     Geraden des Strahlbüschels und die Gerade d unter einem rechten Winkel schneiden.

2.) Man bestimme einen ebenen Schnitt (Ellipse e) eines Drehzylinders. Die eigentliche Leitgerade

     des geraden Konoids soll eine jener Erzeugende d des Drehzylinders sein, die durch einen der beiden Nebenscheitel

     der Ellipse geht. Die Erzeugenden der Regelfläche ergeben sich dann als jene Geraden, die die Leitgerade d unter

     einem rechten Winkel schneiden und die Ellipse e treffen.

3.) KINEMATISCHE ERZEUGUNG: Das Plücker Konoid kann auch erzeugt werden, indem einen ebener Schnitt

     eines Drehzylinders (Ellipse e) bei der Rollung dieses Zylinders in einem Drehzylinder mit doppeltem Radius mitgenommen

     wird. Die Punkte von e besitzen dann nämlich Bahnkurven, die geradlinig sind und auf einem Plücker Konoid liegen.

Utils

>    restart;

>    with(linalg):

>    with(plots):

Warning, the protected names norm and trace have been redefined and unprotected

Warning, the name changecoords has been redefined

Gleichung

Im folgenden wird von der ersten Erzeugungsweise des Plücker Konoids ausgegangen. Es wird versucht, davon auch die

zweite mögliche Erzeugungsweise abzuleiten. Außerdem sollen besondere Schnitte dieses Konoids betrachtet werden.

Dazu wird das kartesische Koordinatensystem so gewählt, dass die eigentliche Leitgerade mit der z-Achse zusammenfällt.

Eine der beiden windschiefen Erzeugenden (jene, auf der der Scheitel des Strahlbüschels liegt) soll mit der

x-Achse zusammenfallen. Die zweite Erzeugende liegt in der Ebene z=h, der Winkel zwischen beiden Erzeugenden ist phi .

Die Koordinaten werden mit Kleinbuchstaben bezeichnet.

>    z:=vector([0,0,1]);

>    P1:=vector([p,0,0]);

>    P2:=vector([t*cos(phi),t*sin(phi),h]);

>    S:=evalm(P2-P1);

>    EV:=crossprod(z,S);

z := vector([0, 0, 1])

P1 := vector([p, 0, 0])

P2 := vector([t*cos(phi), t*sin(phi), h])

S := vector([t*cos(phi)-p, t*sin(phi), h])

EV := vector([-t*sin(phi), t*cos(phi)-p, 0])

Durch einfache Vektoraddition ergibt sich die Parameterdarstellung der Fläche:

>    equ:=evalm(scalarmul(z,alpha)+scalarmul(EV,beta)-scalarmul(S,epsilon)-P1);

equ := vector([-beta*t*sin(phi)-epsilon*(t*cos(phi)-p)-p, beta*(t*cos(phi)-p)-epsilon*t*sin(phi), alpha-epsilon*h])

>    solve({equ[1],equ[2],equ[3]},{alpha,beta,epsilon});

{beta = -p*t*sin(phi)/(t^2-2*t*cos(phi)*p+p^2), epsilon = -p/(t^2-2*t*cos(phi)*p+p^2)*(t*cos(phi)-p), alpha = -p/(t^2-2*t*cos(phi)*p+p^2)*(t*cos(phi)-p)*h}

>    assign(%);

>    PK:=matadd(vector([0,0,alpha]),scalarmul(EV,lambda));

PK := vector([-lambda*t*sin(phi), lambda*(t*cos(phi)-p), -p/(t^2-2*t*cos(phi)*p+p^2)*(t*cos(phi)-p)*h])

Die Parameterdarstellung des Plücker Konoids ist also bekannt, die Parameter lambda  und t sind variabel, phi , p und h haben feste

Werte. Im folgenden interessiert man sich für die Gleichung dieser Fläche, diese erhält man durch Elimination der Parameter aus

den drei bekannten Gleichungen der Parameterdarstellung der Fläche: (Die Koordinatenfunktionen der Parameterdarstellung werden

mit Großbuchstaben bezeichnet.)

>    solve(PK[1]-X,lambda);

-X/t/sin(phi)

>    lambda:=%;

lambda := -X/t/sin(phi)

>    solve(PK[2]-Y,t);

X*p/(X*cos(phi)+Y*sin(phi))

>    t:=%;

t := X*p/(X*cos(phi)+Y*sin(phi))

>    Zs:=factor(simplify(PK[3],trig));

Zs := -(X*cos(phi)+Y*sin(phi))*Y*sin(phi)*h/(cos(phi)-1)/(cos(phi)+1)/(X^2+Y^2)

Man sieht, dass die Wahl des Punktes P1 nicht in die Gleichung der Fläche einfließt!

>    ZK:=Zs-Z;

ZK := -(X*cos(phi)+Y*sin(phi))*Y*sin(phi)*h/(cos(phi)-1)/(cos(phi)+1)/(X^2+Y^2)-Z

>    GL:=numer(normal(ZK));

GL := -Y*sin(phi)*h*X*cos(phi)-Y^2*sin(phi)^2*h+Z*X^2-Z*X^2*cos(phi)^2+Z*Y^2-Z*Y^2*cos(phi)^2

In dieser Gleichung sind phi  und h feste Werte; sie ist also von drittem Grade. Die Punkte des Konoids ergeben sich

als Nullstellenmenge dieser Gleichung für festgewähltes h.

Man könnte diese Gleichung implizit plotten. Diese Darstellung ist aber nicht sehr gut für Maple geeignet:

>    eval(subs(phi=Pi/2,h=1,GL));

-1/2*Y*X-1/2*Y^2+1/2*Z*X^2+1/2*Z*Y^2

>    plot3d([u*cos(t),u*sin(t),(cos(t)-sin(t))*sin(t)],t=0..2*Pi,u=-1..1,numpoints=3000);

>   

[Maple Plot]

>    implicitplot3d(%,X=-5..5,Y=-5..5,Z=2..5,grid=[17,17,17]);

[Maple Plot]

Schnitt mit einem Drehzylinder, der die z-Achse als Erzeugende trägt

Es wird nun der Schnitt des Plücker´schen Konoids mit einem Drehzylinder  bestimmt, wobei dieser die z-Achse als Erzeugende  

enthalten soll. Der Schnitt eines Drehzylinders mit dem Plücker´schen Konoid muß von der Ordnung 2*3=6 sein; da die Gerade d

eine doppelt zu zählende Gerade auf dem Konoid ist, verbleibt noch eine Kurve 4. Ordnung als Schnittkurve.

Mit xm, ym seien die Koordinaten jenes Mittelpunktes des Kreises bezeichnet, der als Leitkurve des Drehzylinders in der Grundrissebene

auftritt. Der Radius R ergibt sich dann automatisch. oBdA. sei für diese Überlegung phi  als Pi /4 gewählt.

>    phi:=Pi/4;
h:=1;

phi := 1/4*Pi

h := 1

>    R:=sqrt(ym^2+xm^2);

R := (ym^2+xm^2)^(1/2)

>    xzyl:=R*cos(theta)+xm;
yzyl:=R*sin(theta)+ym;

xzyl := (ym^2+xm^2)^(1/2)*cos(theta)+xm

yzyl := (ym^2+xm^2)^(1/2)*sin(theta)+ym

>    Z1:=simplify(subs(X=xzyl,Y=yzyl,Zs));

Z1 := 1/2*(cos(theta)*sin(theta)*ym^2+cos(theta)*sin(theta)*xm^2+(ym^2+xm^2)^(1/2)*cos(theta)*ym+xm*(ym^2+xm^2)^(1/2)*sin(theta)+xm*ym+2*ym^2-cos(theta)^2*ym^2+xm^2-cos(theta)^2*xm^2+2*(ym^2+xm^2)^(1/2...
Z1 := 1/2*(cos(theta)*sin(theta)*ym^2+cos(theta)*sin(theta)*xm^2+(ym^2+xm^2)^(1/2)*cos(theta)*ym+xm*(ym^2+xm^2)^(1/2)*sin(theta)+xm*ym+2*ym^2-cos(theta)^2*ym^2+xm^2-cos(theta)^2*xm^2+2*(ym^2+xm^2)^(1/2...

>    Zq:=subs(xm=0,ym=1,Z1);

Zq := 1/2*(cos(theta)*sin(theta)+cos(theta)+2-cos(theta)^2+2*sin(theta))/(1+sin(theta))

>    ZQ:=plot(Zq,theta=0..2*Pi,thickness=3):

>    Sin:=plot(.707*(0.707+sin(theta+0.5)),theta=0..2*Pi, color=blue):

(0.8 statt 0.5 gewählt => so liegt die Sinusfunktion auf k)

>    display(ZQ,Sin);

[Maple Plot]

Es ergibt sich im weitesten Sinne des Wortes eine Sinuslinie am Mantel des Drehzylinders. Aus der Theorie der Konstruktiven Geometrie ist

bekannt, dass der ebene Schnitt eines Drehzylinders (Ellipse) bei der Abwicklung eine Sinuslinie wird. Also ist diese Kurve im Raum eine

Ellipse!

Man kann die Schnittkurven auch mit den expliziten Gleichungen und dann mit der Resultantenmethode lösen:

>    GL1:=subs(phi=Pi/4,h=1,GL);

GL1 := -1/2*Y*X-1/2*Y^2+1/2*Z*X^2+1/2*Z*Y^2

>    Zyl:=(X-xm)^2+(Y-ym)^2-xm^2-ym^2;

Zyl := (X-xm)^2+(Y-ym)^2-xm^2-ym^2

>    expand(Zyl);

X^2-2*X*xm+Y^2-2*Y*ym

>    factor(resultant(GL1,Zyl,X));

1/2*Y^2*(Y^2-2*Z*Y*ym+2*Z^2*ym^2+xm*Y+2*ym*Z*xm-2*Z*xm^2-2*Y*Z*xm+2*Z^2*xm^2-Y*ym)

Wenn man den in Klammer stehenden Ausdruck homogenisiert, sieht man, dass die beiden komplexen Geraden X^2+Y^2 = 0  in der Fernebene teil der Schnittkurve sind!

Schnitt mit einer Tangentialebene

Schnitt mit einer allgemeinen Ebene , die eine Erzeugende des Plücker Konoids enthält. Da der ebene Schnitt dieses die Ordnung

3 hat, und in dem speziellen Fall die Erzeugende ein Teil des Schnittes ist, bleibt als Restschnitt eine Kurve zweiter Ordnung.

Wir betrachten im folgenden (der Einfachheit halber) jenes Ebenenbüschel, das als Träger die Erzeugende hat, die mit der

x-Achse zusammenfällt. Also sind all diese Ebenen zweitprojizierend.

>    ko:=factor(GL);

ko := -1/2*Y*X-1/2*Y^2+1/2*Z*X^2+1/2*Z*Y^2

>    subs(Z=0,%);

-1/2*Y*X-1/2*Y^2

>    factor(%);

-1/2*Y*(X+Y)

>    eb:=z-k*y;

eb := z-k*y

>    subs(Z=k*Y,ko);

-1/2*Y*X-1/2*Y^2+1/2*k*Y*X^2+1/2*k*Y^3

>    factor(%);

1/2*Y*(k*Y^2-Y-X+k*X^2)

Die Grundrisse der Schnittkurven ergeben sich bei y=0 und bei k*Y^2-Y-X+k*X^2 . Dies ist, für jede solche beliebige Ebene, ein Kreis durch den Ursprung.

Die Schnittkurve im Raum entsteht also als Schnitt eines Drehzylinders mit dem Plücker Konoid, oder als ebener Schnitt eben dieses Drehzylinders, wobei der Drehzylinder die z-Achse als Erzeugende trägt.

Die Schnittkurve ist also wieder eine Ellipse.

Zusammenhang der 1. und 2. Erzeugungsweise

Jetzt kann man auch sehen, wie die erste und die zweite Erzeugungsweise zusammenhängen: Nimmt man die Kurve der Lotfußpunkte, so liegen sie alle in einer

Ebene. Daher müssen die ersten 3 Ableitungen der Parameterdarstellung dieser Kurve linear abhängig sein. Ein ebener Schnitt eines Plücker Konoides ist

eine Ellipse. (Außerdem kann man zeigen, dass der Grundriss dieser Kurve ein Kreis ist, dass sie also auf einem Drehzylinder liegt!)

>    t:='t';

t := 't'

>    LFP:=matadd(vector([0,0,alpha]),scalarmul(EV,beta));

LFP := vector([1/2*p*t^2/(t^2-t*2^(1/2)*p+p^2), -1/2*p*t*2^(1/2)/(t^2-t*2^(1/2)*p+p^2)*(1/2*t*2^(1/2)-p), -p/(t^2-t*2^(1/2)*p+p^2)*(1/2*t*2^(1/2)-p)])

>    dLFP:=vector([diff(LFP[1],t),diff(LFP[2],t),diff(LFP[3],t)]):

>    ddLFP:=vector([diff(dLFP[1],t),diff(dLFP[2],t),diff(dLFP[3],t)]):

>    dddLFP:=vector([diff(ddLFP[1],t),diff(ddLFP[2],t),diff(ddLFP[3],t)]):

>    mat:=matrix(3,3,[dLFP,ddLFP,dddLFP]):

>    det(mat);

0

Daraus folgt, dass die ersten 3 Ableitungsvektoren linear abhängig sind. Deshalb ist die Lotfußpunktkurve eine ebene Kurve.

Schnitt mit einem Drehzylinder, der die z-Achse als Achse besitzt

Im folgenden werden Schnitte des Plückerkonoids mit Drehzylindern  betrachtet, die die z-Achse als Achse  besitzen. Der Radius werde mit R festgelegt.

>    R:=1;

R := 1

>    xzyl:=R*cos(psi);
yzyl:=R*sin(psi);

xzyl := cos(psi)

yzyl := sin(psi)

>    Z2:=simplify(subs(X=xzyl,Y=yzyl,Zs));

Z2 := sin(psi)*cos(psi)+1-cos(psi)^2

>    plot(subs(xm=1,ym=1,Z2),psi=0..2*Pi);

[Maple Plot]

In der Abwicklung erkennt man also, dass der Schnitt eines solchen Drehzylinders mit dem Plücker Konoid eine Sinuskurve im weitesten Sinne

mit 2 Perioden ist.

Plots

Zuerst werden die beiden vorgegebenen Erzeugenden mit der Lotfußpunktskurve geplottet.

>    p:=1;
t:='t';
lambda:='lambda';
phi:=Pi/4;
h:=1;

p := 1

t := 't'

lambda := 'lambda'

phi := 1/4*Pi

h := 1

>    k1:=spacecurve(LFP,t=-1000..1000,numpoints=30000,scaling=constrained,axes=normal,color=red,thickness=2):

>    e1:=spacecurve(vector([t,0,0]),t=0..1.5,color=blue,thickness=2):

>    e2:=spacecurve(P2,t=0..1.5,color=green,thickness=2):

>    display3d(k1,e1,e2);

[Maple Plot]

Jetzt wird das Plücker Konoid mittels seiner Parameterdarstellung geplottet.

Um die Fläche zwischen z-Achse und Lotfußpunktskurve zu erhalten, muss man statt dem Erzeugenden-Vektor EV

den Verbindungsvektor EVV der Kurve mit der z-Achse nehmen. Diese haben zwar die selbe Richtung, unterscheiden sich aber

durch ihre Länge. Läßt man den Parameter auf EVV zwischen 0 und 1 wandern, so erhält man die gewünschte Fläche!

>    EVV:=scalarmul(EV,beta);

EVV := vector([1/2*t^2/(t^2-t*2^(1/2)+1), -1/2*t*2^(1/2)/(t^2-t*2^(1/2)+1)*(1/2*t*2^(1/2)-1), 0])

>    PKq:=matadd(vector([0,0,alpha]),scalarmul(EVV,lambda));

PKq := vector([1/2*lambda*t^2/(t^2-t*2^(1/2)+1), -1/2*lambda*t*2^(1/2)/(t^2-t*2^(1/2)+1)*(1/2*t*2^(1/2)-1), -1/(t^2-t*2^(1/2)+1)*(1/2*t*2^(1/2)-1)])

>    RF:=plot3d(PKq,lambda=-1..1,t=-200..200,grid=[20,1000]):

>    display3d(RF,k1,e1,e2);

[Maple Plot]

>