Geometrie: Oberflächenanteil auf einer Halbkugel

Folgendes Problem:

Vereinfachung: Die Erde sei eine ebene Fläche (damit die nachfolgenden Berechnungen annehmen, dass das Volumen darüber eine Halbkugel ist).

Ich stehe auf dieser Halbkugel im Mittelpunkt eines Koordinatensystemes (x/y/z). In einer beliebigen Höhe über mir oder seitlich über mir schwebt eine quadratische Fläche in fixer Größe, deren Seitenlinien parallel zu der x- und y-Achse sind. Das Quadrat schwebt eben in der Luft, die Höhe z ist für alle Punkte des Quadrats gleich.

Ich habe also die Koordinaten des Flächenmittelpunktes (x1/y1/z1) und kann durch die bekannte Quadratseitenlinie auch ausrechnen, welchen Sichtwinkel mir die Fläche zum Himmel versperrt (Winkel zwischen rechter und linker Aussenkante und Winkel zwischen vorderer und hinterer Aussenkante).

Ich möchte jetzt die prozentuale Fläche berechnen, die das Quadrat vom Himmel (also von der Oberfläche der Halbkugel) verdeckt.
-> abhängig entweder von x1/y1/z1 und Quadratseitenlänge
-> oder von den beiden Sichtwinkeln alpha_x und alpha_y

Die Berechnung darf gerne Näherungsannahmen treffen um zu komplizierte Berechnungen (soll hinterher in Excel) zu vermeiden.

Vielen Dank, würde mich über Unterstützung freuen!

(Schatten-)Projektion von Ebenenstück auf Kugelobe
Ich glaube, die Aufgabe ist kompliziert und dazu noch falsch beschrieben. Die Lösung wäre nämlich 0%.

Wahrscheinlich ist gefragt, wie groß der Schatten (nämlich die Fläche A) ist, der von einer

Lichtquelle (Ort L = (x_l, y_l, z_l))

von einem

Ebenenstück (Ort Mittelpunkt des Flächenstücks M = (x_m, y_m, z_m) und Fläche A_0)

auf die

Kugeloberfläche x^2 + y^2 + z^2 = R^2

projiziert wird.

Der prozentuale Anteil ist dann A/(4*pi*R^2).

Dass die Normale des Flächenstücks parallel zur z-Achse sein soll, ist eine unnötige ‚Vereinfachung‘, da man das Ganze im so um den Kugeloberflächenmittelpunkt drehen könnte, dass dies erfüllt wäre.

Mit der Vereinfachung R >> Betrag(L), Betrag(M) kann man dies einfach lösen.

Falls das nicht erfüllt ist, würde ich die Aufgabe neu formulieren und statt der Hemisphäre des Weltalls z.B. eine Glaskugel eines Wahrsagers zur Illustration verwenden.

Die Lösung ist wie folgt:

L und M sind Vektoren. Die Gerade durch L und M ist

G(t) = M + t(L-M) mit t von minus bis plus unendlich.

Mit G^2 = R^2 erhält man t_0 (Lösung einer Quadratischen Gleichung in t). t_0 definiert den Projektionspunkt P von M:

P = G(t_0).

Wenn nun

alpha der Winkel zwischen G und der Normalen zum Flächenstück

ist und

beta der Winkel zwischen P und G

ist, dann gilt für A:

A * cos(beta) * (M-L)^2 = A_0 * cos(alpha) * (P-L)^2

[oder so ähnlich - hier verrechnet man sich so leicht…]

Ich würde das ganze einmal 2-D (mit Projektion einer Strecke auf Kreis) üben.

[Bei dieser Antwort wurde das Vollzitat nachträglich automatisiert entfernt]

Hallo Frank, danke zuerst mal für Deine Hilfe. Mein Studium ist doch schon ein paar Jährchen her und ich muss versuchen, Dir zu folgen.

Ich glaube, die Aufgabe ist kompliziert und dazu noch falsch
beschrieben. Die Lösung wäre nämlich 0%.
Wahrscheinlich ist gefragt, wie groß der Schatten (nämlich die
Fläche A) ist, der von einer
Lichtquelle (Ort L = (x_l, y_l, z_l))
von einem Ebenenstück (Ort Mittelpunkt des Flächenstücks M = (x_m, y_m, z_m)
und Fläche A_0) auf die Kugeloberfläche x^2 + y^2 + z^2 = R^2
projiziert wird.

Der prozentuale Anteil ist dann A/(4*pi*R^2).

Nur zum Teil so: Die Lichtquelle darf (soll) in (0,0,0) stehen, um x_l… brauchen wir uns nicht zu kümmern. Ausserdem möchte ich vom Radius einer Kugel unabhängig sein: Sonst könnte das Quadrat ja ausserhalb liegen oder die Kugel schneiden.

Dass die Normale des Flächenstücks parallel zur z-Achse sein
soll, ist eine unnötige ‚Vereinfachung‘, da man das Ganze im
so um den Kugeloberflächenmittelpunkt drehen könnte, dass dies
erfüllt wäre.

Ich glaube, diese Aussage ist nicht richtig, oder? Wenn die Normale des Quadrats parallel zu x ist ist die Fläche = 0%. Aber egal: Ich habe vielevieleviele Quadrate zu rechnen, jedes Mal die Kugel zu drehen macht die Sache vermutlich komplizierter.

Mit der Vereinfachung R >> Betrag(L), Betrag(M) kann man
dies einfach lösen.

Falls das heißt R>>Entfernung des Quadrats dann können wir das annehmen. R darf gegen Unendlich gehen.

Falls das nicht erfüllt ist, würde ich die Aufgabe neu
formulieren und statt der Hemisphäre des Weltalls z.B. eine
Glaskugel eines Wahrsagers zur Illustration verwenden.

… den unteren Teil habe ich nicht verstanden. Vielleicht komme ich der Sache aber näher, wenn Du mir erklärst, was die Vektoren L, G und M hier darstellen.

Die Lösung ist wie folgt:

L und M sind Vektoren. Die Gerade durch L und M ist
G(t) = M + t(L-M) mit t von minus bis plus unendlich.
Mit G^2 = R^2 erhält man t_0 (Lösung einer Quadratischen
Gleichung in t). t_0 definiert den Projektionspunkt P von M:
P = G(t_0).

Wenn nun
alpha der Winkel zwischen G und der Normalen zum Flächenstück
ist und
beta der Winkel zwischen P und G
ist, dann gilt für A:
A * cos(beta) * (M-L)^2 = A_0 * cos(alpha) * (P-L)^2
[oder so ähnlich - hier verrechnet man sich so leicht…]
Ich würde das ganze einmal 2-D (mit Projektion einer Strecke
auf Kreis) üben.

Vielleicht versuche ich, das GESAMTproblem zu schildern… vermutlich macht das auch das Antworten leichter.

Ich habe eine Kiste, sagen wir eine Schuhschachtel und einen Punkt in der Kiste, der durch (x_p, y_p, z_p) definiert wird. Diese drei Variablen möchte ich später in Excel verändern um den Punkt in der Kiste wandern zu lassen um verschiedene Auswirkungen darauf zu untersuchen.
Um das ganze halbwegs handlich zu halten betrachte ich jetzt jede Kistenwand einzeln. Die Kistenwand wird in gleich große Rechtecke oder von mir aus Quadrate unterteilt. Jedes Quadrat bestimmt sich jetzt durch die Koordinaten mit Bezug auf den ominösen Punkt (x_p, y_p, z_p).

Jedes dieser Quadrate deckt für den berühmten Punkt nun ein Stück Himmel ab, und ich benötige diesen prozentualen Wert jeder Abdeckung, da ich diesen Anteil weiterverarbeiten muss. Und am Ende, klar sollte in Näherung die Abdeckung von 100% von allen sechs Kistenwänden herauskommen.

Bitte den Bezug von meinem Pünktchen zur Kiste nicht berücksichtigen: Der Teil ist schon klar. Sobald ich jetzt auch noch die prozentuale Abdeckung EINES Quadrates berechnen kann macht Excel und copypaste mir den Rest :smile:

Danke im voraus!!

Hallo Frank, danke zuerst mal für Deine Hilfe. Mein Studium
ist doch schon ein paar Jährchen her und ich muss versuchen,
Dir zu folgen.

Ich glaube, die Aufgabe ist kompliziert und dazu noch falsch
beschrieben. Die Lösung wäre nämlich 0%.
Wahrscheinlich ist gefragt, wie groß der Schatten (nämlich die
Fläche A) ist, der von einer
Lichtquelle (Ort L = (x_l, y_l, z_l))
von einem Ebenenstück (Ort Mittelpunkt des Flächenstücks M = (x_m, y_m, z_m)
und Fläche A_0) auf die Kugeloberfläche x^2 + y^2 + z^2 = R^2
projiziert wird.

Der prozentuale Anteil ist dann A/(4*pi*R^2).

Nur zum Teil so: Die Lichtquelle darf (soll) in (0,0,0)
stehen, um x_l… brauchen wir uns nicht zu kümmern.

Tatsächlich is L auch dann 0, wenn es nicht wäre, da wegen R >> Betrag(L) gilt

Betrag(P-L) = Betrag§ = R

und

beta (der Winkel zwischen P und G) wird 0, cos(beta)=1

Das Ergebnis wird dadurch noch einfacher:

A = A_0 * cos(alpha) * R^2 / M^2

Erklärung:

Man schaut vom Mittelpunkt einer Kugel auf ein Flächenstück bei Abstand M mit Flächeninhalt A_0. Bildet die Normale der Fläche mit der Blickrichtung einen Winkel von alpha, ist die sichtbare Fläche A_0 * cos(alpha).

[Stehen Flächennormale und Blickrichtung senkrecht aufeinander, wäre die sichtbare Fläche gleich Null, da eine Fläche keine Dicke hat.]

Der prozentuale Anteil der sichtbaren im Bezug auf eine Kugeloberfläche mit Radius M

A_0 * cos(alpha) / 4 * Pi * M^2

Dies ist der Raumwinkel unter der die Fläche zu sehen ist.

Projiziert man dies nun alles auf eine Größere Kugeloberfläche mit Radius R >> M, dan ist die im Firnament projizierte Fläche

A = (A_0 * cos(alpha) / 4 * Pi * M^2) * R^2

Zugegeben, ein wenig Intuition und Kopfrechnen ist dabei, denke aber doch, dass dies stimmt.

WICHTIG: Im übrigen wurde hier nicht auf die Kugeloberfläche sondern nur auf die Tangentialfläche an der Kugeloberfläche projiziert. Das gilt nur, wenn A_0 * cos(alpha) > Betrag(L), Betrag(M) kann man

dies einfach lösen.

Falls das heißt R>>Entfernung des Quadrats dann können
wir das annehmen. R darf gegen Unendlich gehen.

Falls das nicht erfüllt ist, würde ich die Aufgabe neu
formulieren und statt der Hemisphäre des Weltalls z.B. eine
Glaskugel eines Wahrsagers zur Illustration verwenden.

… den unteren Teil habe ich nicht verstanden. Vielleicht
komme ich der Sache aber näher, wenn Du mir erklärst, was die
Vektoren L, G und M hier darstellen.

Die Lösung ist wie folgt:

L und M sind Vektoren. Die Gerade durch L und M ist
G(t) = M + t(L-M) mit t von minus bis plus unendlich.
Mit G^2 = R^2 erhält man t_0 (Lösung einer Quadratischen
Gleichung in t). t_0 definiert den Projektionspunkt P von M:
P = G(t_0).

Wenn nun
alpha der Winkel zwischen G und der Normalen zum Flächenstück
ist und
beta der Winkel zwischen P und G
ist, dann gilt für A:
A * cos(beta) * (M-L)^2 = A_0 * cos(alpha) * (P-L)^2
[oder so ähnlich - hier verrechnet man sich so leicht…]
Ich würde das ganze einmal 2-D (mit Projektion einer Strecke
auf Kreis) üben.

Noch ein schneller Tipp, denn ich bin ziemlich unter Zeitdruck geraten und schaue sobald nicht mehr vorbei:

Die Lichtquelle und zwei Eckpunkte (oder die Gerade durch die beiden Eckpunkte) definieren eine Ebene, die die Kugeloberfläche schneidet und einen Kreis beschreibt. Ist die Lampe im Ursprung, ist es sogar ein Großkreis.

Solche Kugelvierecke sind sicherlich in allen Formelsammlungen beschrieben.

Sonst würde ich es einmal bei einer Melone ausprobieren :wink:

[Bei dieser Antwort wurde das Vollzitat nachträglich automatisiert entfernt]

Fläche Dreieck, projiziert auf Kugeloberfläche

Folgendes Problem:

Hier ein neuer Ansatz, der zum Erfolg führt.

Die Vektoren a b c definieren ein Dreieck ABC.
a ist der Vektor vom Ursprung O zum Eckpunkt A, etc.

Die drei Ebenen

x_ab(u,v) = ua + vb

x_bc(u,v) = ub + vc

x_ca(u,v) = uc + va

u,v Skalare aus [-unendlich … +unendlich]

schneiden die (Einheits-)Kugel.
Es sind Großkreise auf der Kugeloberfläche, da die Ebenen durch den Ursprung gehen.

Diese drei Großkreise definieren ein sphärisches Dreieck mit den Eckpunkten (Vektoren)

A’, B’, C’

a’ = a/Betrag(a)
b’ = b/Betrag(b)
c’ = c/Betrag©

Die Fläche die des spärischen Dreiecks ist die Fläche des Schattens, den eine Lichtquelle in O projizieren würde.

Um diese Fläche F zu berechnen, muss man die Winkel alpha, beta, gamma in A’, B’ und C’ zwischen den jeweiligen Großkreisen berechnen:

F = alpha + beta + gamma - pi.

[alpha, beta, gamma aus 0 … 2*pi, gewöhnliche Winkel.]

(Fläche eines Eulerschen Sphärischen Dreiecks. Findet man in jedem besseren Mathematiklexikon. Die Herleitung dafür ist nicht weiter schwer.)

Der Winkel alpha wird wie folgt berechnet:

Man berechnet den Winkel zwischen einem Vektor b_ab, der in der Ebene x_ab(u,v) liegt (coplanar) und senkrecht auf a stehet, und dem Vektor c_ac, der entsprechend definiert ist.

Ohne Zeichnung muss man dies halt als Rezept nehmen.

Dennoch zur Verdeutlichung: b_ab und c_ac definieren die Richtungen der beiden Tangenten der beiden Großkreise im Punkt A, in dem sich die beiden Großkreise schneiden.

Man kann auch die Tangenten angeben

g_ab(u) = a’ + ub_ab
g_ac(u) = a’ + uc_ac

-unendlich

Wow! Danke für die ausführliche (und anschauliche) Herleitung und für den Lösungsweg… Ich verstehe jetzt die Konstruktion der Lösung, obwohl das Umsetzen in Formeln für Excel noch lange nicht problemlos ablaufen wird :frowning:

Numerisch habe also meine Punkte (da meine Fläche ja immer parallel zur x/y-Fläche des Koordinatensystems liegt ändert sich z nicht) und die Quadratseitenlänge konstant k=10 hat.

a’ = (x, y, z)

b’ = (x+10, y, z)

c’ = (x+10, y+10, z)

d’ = (x, y+10, z)

Die Eckpunkte A’, B’… zu bilden ist klar.

Was mir jetzt aber (schon) Probleme macht, ist die folgende Konstruktion mit den Kreistangenten in eine Excel-Formel zu packen:

cos(alpha) = b_ab*c_ac/Betrag(b_ab)/Betrag(c_ac).

… was ja dann von der Komplettlösung nur noch Millimeter entfernt wäre…

Wow! Danke für die ausführliche (und anschauliche) Herleitung
und für den Lösungsweg… Ich verstehe jetzt die Konstruktion
der Lösung, obwohl das Umsetzen in Formeln für Excel noch
lange nicht problemlos ablaufen wird :frowning:

Numerisch habe also meine Punkte (da meine Fläche ja immer
parallel zur x/y-Fläche des Koordinatensystems liegt ändert
sich z nicht) und die Quadratseitenlänge konstant k=10 hat.

a’ = (x, y, z)

b’ = (x+10, y, z)

c’ = (x+10, y+10, z)

d’ = (x, y+10, z)

Die Eckpunkte A’, B’… zu bilden ist klar.

Der „’“ ist ja eigentlich für den Punkt (Großbuchstabe) bzw. den Vektor (Kleinbuchstabe) auf der (Einheits-)Kugeloberfläche gedacht.

Also, wenn

A ein Eckpunkt mit Vektor a = (x, y, z) ist, dann ist der Punkt auf der Oberfläche

A’ mit a’ = (x’, y’, z’)

und

x’ = x/Sqrt(x^2+y^2+z^2)
y’ = y/Sqrt(x^2+y^2+z^2)
z’ = z/Sqrt(x^2+y^2+z^2)

B ist b = (r, s, t)

mit

r = x + 10
s = y
t = z

und

B’ ist verbunden mit b’ = (r’, s’, t’)

mit

r’ = r/Sqrt(r^2 + s^2 + t^2)
etc.

Analoges gilt für

C, c= (u, v, w), und D, d = (h, k, l).

Was mir jetzt aber (schon) Probleme macht, ist die folgende
Konstruktion mit den Kreistangenten in eine Excel-Formel zu
packen:

cos(alpha) = b_ab*c_ac/Betrag(b_ab)/Betrag(c_ac).

… was ja dann von der Komplettlösung nur noch Millimeter
entfernt wäre…

[A]

Wir bilden jetzt einen Vektor, der in der Ebene aufgespannt von a’ und b’ (selbe Ebene wie von a und b natürlich) liegt und senkrecht auf a’ steht. Dazu ziehen wir von b’ einfach den Teil ab, der parallel zu a’ ist. Also

b’ - a’ (a’*b’)/Sqrt(a’*a’)

mit

Sqrt(a’*a’) = 1
(a’*b’) = x’r’+y’s’+z’t’

haben wir also den Vektor

(r’ - (x’r’+y’s’+z’t’)x’, s’ - (x’r’+y’s’+z’t’)y’, t’ - (x’r’+y’s’+z’t’)z’)

Nennen wir ihn

aB = (aB_x, aB_y, aB_z)

mit aB_x = r’ - (x’r’+y’s’+z’t’)x’, etc.

Normierung:

aB’ = (aB_x’, aB_y’, aB_z’)

mit aB_x’ = aB_x/Sqrt(aB_x^2+aB_y^2+aB_z^2), etc.

[B]

Der Vektor in der Ebene a’ c’ und senkrecht zu a’

aB -> aC
b -> c
r,s,t -> u,v,w

Also:

aC’ = (aC_x’, aC_y’, aC_z’)

mit

mit

aC_x’ = aC_x/Sqrt(aC_x^2+aC_y^2+aC_z^2), etc.

mit

mit aC_x = u’ - (x’u’+y’v’+z’w’)x’, etc.

[C]

Da aB’ und aC’ den Betrag eins haben, ist

Zahl_a = cos(alpha) = aB*aC
= aB_x’.aC_x’ + aB_y’.aC_y’ + aB_z’.aC_z’

[Punkt für skalare Multiplikation wurde eingeführt!]

Dies ist eine Zahl zwischen -1 und +1, nennen wir sie Zahl_a.

Dann ist alpha = arccos(Zahl_a).

Beim Berechnen des arccos muss man ein wenig aufpassen. Der Taschenrechner meines Sohnes ergab einen Fehler bei arccos(-0,5), obwohl meines Erachtens 2 pi /3 hätte herauskommen sollen. Aber

arccos(-x) = pi - arccos(x)

[Bitte in Formelsammlung nachschlagen, da ich dies so aus dem Kopf schreibe. Aus dem selben Grunde kann das oben alles grotte falsch sein. Aber im Prinzip stimmt es.]

Zusammenfassung (per copy & paste):

alpha
= arccos(Zahl_a) für Zahl_a >= 0
alpha
= pi - arccos(Zahl_a) für Zahl_a

Wow!

Falsch:

u’ = u/skalprod(u, v, w, u, v, w)

Richtig:

u’ = u/Sqrt(skalprod(u, v, w, u, v, w))

… Umsetzung in einem Macro versucht, funktioniert aber noch nicht :frowning:. Habe ich da Probleme mit einer Vektorberechnung oder mit Fallunterscheidung in der Cosinusberechnung?!? (you’ve got mail :wink:

###########################
Public Function flaeche(x, y, z, delta_x, delta_y) As Double

’ x, y, z: Vector to left upper corner of shielding segment
’ delta_x: Segment size in mm, x-direction
’ delta_y: segment size in mm, y-direction
’ delta_z not necessary, is always zero

Dim x_strich, y_strich, z_strich As Double ’ standardized vector (A’) to 6-pi sphere
Dim r_strich, s_strich, t_strich As Double ’ standardized vector (B’ == next cornerstone)
Dim u_strich, v_strich, w_strich As Double ’ standardized vector (C’ == next cornerstone)
Dim h_strich, k_strich, l_strich As Double ’ standardized vector (D’ == next cornerstone)
Dim betrag As Double
’ tangents:
Dim aB_x, aB_y, aB_z As Double ’ vector in the a’b’ plane, perpendicular to a’
Dim aB_x_strich, aB_y_strich, aB_z_strich As Double ’ aB = (aB_x, aB_y, aB_z) plus standardized vector
Dim bA_x, bA_y, bA_z As Double
Dim bA_x_strich, bA_y_strich, bA_z_strich As Double
Dim aC_x, aC_y, aC_z As Double ’ vector in the a’c’ plane, perpendicular to a’
Dim aC_x_strich, aC_y_strich, aC_z_strich As Double ’ aC = (aC_x, aC_y, aC_z) plus standardized vector
Dim cA_x, cA_y, cA_z As Double
Dim cA_x_strich, cA_y_strich, cA_z_strich As Double
Dim bD_x, bD_y, bD_z As Double
Dim bD_x_strich, bD_y_strich, bD_z_strich As Double
Dim dB_x, dB_y, dB_z As Double
Dim dB_x_strich, dB_y_strich, dB_z_strich As Double
Dim cD_x, cD_y, cD_z As Double
Dim cD_x_strich, cD_y_strich, cD_z_strich As Double
Dim dC_x, dC_y, dC_z As Double
Dim dC_x_strich, dC_y_strich, dC_z_strich As Double

Dim alpha, beta, gamma, delta As Double ’ angular results
Dim cosinusvalue As Double
Dim vectorproduct As Double

’ calculation of standardized vector, left upper corner (A’)
betrag = ((x ^ 2) + (y ^ 2) + (z ^ 2)) ^ 0.5
x_strich = x / betrag
y_strich = y / betrag
z_strich = z / betrag
’ calculation of standardized vector, right upper corner (B’)
betrag = (((x + delta_x) ^ 2) + (y ^ 2) + (z ^ 2)) ^ 0.5
r_strich = (x + delta_x) / betrag
s_strich = y / betrag
t_strich = z / betrag
’ calculation of standardized vector, left lower corner (C’)
betrag = ((x ^ 2) + ((y - delta_y) ^ 2) + (z ^ 2)) ^ 0.5
u_strich = x / betrag
v_strich = (y - delta_y) / betrag
w_strich = z / betrag
’ calculation of standardized vector, right lower corner (D’)
betrag = (((x + delta_x) ^ 2) + ((y - delta_y) ^ 2) + (z ^ 2)) ^ 0.5
h_strich = (x + delta_x) / betrag
k_strich = (y - delta_y) / betrag
l_strich = z / betrag

'########################## calculate tangents
'a_strich * b_strich
vectorproduct = ((x_strich * r_strich) + (y_strich * s_strich) + (z_strich * t_strich))
aB_x = (r_strich - (x_strich * vectorproduct))
bA_x = (x_strich - (r_strich * vectorproduct))
aB_y = (s_strich - (y_strich * vectorproduct))
bA_y = (y_strich - (s_strich * vectorproduct))
aB_z = (t_strich - (z_strich * vectorproduct))
bA_z = (z_strich - (t_strich * vectorproduct))
betrag = ((aB_x ^ 2) + (aB_y ^ 2) + (aB_z ^ 2)) ^ 0.5 ’ and standardization
aB_x_strich = aB_x / betrag
aB_y_strich = aB_y / betrag
aB_z_strich = aB_z / betrag
betrag = ((bA_x ^ 2) + (bA_y ^ 2) + (bA_z ^ 2)) ^ 0.5 ’ and standardization
bA_x_strich = bA_x / betrag
bA_y_strich = bA_y / betrag
bA_z_strich = bA_z / betrag
'a_strich * c_strich
vectorproduct = ((x_strich * r_strich) + (y_strich * s_strich) + (z_strich * t_strich))
aC_x = (u_strich - (x_strich * vectorproduct))
cA_x = (x_strich - (u_strich * vectorproduct))
aC_y = (v_strich - (y_strich * vectorproduct))
cA_y = (y_strich - (v_strich * vectorproduct))
aC_z = (w_strich - (z_strich * vectorproduct))
cA_z = (z_strich - (w_strich * vectorproduct))
betrag = ((aC_x ^ 2) + (aC_y ^ 2) + (aC_z ^ 2)) ^ 0.5 ’ and standardization
aC_x_strich = aC_x / betrag
aC_y_strich = aC_y / betrag
aC_z_strich = aC_z / betrag
betrag = ((cA_x ^ 2) + (cA_y ^ 2) + (cA_z ^ 2)) ^ 0.5 ’ and standardization
cA_x_strich = cA_x / betrag
cA_y_strich = cA_y / betrag
cA_z_strich = cA_z / betrag
'b_strich * d_strich
vectorproduct = ((r_strich * h_strich) + (s_strich * k_strich) + (t_strich * l_strich))
bD_x = (h_strich - (r_strich * vectorproduct))
dB_x = (r_strich - (h_strich * vectorproduct))
bD_y = (k_strich - (s_strich * vectorproduct))
dB_y = (s_strich - (k_strich * vectorproduct))
bD_z = (l_strich - (t_strich * vectorproduct))
dB_z = (t_strich - (l_strich * vectorproduct))
betrag = ((bD_x ^ 2) + (bD_y ^ 2) + (bD_z ^ 2)) ^ 0.5 ’ and standardization
bD_x_strich = bD_x / betrag
bD_y_strich = bD_y / betrag
bD_z_strich = bD_z / betrag
betrag = ((dB_x ^ 2) + (dB_y ^ 2) + (dB_z ^ 2)) ^ 0.5 ’ and standardization
dB_x_strich = dB_x / betrag
dB_y_strich = dB_y / betrag
dB_z_strich = dB_z / betrag
'c_strich * d_strich
vectorproduct = ((u_strich * h_strich) + (v_strich * k_strich) + (w_strich * l_strich))
cD_x = (h_strich - (u_strich * vectorproduct))
dC_x = (u_strich - (h_strich * vectorproduct))
cD_y = (k_strich - (v_strich * vectorproduct))
dC_y = (v_strich - (k_strich * vectorproduct))
cD_z = (l_strich - (w_strich * vectorproduct))
dC_z = (w_strich - (l_strich * vectorproduct))
betrag = ((cD_x ^ 2) + (cD_y ^ 2) + (cD_z ^ 2)) ^ 0.5 ’ and standardization
cD_x_strich = cD_x / betrag
cD_y_strich = cD_y / betrag
cD_z_strich = cD_z / betrag
betrag = ((dC_x ^ 2) + (dC_y ^ 2) + (dC_z ^ 2)) ^ 0.5 ’ and standardization
dC_x_strich = dC_x / betrag
dC_y_strich = dC_y / betrag
dC_z_strich = dC_z / betrag

'########################## and finally angles
cosinusvalue = ((aB_x_strich * aC_x_strich) + _
(aB_y_strich * aC_y_strich) + _
(aB_z_strich * aC_z_strich))
alpha = Atn(-cosinusvalue / Sqr(-cosinusvalue * cosinusvalue + 1)) + 2 * Atn(1) ’ replacement for missing arccos
cosinusvalue = ((bA_x_strich * bD_x_strich) + _
(bA_y_strich * bD_y_strich) + _
(bA_z_strich * bD_z_strich))
beta = Atn(-cosinusvalue / Sqr(-cosinusvalue * cosinusvalue + 1)) + 2 * Atn(1) ’ replacement for missing arccos
cosinusvalue = ((cA_x_strich * cD_x_strich) + _
(cA_y_strich * cD_y_strich) + _
(cA_z_strich * cD_z_strich))
gamma = Atn(-cosinusvalue / Sqr(-cosinusvalue * cosinusvalue + 1)) + 2 * Atn(1) ’ replacement for missing arccos
cosinusvalue = ((dC_x_strich * dB_x_strich) + _
(dC_y_strich * dB_y_strich) + _
(dC_z_strich * dB_z_strich))
delta = Atn(-cosinusvalue / Sqr(-cosinusvalue * cosinusvalue + 1)) + 2 * Atn(1) ’ replacement for missing arccos

flaeche = (alpha + beta + gamma + delta - (2 * 3.14159265358979)) / (4 * 3.14159265358979)

End Function
###################

[Bei dieser Antwort wurde das Vollzitat nachträglich automatisiert entfernt]

Wow!

Gelöst (glaube ich): Fehler in einer vektorberechnung.
Richtiges Makro hängt an…

##############################################
Public Function flaeche(x, y, z, delta_x, delta_y) As Double

’ x, y, z: Vector to left upper corner of shielding segment
’ delta_x: Segment size in mm, x-direction
’ delta_y: segment size in mm, y-direction
’ delta_z not necessary, is always zero

Dim x_strich, y_strich, z_strich As Double ’ standardized vector (A’) to 6-pi sphere
Dim r_strich, s_strich, t_strich As Double ’ standardized vector (B’ == next cornerstone)
Dim u_strich, v_strich, w_strich As Double ’ standardized vector (C’ == next cornerstone)
Dim h_strich, k_strich, l_strich As Double ’ standardized vector (D’ == next cornerstone)
Dim betrag As Double
’ tangents:
Dim aB_x, aB_y, aB_z As Double ’ vector in the a’b’ plane, perpendicular to a’
Dim aB_x_strich, aB_y_strich, aB_z_strich As Double ’ aB = (aB_x, aB_y, aB_z) plus standardized vector
Dim bA_x, bA_y, bA_z As Double
Dim bA_x_strich, bA_y_strich, bA_z_strich As Double
Dim aC_x, aC_y, aC_z As Double ’ vector in the a’c’ plane, perpendicular to a’
Dim aC_x_strich, aC_y_strich, aC_z_strich As Double ’ aC = (aC_x, aC_y, aC_z) plus standardized vector
Dim cA_x, cA_y, cA_z As Double
Dim cA_x_strich, cA_y_strich, cA_z_strich As Double
Dim bD_x, bD_y, bD_z As Double
Dim bD_x_strich, bD_y_strich, bD_z_strich As Double
Dim dB_x, dB_y, dB_z As Double
Dim dB_x_strich, dB_y_strich, dB_z_strich As Double
Dim cD_x, cD_y, cD_z As Double
Dim cD_x_strich, cD_y_strich, cD_z_strich As Double
Dim dC_x, dC_y, dC_z As Double
Dim dC_x_strich, dC_y_strich, dC_z_strich As Double

Dim alpha, beta, gamma, delta As Double ’ angular results
Dim cosinusvalue As Double
Dim vectorproduct As Double

’ calculation of standardized vector, left upper corner (A’)
betrag = ((x ^ 2) + (y ^ 2) + (z ^ 2)) ^ 0.5
x_strich = x / betrag
y_strich = y / betrag
z_strich = z / betrag
’ calculation of standardized vector, right upper corner (B’)
betrag = (((x + delta_x) ^ 2) + (y ^ 2) + (z ^ 2)) ^ 0.5
r_strich = (x + delta_x) / betrag
s_strich = y / betrag
t_strich = z / betrag
’ calculation of standardized vector, left lower corner (C’)
betrag = ((x ^ 2) + ((y - delta_y) ^ 2) + (z ^ 2)) ^ 0.5
u_strich = x / betrag
v_strich = (y - delta_y) / betrag
w_strich = z / betrag
’ calculation of standardized vector, right lower corner (D’)
betrag = (((x + delta_x) ^ 2) + ((y - delta_y) ^ 2) + (z ^ 2)) ^ 0.5
h_strich = (x + delta_x) / betrag
k_strich = (y - delta_y) / betrag
l_strich = z / betrag

'########################## calculate tangents
'a_strich * b_strich
vectorproduct = ((x_strich * r_strich) + (y_strich * s_strich) + (z_strich * t_strich))
aB_x = (r_strich - (x_strich * vectorproduct))
bA_x = (x_strich - (r_strich * vectorproduct))
aB_y = (s_strich - (y_strich * vectorproduct))
bA_y = (y_strich - (s_strich * vectorproduct))
aB_z = (t_strich - (z_strich * vectorproduct))
bA_z = (z_strich - (t_strich * vectorproduct))
betrag = ((aB_x ^ 2) + (aB_y ^ 2) + (aB_z ^ 2)) ^ 0.5 ’ and standardization
aB_x_strich = aB_x / betrag
aB_y_strich = aB_y / betrag
aB_z_strich = aB_z / betrag
betrag = ((bA_x ^ 2) + (bA_y ^ 2) + (bA_z ^ 2)) ^ 0.5 ’ and standardization
bA_x_strich = bA_x / betrag
bA_y_strich = bA_y / betrag
bA_z_strich = bA_z / betrag
'a_strich * c_strich
vectorproduct = ((x_strich * u_strich) + (y_strich * v_strich) + (z_strich * w_strich))
aC_x = (u_strich - (x_strich * vectorproduct))
cA_x = (x_strich - (u_strich * vectorproduct))
aC_y = (v_strich - (y_strich * vectorproduct))
cA_y = (y_strich - (v_strich * vectorproduct))
aC_z = (w_strich - (z_strich * vectorproduct))
cA_z = (z_strich - (w_strich * vectorproduct))
betrag = ((aC_x ^ 2) + (aC_y ^ 2) + (aC_z ^ 2)) ^ 0.5 ’ and standardization
aC_x_strich = aC_x / betrag
aC_y_strich = aC_y / betrag
aC_z_strich = aC_z / betrag
betrag = ((cA_x ^ 2) + (cA_y ^ 2) + (cA_z ^ 2)) ^ 0.5 ’ and standardization
cA_x_strich = cA_x / betrag
cA_y_strich = cA_y / betrag
cA_z_strich = cA_z / betrag
'b_strich * d_strich
vectorproduct = ((r_strich * h_strich) + (s_strich * k_strich) + (t_strich * l_strich))
bD_x = (h_strich - (r_strich * vectorproduct))
dB_x = (r_strich - (h_strich * vectorproduct))
bD_y = (k_strich - (s_strich * vectorproduct))
dB_y = (s_strich - (k_strich * vectorproduct))
bD_z = (l_strich - (t_strich * vectorproduct))
dB_z = (t_strich - (l_strich * vectorproduct))
betrag = ((bD_x ^ 2) + (bD_y ^ 2) + (bD_z ^ 2)) ^ 0.5 ’ and standardization
bD_x_strich = bD_x / betrag
bD_y_strich = bD_y / betrag
bD_z_strich = bD_z / betrag
betrag = ((dB_x ^ 2) + (dB_y ^ 2) + (dB_z ^ 2)) ^ 0.5 ’ and standardization
dB_x_strich = dB_x / betrag
dB_y_strich = dB_y / betrag
dB_z_strich = dB_z / betrag
'c_strich * d_strich
vectorproduct = ((u_strich * h_strich) + (v_strich * k_strich) + (w_strich * l_strich))
cD_x = (h_strich - (u_strich * vectorproduct))
dC_x = (u_strich - (h_strich * vectorproduct))
cD_y = (k_strich - (v_strich * vectorproduct))
dC_y = (v_strich - (k_strich * vectorproduct))
cD_z = (l_strich - (w_strich * vectorproduct))
dC_z = (w_strich - (l_strich * vectorproduct))
betrag = ((cD_x ^ 2) + (cD_y ^ 2) + (cD_z ^ 2)) ^ 0.5 ’ and standardization
cD_x_strich = cD_x / betrag
cD_y_strich = cD_y / betrag
cD_z_strich = cD_z / betrag
betrag = ((dC_x ^ 2) + (dC_y ^ 2) + (dC_z ^ 2)) ^ 0.5 ’ and standardization
dC_x_strich = dC_x / betrag
dC_y_strich = dC_y / betrag
dC_z_strich = dC_z / betrag

'########################## and finally angles
cosinusvalue = ((aB_x_strich * aC_x_strich) + _
(aB_y_strich * aC_y_strich) + _
(aB_z_strich * aC_z_strich))
alpha = Atn(-cosinusvalue / Sqr(-cosinusvalue * cosinusvalue + 1)) + 2 * Atn(1) ’ replacement for missing arccos
cosinusvalue = ((bA_x_strich * bD_x_strich) + _
(bA_y_strich * bD_y_strich) + _
(bA_z_strich * bD_z_strich))
beta = Atn(-cosinusvalue / Sqr(-cosinusvalue * cosinusvalue + 1)) + 2 * Atn(1) ’ replacement for missing arccos
cosinusvalue = ((cA_x_strich * cD_x_strich) + _
(cA_y_strich * cD_y_strich) + _
(cA_z_strich * cD_z_strich))
gamma = Atn(-cosinusvalue / Sqr(-cosinusvalue * cosinusvalue + 1)) + 2 * Atn(1) ’ replacement for missing arccos
cosinusvalue = ((dC_x_strich * dB_x_strich) + _
(dC_y_strich * dB_y_strich) + _
(dC_z_strich * dB_z_strich))
delta = Atn(-cosinusvalue / Sqr(-cosinusvalue * cosinusvalue + 1)) + 2 * Atn(1) ’ replacement for missing arccos

flaeche = (alpha + beta + gamma + delta - (2 * 3.14159265358979)) / (4 * 3.14159265358979)

End Function

Public Function Travelpath(x, y, z, wall_thickness, delta_x, delta_y) As Double
'### calculation of the travel path through an area of delta_x/delta_y
’ Assumption: x, y, z define the vector to the left upper corner of the area
Dim betrag As Double

’ calculation of vector to area-middle:
x = x + (delta_x / 2)
y = y - (delta_y / 2)
’ z is constant
betrag = ((x ^ 2) + (y ^ 2) + (z ^ 2)) ^ 0.5

Travelpath = betrag * wall_thickness / z

End Function
#######################################

Wow!

Gelöst (glaube ich): Fehler in einer vektorberechnung.
Richtiges Makro hängt an…

Gratulation. Weitere analytischen Argumente wären mir nämlich schwergefallen.