void Spice::ComputeSolarLongitude(double et) {
NaifStatus::CheckErrors();
if (iString(Target()).UpCase() == "SKY") {
p_solarLongitude = -999.0;
return;
}
if (p_bodyRotation->IsCached()) return;
double tipm[3][3], npole[3];
char frameName[32];
SpiceInt frameCode;
SpiceBoolean found;
cidfrm_c (p_spkBodyCode, sizeof(frameName), &frameCode, frameName, &found);
if ( found ) {
pxform_c("J2000",frameName,et,tipm);
}
else {
tipbod_c("J2000",p_spkBodyCode,et,tipm);
}
for (int i=0; i<3; i++) {
npole[i] = tipm[2][i];
}
double state[6], lt;
spkez_c(p_spkBodyCode,et,"J2000","NONE",10,state,<);
double uavel[3];
ucrss_c(state,&state[3],uavel);
double x[3], y[3], z[3];
vequ_c(uavel,z);
ucrss_c(npole,z,x);
ucrss_c(z,x,y);
double trans[3][3];
for (int i=0; i<3; i++) {
trans[0][i] = x[i];
trans[1][i] = y[i];
trans[2][i] = z[i];
}
spkez_c(10,et,"J2000","LT+S",p_spkBodyCode,state,<);
double pos[3];
mxv_c(trans,state,pos);
double radius, ls, lat;
reclat_c(pos,&radius,&ls,&lat);
ls *= 180.0 / Isis::PI;
if (ls < 0.0) ls += 360.0;
else if (ls > 360.0) ls -= 360.0;
p_solarLongitude = ls;
NaifStatus::CheckErrors();
}
void psv2pl_c ( ConstSpiceDouble point[3],
ConstSpiceDouble span1[3],
ConstSpiceDouble span2[3],
SpicePlane * plane )
/*
-Brief_I/O
Variable I/O Description
-------- --- --------------------------------------------------
point,
span1,
span2 I A point and two spanning vectors defining a plane.
plane O A CSPICE plane representing the plane.
-Detailed_Input
point,
span1,
span2 are, respectively, a point and two spanning vectors
that define a geometric plane in three-dimensional
space. The plane is the set of vectors
point + s * span1 + t * span2
where s and t are real numbers. The spanning
vectors span1 and span2 must be linearly
independent, but they need not be orthogonal or
unitized.
-Detailed_Output
plane is a CSPICE plane that represents the geometric
plane defined by point, span1, and span2.
-Parameters
None.
-Exceptions
1) If span1 and span2 are linearly dependent, then the vectors
point, span1, and span2 do not define a plane. The error
SPICE(DEGENERATECASE) is signaled.
-Files
None.
-Particulars
CSPICE geometry routines that deal with planes use the `plane'
data type to represent input and output planes. This data type
makes the subroutine interfaces simpler and more uniform.
The CSPICE routines that produce CSPICE planes from data that
define a plane are:
nvc2pl_c ( Normal vector and constant to plane )
nvp2pl_c ( Normal vector and point to plane )
psv2pl_c ( Point and spanning vectors to plane )
The CSPICE routines that convert CSPICE planes to data that
define a plane are:
pl2nvc_c ( Plane to normal vector and constant )
pl2nvp_c ( Plane to normal vector and point )
pl2psv_c ( Plane to point and spanning vectors )
Any of these last three routines may be used to convert this
routine's output, plane, to another representation of a
geometric plane.
-Examples
1) Project a vector v orthogonally onto a plane defined by
point, span1, and span2. proj is the projection we want; it
is the closest vector in the plane to v.
psv2pl_c ( point, span1, span2, &plane );
vprjp_c ( v, &plane, proj );
2) Find the plane determined by a spacecraft's position vector
relative to a central body and the spacecraft's velocity
vector. We assume that all vectors are given in the same
coordinate system.
/.
pos is the spacecraft's position, relative to
the central body. vel is the spacecraft's velocity
vector. pos is a point (vector, if you like) in
the orbit plane, and it is also one of the spanning
vectors of the plane.
./
psv2pl_c ( pos, pos, vel, &plane );
-Restrictions
None.
-Literature_References
[1] `Calculus and Analytic Geometry', Thomas and Finney.
-Author_and_Institution
N.J. Bachman (JPL)
-Version
-CSPICE Version 1.0.0, 05-MAR-1999 (NJB)
-Index_Entries
point and spanning vectors to plane
-&
*/
{ /* Begin psv2pl_c */
/*
This routine checks in only if an error is discovered.
*/
if ( return_c () )
{
return;
}
/*
Find the unitized cross product of SPAN1 and SPAN2; this is our
unit normal vector, or possibly its inverse.
*/
ucrss_c ( span1, span2, plane->normal );
if ( vzero_c ( plane->normal ) )
{
chkin_c ( "psv2pl_c" );
setmsg_c ( "Spanning vectors are parallel." );
sigerr_c ( "SPICE(DEGENERATECASE)" );
chkout_c ( "psv2pl_c" );
return;
}
/*
Find the plane constant corresponding to the unit normal
vector we've found.
*/
plane->constant = vdot_c ( plane->normal, point );
/*
The constant should be the distance of the plane from the
origin. If the constant is negative, negate both it and the
normal vector.
*/
if ( plane->constant < 0. )
{
plane->constant = - (plane->constant);
vminus_c ( plane->normal, plane->normal );
}
} /* End psv2pl_c */