Class xlifepp::EllipsoidSidePart#

class EllipsoidSidePart : public xlifepp::Surface#

Inheritance diagram for xlifepp::EllipsoidSidePart:

Collaboration diagram for xlifepp::EllipsoidSidePart:

definition of a part of ellipsoid side in R^3 (surface), defined by an ellipsoid and angles theta, phi related to ellisoid axes: theta = (1-u)theta_min + u theta_max, phi = (1-v)phi_min + v phi_max P(u,v) = P0 + (P1-P0) cos(theta) cos(phi) + (P2-P0) sin(theta) cos(phi) + (P6-P0) sin(phi) no construction via key parameter, no geometric transformation available, no mesh (p_,n_,h_ not managed) not a user geometry for the moment !!!

Public Functions

EllipsoidSidePart(const Geometry &g, real_t tmin, real_t tmax, real_t pmin, real_t pmax, EllipsoidParametrizationType = _thetaphi)#

default constructor

explicit constructor

eplicit constructor

inline virtual ~EllipsoidSidePart()#

destructor

virtual string_t asString() const#

format as string

format as string: “EllipsoidSidePart …)”

Vector<real_t> biSphericalExtension(MeshElement *melt, const Point &pt, Parameters &pars, DiffOpType d) const#

extended bi-spherical parametrization

extended biSpherical parametrization on a transition element see documentation for details

Vector<real_t> biSphericalParametrization(const Point &pt, Parameters &pars, DiffOpType d = _id) const#

bi-spherical parametrization (front)

bi-theta-phi parametrization of EllipsoidSidePart based on two theta-phi maps nu > 0 (default pi/10), -pi <= theta <=pi and -pi/2+nu <= phi <= pi/2-nu

1) map with P6 as north pole P - P0 = (P1-P0) cos(theta) cos(phi) + (P2-P0) sin(theta) cos(phi) + (P6-P0) sin(phi) a1=(P-P0,P6-P0)/(P6-P0,P6-P0), d1=min(|1-a1|,|1+a1|) minimal ‘distance’ to poles

2) map with P1 as north pole P - P0 = (P1-P0) sin(phi) + (P2-P0) sin(theta) cos(phi) + (P6-P0) cos(theta) cos(phi) a2=(P-P0,P1-P0)/(P1-P0,P1-P0), d2=min(|1-a2|,|1+a2|) minimal ‘distance’ to poles

note that |a1|<cos(nu) and |a2|<cos(nu)

map is chosen according the parameter “mapIndex” does not managed theta_min, theta_max, phi_min, phi_max

Vector<real_t> biSphericalParametrizationStandard(const Point &pt, Parameters &pars, DiffOpType d) const#

standard bi-spherical parametrization

Vector<real_t> biStereographicParametrization(const Point &pt, Parameters &pars, DiffOpType d = _id) const#

bi-stereographic parametrization

Bi-stereographic parametrization of sphere S(C,R), u in [0,1], v in [0,1] (t=2pi.v-pi) :

                        4ucos(t)               4usin(t)              4u^2-1

0 <= u <= 0.5 : x = Cx + R —–&#8212; y = Cy + R —–&#8212; z = Cz + R —&#8212; 1+4u^2 1+4u^2 4u^2+1

4(1-u)cos(t) 4(1-u)sin(t) 1-4(1-u)^2 0.5 < u <= 1 : x = Cx + R ———&#8212; y = Cy + R ———&#8212; z = Cz + R ——-&#8212; 1+4(1-u)^2 1+4(1-u)^2 1+4(1-u)^2

u = 0 -> C+(0,0,-R) u = 0.5 -> C+(Rcos(t), Rsin(t),0) u = 1 -> C+(0,0,R) 0<t<1 gives circle parallel to the xy plane 0<u<1 gives meridian parallel to perpendicular plane to xy plane

C0 Parametrization [0,1]x[0,1]->S, but not C1 at u=0.5 !

To deal with any ellipsoid E, use the transformation that maps the unit sphere S(0,1) to E: (x,y,z) -> C + x(P1-C) + y(P2-C) + z(P3-C) (P1,P2,P3 first apogees of E)

inline virtual Geometry *clone() const#

virtual copy constructor for Geometry

inline virtual EllipsoidSidePart *ellipsoidSidePart()#

access to child EllipsoidSidePart object

inline virtual const EllipsoidSidePart *ellipsoidSidePart() const#

access to child EllipsoidSidePart object (const)

Vector<real_t> funParametrization(const Point &pt, Parameters &pars, DiffOpType d = _id) const#

parametrization

EllipsoidSidePart parametrization.

virtual GeometricGeodesic geodesic(const Point &x, const Point &dx, bool wCA = false, bool wT = false)#

build a geometric geodesic starting at (x,dx) x must be located on ellipsoid and dx must in the tangent space (not checked here)

Vector<real_t> invBiSphericalParametrization(const Point &pt, Parameters &pars, DiffOpType d = _id) const#

inv of bi-spherical parametrization

inverse of EllipsoidSidePart biSpherical parametrization (u,v)=invf(p) mapIndex = 1 use first spherical map, compute d1=min(|P-P6|,|P+P6|), mapIndex = 2 use second spherical map, compute d2=min(|P-P1|,|P+P1|), mapIndex = 0 use ‘best’ spherical map, map 1 if d1>=d2, else map 2 di is strored in parametres pars(“dist”)

Vector<real_t> invBiStereographicParametrization(const Point &pt, Parameters &pars, DiffOpType d = _id) const#

inv of bi-stereographic parametrization

inverse of bi-stereographic parametrization

Vector<real_t> invParametrization(const Point &pt, Parameters &pars, DiffOpType d = _id) const#

inverse of parametrization

inverse of EllipsoidSidePart parametrization (u,v)=invf(p)

Vector<real_t> invStereographicParametrization(const Point &pt, Parameters &pars, DiffOpType d = _id) const#

inv of stereographic parametrization

inverse of stereographic parametrization: u = (x-Cx)/(R+z-Cz) v = (y-Cy)/(R+z-Cz)

Vector<real_t> invThetaPhiParametrization(const Point &pt, Parameters &pars, DiffOpType d = _id) const#

inv of theta-phi parametrization

inverse of EllipsoidSidePart parametrization (u,v)=invf(p)

bool isFull() const#

true if full ellisoid side

Vector<real_t> stereographicParametrization(const Point &pt, Parameters &pars, DiffOpType d = _id) const#

stereographic parametrization

Stereographic parametrization of sphere S(C,R), (u,v) in ]0,1[x]0,1[ : (u,v) -> (s,t) = (tan(pi(u-0.5),tan(pi(v-0.5)) maps ]0,1[x]0,1[ to R2 Stereographic parametrization of sphere S(C,R) (s,t) in R2 2s 2t 1-s^2-t^2 x = Cx + R ——&#8212; y = Cy + R ——&#8212; z = Cz + R ——&#8212; 1+s^2+t^2 1+s^2+t^2 1+s^2+t^2.

(s,t) = (0,0) -> C+(0,0,R) (s,t) = (cos(a),sin(a)) -> C+(Rcos(a), Rsin(a),0) |(s,t)|-> +inf -> C+(0,0,-R) C-inf parametrization R^2 -> S/south

To deal with any ellipsoid E, use the transformation that maps the unit sphere S(0,1) to E: (x,y,z) -> C + x(P1-C) + y(P2-C) + z(P3-C) (P1,P2,P3 first apogees of E)

Vector<real_t> thetaPhiParametrization(const Point &pt, Parameters &pars, DiffOpType d = _id) const#

theta-phi parametrization

(theta-phi) parametrization of EllipsoidSidePart theta = (1-u)theta_min + u theta_max, phi = (1-v)phi_min + v phi_max P - P0 = (P1-P0) cos(theta) cos(phi) + (P2-P0) sin(theta) cos(phi) + (P6-P0) sin(phi)