EllipsoidDistance Class Reference

#include <lptellipsoiddistance.h>

Public Member Functions
	EllipsoidDistance (MFloat di[3], MFloat l1i[3], MFloat m1i[3], MFloat n1i[3], MFloat l2i[3], MFloat m2i[3], MFloat n2i[3], MFloat a1, MFloat b1, MFloat c1, MFloat a2, MFloat b2, MFloat c2)
void	crossP (MFloat *x, MFloat *y, MFloat *z)
void	norm (MFloat *vec, MFloat *nvec)
MFloat	mag (MFloat *V)
MFloat	dotP (MFloat *Vec1, MFloat *Vec2)
MFloat	plane_int (MFloat)
MFloat	distance2d (MFloat, MFloat, MFloat, MFloat, MFloat, MFloat)
std::complex< MFloat >	c_cbrt (std::complex< MFloat >)
MFloat	ellipsoids (void)

Public Attributes
MFloat	l1i [3]
MFloat	l2i [3]
MFloat	m1i [3]
MFloat	m2i [3]
MFloat	n1i [3]
MFloat	n2i [3]
MFloat	di [3]
MFloat	a1
MFloat	a2
MFloat	b1
MFloat	b2
MFloat	c1
MFloat	c2
MFloat	d [3]
MFloat	p0 [3]
MFloat	p [3]
MFloat	s [3]
MFloat	l1 [3]
MFloat	l2 [3]
MFloat	m1 [3]
MFloat	m2 [3]
MFloat	n1 [3]
MFloat	n2 [3]
MFloat	dxp0 [3]
MFloat	pi
MFloat	gratio
MFloat	o1g
MFloat	tolerance
MFloat	delt

Friends
template<MInt nDim>
class	LPT

Detailed Description

Definition at line 13 of file lptellipsoiddistance.h.

Constructor & Destructor Documentation

EllipsoidDistance()

EllipsoidDistance::EllipsoidDistance	(	MFloat	di[3],
		MFloat	l1i[3],
		MFloat	m1i[3],
		MFloat	n1i[3],
		MFloat	l2i[3],
		MFloat	m2i[3],
		MFloat	n2i[3],
		MFloat	a1,
		MFloat	b1,
		MFloat	c1,
		MFloat	a2,
		MFloat	b2,
		MFloat	c2
	)

Definition at line 17 of file lptellipsoiddistance.cpp.

                                                                                                                     {
  TRACE();
 
  for(MInt i = 0; i < 3; i++) {
    di[i] = v1[i];
    l1i[i] = v2[i];
    m1i[i] = v3[i];
    n1i[i] = v4[i];
    l2i[i] = v5[i];
    m2i[i] = v6[i];
    n2i[i] = v7[i];
  }
  a1 = s1;
  b1 = s2;
  c1 = s3;
  a2 = s4;
  b2 = s5;
  c2 = s6;
 
  pi = 4.0 * atan(1.0);
  gratio = (1.0 + sqrt(5.0)) * 0.5;
  o1g = 1.0 / (1.0 + gratio);
  tolerance = 1.0E-3;
  delt = 1.0E-5;
}

Member Function Documentation

c_cbrt()

complex< MFloat > EllipsoidDistance::c_cbrt

(

std::complex< MFloat >

x

)

Definition at line 297 of file lptellipsoiddistance.cpp.

                                                           {
  TRACE();
 
  MFloat a, b, r, phi, rn;
  a = real(x);
  b = imag(x);
  r = sqrt(a * a + b * b);
  phi = atan2(b, a);
  phi /= 3.0;
  rn = cbrt(r);
 
  return complex<MFloat>(rn * cos(phi), rn * sin(phi));
}

crossP()

void EllipsoidDistance::crossP	(	MFloat *	x,
		MFloat *	y,
		MFloat *	z
	)

Definition at line 125 of file lptellipsoiddistance.cpp.

                                                                    {
  TRACE();
 
  z[0] = x[1] * y[2] - x[2] * y[1];
  z[1] = x[2] * y[0] - x[0] * y[2];
  z[2] = x[0] * y[1] - x[1] * y[0];
}

distance2d()

MFloat EllipsoidDistance::distance2d	(	MFloat	a1_input,
		MFloat	b1_input,
		MFloat	a2_input,
		MFloat	b2_input,
		MFloat	angle1,
		MFloat	angle2
	)

Definition at line 209 of file lptellipsoiddistance.cpp.

                                                    {
  TRACE();
 
  MFloat eps1, eps2, k1dotd, k2dotd, k1dotk2, nu, Ap[2][2];
  MFloat lambdaplus, lambdaminus, bp2, ap2, cosphi, tanphi2, delta, dp, qu2;
  MFloat A, B, C, D, E, alpha, beta, gamma, P, Q, A2, B2;
  complex<MFloat> U, y, qu, calpha;
 
  eps1 = sqrt(1.0 - (b1_input * b1_input) / (a1_input * a1_input));
  eps2 = sqrt(1.0 - (b2_input * b2_input) / (a2_input * a2_input));
  k1dotd = cos(angle1);
  k2dotd = cos(angle2);
  k1dotk2 = cos(angle2 - angle1);
  nu = a1_input / b1_input - 1.0;
  Ap[0][0] =
      b1_input * b1_input / (b2_input * b2_input)
      * (1.0 + 0.5 * (1.0 + k1dotk2) * (nu * (2.0 + nu) - eps2 * eps2 * (1.0 + nu * k1dotk2) * (1.0 + nu * k1dotk2)));
  Ap[1][1] =
      b1_input * b1_input / (b2_input * b2_input)
      * (1.0 + 0.5 * (1.0 - k1dotk2) * (nu * (2.0 + nu) - eps2 * eps2 * (1.0 - nu * k1dotk2) * (1.0 - nu * k1dotk2)));
  Ap[0][1] = b1_input * b1_input / (b2_input * b2_input) * 0.5 * sqrt(1.0 - k1dotk2 * k1dotk2)
             * (nu * (2.0 + nu) + eps2 * eps2 * (1.0 - nu * nu * k1dotk2 * k1dotk2));
  lambdaplus =
      0.5 * (Ap[0][0] + Ap[1][1]) + sqrt(0.25 * (Ap[0][0] - Ap[1][1]) * (Ap[0][0] - Ap[1][1]) + Ap[0][1] * Ap[0][1]);
  lambdaminus =
      0.5 * (Ap[0][0] + Ap[1][1]) - sqrt(0.25 * (Ap[0][0] - Ap[1][1]) * (Ap[0][0] - Ap[1][1]) + Ap[0][1] * Ap[0][1]);
  bp2 = 1.0 / sqrt(lambdaplus);
  ap2 = 1.0 / sqrt(lambdaminus);
 
  if(approx(k1dotk2, 1.0, MFloatEps)) {
    if(Ap[0][0] > Ap[1][1])
      cosphi = b1_input * k1dotd / (a1_input * sqrt(1.0 - eps1 * eps1 * k1dotd * k1dotd));
    else
      cosphi = sqrt(1.0 - k1dotd * k1dotd) / sqrt(1.0 - eps1 * eps1 * k1dotd * k1dotd);
  } else {
    cosphi = 1.0
             / sqrt(2.0 * (Ap[0][1] * Ap[0][1] + (lambdaplus - Ap[0][0]) * (lambdaplus - Ap[0][0]))
                    * (1.0 - eps1 * eps1 * k1dotd * k1dotd))
             * (Ap[0][1] / sqrt(1.0 + k1dotk2)
                    * (b1_input / a1_input * k1dotd + k2dotd + (b1_input / a1_input - 1.0) * k1dotd * k1dotk2)
                + (lambdaplus - Ap[0][0]) / sqrt(1.0 - k1dotk2)
                      * (b1_input / a1_input * k1dotd - k2dotd - (b1_input / a1_input - 1.0) * k1dotd * k1dotk2));
  }
 
  delta = ap2 * ap2 / (bp2 * bp2) - 1.0;
  if(approx(delta, 0.0, MFloatEps) || approx(cosphi, 0.0, MFloatEps))
    dp = 1.0 + ap2;
  else {
    tanphi2 = 1.0 / (cosphi * cosphi) - 1.0;
    A = -(1.0 + tanphi2) / (bp2 * bp2);
    B = -2.0 * (1.0 + tanphi2 + delta) / bp2;
    C = -tanphi2 - (1.0 + delta) * (1.0 + delta) + (1.0 + (1.0 + delta) * tanphi2) / (bp2 * bp2);
    D = 2.0 * (1.0 + tanphi2) * (1.0 + delta) / bp2;
    E = (1.0 + tanphi2 + delta) * (1.0 + delta);
    A2 = A * A;
    B2 = B * B;
    alpha = -3.0 * B2 / (8.0 * A2) + C / A;
    beta = B2 * B / (8.0 * A2 * A) - B * C / (2.0 * A2) + D / A;
    gamma = -3.0 * B2 * B2 / (256.0 * A2 * A2) + C * B2 / (16.0 * A2 * A) - B * D / (4.0 * A2) + E / A;
    calpha = complex<MFloat>(alpha, 0.0);
    if(approx(beta, 0.0, MFloatEps)) {
      qu = complex<MFloat>(-B / (4.0 * A), 0.0)
           + sqrt(0.5 * (-calpha + sqrt(complex<MFloat>(alpha * alpha - 4.0 * gamma, 0.0))));
    } else {
      P = -F1B12 * alpha * alpha - gamma;
      Q = -alpha * alpha * alpha / 108.0 + F1B3 * alpha * gamma - 0.125 * beta * beta;
      U = c_cbrt(complex<MFloat>(-Q * 0.5, 0.0) + sqrt(complex<MFloat>(Q * Q * 0.25 + P * P * P / 27.0, 0.0)));
      if(approx(real(U), 0.0, MFloatEps) && approx(imag(U), 0.0, MFloatEps))
        y = -5.0 * F1B6 * calpha - c_cbrt(complex<MFloat>(Q, 0.0));
      else
        y = -5.0 * F1B6 * calpha + U - complex<MFloat>(P, 0.0) / (3.0 * U);
      qu = complex<MFloat>(-B / (4.0 * A), 0.0)
           + 0.5
                 * (sqrt(calpha + 2.0 * y)
                    + sqrt(-(3.0 * calpha + 2.0 * y + 2.0 * complex<MFloat>(beta, 0.0) / sqrt(calpha + 2.0 * y))));
    }
    qu2 = abs(qu * qu);
    dp = sqrt((qu2 - 1.0) / delta * (1.0 + bp2 * (1.0 + delta)) * (1.0 + bp2 * (1.0 + delta)) / qu2
              + (1.0 - (qu2 - 1.0) / delta) * (1.0 + bp2) * (1.0 + bp2) / qu2);
  }
 
 
  return dp * b1_input / sqrt(1.0 - eps1 * eps1 * k1dotd * k1dotd);
}

dotP()

MFloat EllipsoidDistance::dotP	(	MFloat *	Vec1,
		MFloat *	Vec2
	)

Definition at line 157 of file lptellipsoiddistance.cpp.

                                                             {
  return Vec1[0] * Vec2[0] + Vec1[1] * Vec2[1] + Vec1[2] * Vec2[2];
}

ellipsoids()

MFloat EllipsoidDistance::ellipsoids

(

void

)

Definition at line 44 of file lptellipsoiddistance.cpp.

                                         {
  TRACE();
 
  MFloat sol;
  MFloat theta1, theta2, theta3, theta4, f1, f4, f3, f5, f6; // Search algorithm variables
 
  norm(di, d);
  norm(l1i, l1);
  norm(l2i, l2);
  norm(m1i, m1);
  norm(m2i, m2);
  norm(n1i, n1);
  norm(n2i, n2);
 
  crossP(d, l1, dxp0);
  if(mag(dxp0) < 1.E-14) crossP(d, m1, dxp0);
  norm(dxp0, p0);
  crossP(p0, d, dxp0);
 
  theta1 = 0.0;
  theta2 = pi;
  theta3 = theta1 + o1g * (theta2 - theta1);
  theta4 = theta2 - o1g * (theta2 - theta1);
  f1 = plane_int(theta1);
  f3 = plane_int(theta3);
  f4 = plane_int(theta4);
 
  while((theta2 - theta1) > tolerance) {
    if((f1 <= f3 && f3 <= f4) || (f3 <= f1 && f1 <= f4)) // case a
    {
      theta1 = theta3;
      f1 = f3;
      theta3 = theta4;
      f3 = f4;
      theta4 = theta2 - o1g * (theta2 - theta1);
      f4 = plane_int(theta4);
    } else if((f1 <= f4 && f4 <= f3) || (f4 <= f1 && f1 <= f3)) // case b
    {
      theta2 = theta4;
      theta4 = theta3;
      f4 = f3;
      theta3 = theta1 + o1g * (theta2 - theta1);
      f3 = plane_int(theta3);
    } else // case c
    {
      f5 = plane_int(theta1 + delt);
      if(f5 > f1) {
        theta2 = theta3;
        theta3 = theta1 + o1g * (theta2 - theta1);
        theta4 = theta2 - o1g * (theta2 - theta1);
        f3 = plane_int(theta3);
        f4 = plane_int(theta4);
      } else {
        f6 = plane_int(theta1 - delt);
        if(f6 < f1) {
          theta2 = theta3;
          theta3 = theta1 + o1g * (theta2 - theta1);
          theta4 = theta2 - o1g * (theta2 - theta1);
          f3 = plane_int(theta3);
          f4 = plane_int(theta4);
        } else {
          theta1 = theta4;
          f1 = f4;
          theta3 = theta1 + o1g * (theta2 - theta1);
          theta4 = theta2 - o1g * (theta2 - theta1);
          f3 = plane_int(theta3);
          f4 = plane_int(theta4);
        }
      }
    }
  }
  sol = f4;
 
 
  return sol;
}

mag()

MFloat EllipsoidDistance::mag

(

MFloat *

V

)

Definition at line 153 of file lptellipsoiddistance.cpp.

{ return sqrt(V[0] * V[0] + V[1] * V[1] + V[2] * V[2]); }

norm()

void EllipsoidDistance::norm	(	MFloat *	vec,
		MFloat *	nvec
	)

Definition at line 135 of file lptellipsoiddistance.cpp.

                                                          {
  TRACE();
 
  MFloat length;
  length = mag(vec);
  if(approx(length, 0.0, MFloatEps)) {
    nvec[0] = 0.0;
    nvec[1] = 0.0;
    nvec[2] = 0.0;
  } else {
    nvec[0] = vec[0] / length;
    nvec[1] = vec[1] / length;
    nvec[2] = vec[2] / length;
  }
}

plane_int()

MFloat EllipsoidDistance::plane_int

(

MFloat

theta

)

Definition at line 163 of file lptellipsoiddistance.cpp.

                                                {
  TRACE();
 
  MFloat alpha1, beta1, gamma1, v1, u1, alpha2, beta2, gamma2, v2, u2;
  MFloat l1x, l1y, m1x, m1y, n1x, n1y, l2x, l2y, m2x, m2y, n2x, n2y;
  MFloat a2d1, a2d2, b2d1, b2d2, angle1, angle2; // Ellipses variables
  MInt j;
 
  for(j = 0; j < 3; j++)
    p[j] = cos(theta) * p0[j] + sin(theta) * dxp0[j];
  crossP(p, d, s);
  l1x = dotP(l1, d);
  l1y = dotP(l1, s);
  m1x = dotP(m1, d);
  m1y = dotP(m1, s);
  n1x = dotP(n1, d);
  n1y = dotP(n1, s);
  alpha1 = l1x * l1x / (a1 * a1) + m1x * m1x / (b1 * b1) + n1x * n1x / (c1 * c1);
  beta1 = l1y * l1x / (a1 * a1) + m1y * m1x / (b1 * b1) + n1x * n1y / (c1 * c1);
  gamma1 = l1y * l1y / (a1 * a1) + m1y * m1y / (b1 * b1) + n1y * n1y / (c1 * c1);
  v1 = sqrt(4.0 * beta1 * beta1 + (alpha1 - gamma1) * (alpha1 - gamma1));
  angle1 = 0.5 * atan2(-2.0 * beta1, -(alpha1 - gamma1));
  u1 = gamma1 + v1 * sin(angle1) * sin(angle1);
  b2d1 = 1.0 / sqrt(u1);
  a2d1 = 1.0 / sqrt(u1 - v1);
  l2x = dotP(l2, d);
  l2y = dotP(l2, s);
  m2x = dotP(m2, d);
  m2y = dotP(m2, s);
  n2x = dotP(n2, d);
  n2y = dotP(n2, s);
  alpha2 = l2x * l2x / (a2 * a2) + m2x * m2x / (b2 * b2) + n2x * n2x / (c2 * c2);
  beta2 = l2y * l2x / (a2 * a2) + m2y * m2x / (b2 * b2) + n2x * n2y / (c2 * c2);
  gamma2 = l2y * l2y / (a2 * a2) + m2y * m2y / (b2 * b2) + n2y * n2y / (c2 * c2);
  v2 = sqrt(4.0 * beta2 * beta2 + (alpha2 - gamma2) * (alpha2 - gamma2));
  angle2 = 0.5 * atan2(-2.0 * beta2, -(alpha2 - gamma2));
  u2 = gamma2 + v2 * sin(angle2) * sin(angle2);
  b2d2 = 1.0 / sqrt(u2);
  a2d2 = 1.0 / sqrt(u2 - v2);
 
 
  return distance2d(a2d1, b2d1, a2d2, b2d2, angle1, angle2);
}

Friends And Related Function Documentation

LPT

template<MInt nDim>

friend class LPT

friend

Definition at line 15 of file lptellipsoiddistance.h.

Member Data Documentation

a1

MFloat EllipsoidDistance::a1

Definition at line 29 of file lptellipsoiddistance.h.

a2

MFloat EllipsoidDistance::a2

Definition at line 29 of file lptellipsoiddistance.h.

b1

MFloat EllipsoidDistance::b1

Definition at line 29 of file lptellipsoiddistance.h.

b2

MFloat EllipsoidDistance::b2

Definition at line 29 of file lptellipsoiddistance.h.

c1

MFloat EllipsoidDistance::c1

Definition at line 29 of file lptellipsoiddistance.h.

c2

MFloat EllipsoidDistance::c2

Definition at line 29 of file lptellipsoiddistance.h.

d

MFloat EllipsoidDistance::d[3]

Definition at line 30 of file lptellipsoiddistance.h.

delt

MFloat EllipsoidDistance::delt

Definition at line 35 of file lptellipsoiddistance.h.

di

MFloat EllipsoidDistance::di[3]

Definition at line 28 of file lptellipsoiddistance.h.

dxp0

MFloat EllipsoidDistance::dxp0[3]

Definition at line 30 of file lptellipsoiddistance.h.

gratio

MFloat EllipsoidDistance::gratio

Definition at line 32 of file lptellipsoiddistance.h.

l1

MFloat EllipsoidDistance::l1[3]

Definition at line 30 of file lptellipsoiddistance.h.

l1i

MFloat EllipsoidDistance::l1i[3]

Definition at line 28 of file lptellipsoiddistance.h.

l2

MFloat EllipsoidDistance::l2[3]

Definition at line 30 of file lptellipsoiddistance.h.

l2i

MFloat EllipsoidDistance::l2i[3]

Definition at line 28 of file lptellipsoiddistance.h.

m1

MFloat EllipsoidDistance::m1[3]

Definition at line 30 of file lptellipsoiddistance.h.

m1i

MFloat EllipsoidDistance::m1i[3]

Definition at line 28 of file lptellipsoiddistance.h.

m2

MFloat EllipsoidDistance::m2[3]

Definition at line 30 of file lptellipsoiddistance.h.

m2i

MFloat EllipsoidDistance::m2i[3]

Definition at line 28 of file lptellipsoiddistance.h.

n1

MFloat EllipsoidDistance::n1[3]

Definition at line 30 of file lptellipsoiddistance.h.

n1i

MFloat EllipsoidDistance::n1i[3]

Definition at line 28 of file lptellipsoiddistance.h.

n2

MFloat EllipsoidDistance::n2[3]

Definition at line 30 of file lptellipsoiddistance.h.

n2i

MFloat EllipsoidDistance::n2i[3]

Definition at line 28 of file lptellipsoiddistance.h.

o1g

MFloat EllipsoidDistance::o1g

Definition at line 33 of file lptellipsoiddistance.h.

p

MFloat EllipsoidDistance::p[3]

Definition at line 30 of file lptellipsoiddistance.h.

p0

MFloat EllipsoidDistance::p0[3]

Definition at line 30 of file lptellipsoiddistance.h.

pi

MFloat EllipsoidDistance::pi

Definition at line 31 of file lptellipsoiddistance.h.

s

MFloat EllipsoidDistance::s[3]

Definition at line 30 of file lptellipsoiddistance.h.

tolerance

MFloat EllipsoidDistance::tolerance

Definition at line 34 of file lptellipsoiddistance.h.

---

The documentation for this class was generated from the following files:

• /home/gitlab-runner/scratch/builds/oxpnswJ6/1/aia/m-AIA/m-AIA/src/LPT/lptellipsoiddistance.h
• /home/gitlab-runner/scratch/builds/oxpnswJ6/1/aia/m-AIA/m-AIA/src/LPT/lptellipsoiddistance.cpp