void Interpolate_State(double Time,
int Target,
double Position[3],
double Velocity[3])
{
double A[50] , B[50] , Cp[50] , P_Sum[3] , V_Sum[3] , Up[50] ,
T_break , T_seg , T_sub , Tc;
int i , j;
long int C , G , N , offset = 0;
Time += TDBOFFSET; /****!!!!! Account for difference between TDB and UT**/
/*--------------------------------------------------------------------------*/
/* This function doesn't "do" nutations or librations. */
/*--------------------------------------------------------------------------*/
if ( Target >= 11 ) /* Also protects against weird input errors */
{
printf("\n This function does not compute nutations or librations.\n");
return;
}
/*--------------------------------------------------------------------------*/
/* Initialize local coefficient array. */
/*--------------------------------------------------------------------------*/
for ( i=0 ; i<50 ; i++ )
{
A[i] = 0.0;
B[i] = 0.0;
}
/*--------------------------------------------------------------------------*/
/* Determine if a new record needs to be input. */
/*--------------------------------------------------------------------------*/
if (Time < T_beg || Time > T_end) Read_Coefficients(Time);
/*--------------------------------------------------------------------------*/
/* Read the coefficients from the binary record. */
/*--------------------------------------------------------------------------*/
C = R1.coeffPtr[Target][0] - 1; /* Coeff array entry point */
N = R1.coeffPtr[Target][1]; /* Number of coeff's */
G = R1.coeffPtr[Target][2]; /* Granules in current record */
/*...................................................Debug print (optional) */
if ( Debug )
{
printf("\n In: Interpolate_State\n");
printf("\n Target = %2d",Target);
printf("\n C = %4ld (before)",C);
printf("\n N = %4ld",N);
printf("\n G = %4ld\n",G);
}
/*--------------------------------------------------------------------------*/
/* Compute the normalized time, then load the Tchebeyshev coefficients */
/* into array A[]. If T_span is covered by a single granule this is easy. */
/* If not, the granule that contains the interpolation time is found, and */
/* an offset from the array entry point for the ephemeris body is used to */
/* load the coefficients. */
/*--------------------------------------------------------------------------*/
if ( G == 1 )
{
Tc = 2.0*(Time - T_beg) / T_span - 1.0;
for (i=C ; i<(C+3*N) ; i++) A[i-C] = Coeff_Array[i];
}
else if ( G > 1 )
{
T_sub = T_span / ((double) G); /* Compute subgranule interval */
T_seg = T_beg + T_sub ; /* Set T_seg to the smallest value that is reasonable */
for ( j=G ; j>0 ; j-- )
{
T_break = T_beg + ((double) j-1) * T_sub;
if ( Time > T_break )
{
T_seg = T_break;
offset = j-1;
break;
}
}
Tc = 2.0*(Time - T_seg) / T_sub - 1.0;
C = C + 3 * offset * N;
for (i=C ; i<(C+3*N) ; i++) A[i-C] = Coeff_Array[i];
}
else /* Something has gone terribly wrong */
{
printf("\n Number of granules must be >= 1: check header data.\n");
}
/*...................................................Debug print (optional) */
if ( Debug )
{
printf("\n C = %4ld (after)",C);
printf("\n offset = %4ld",offset);
printf("\n Time = %12.7f",Time);
printf("\n T_sub = %12.7f",T_sub);
printf("\n T_seg = %12.7f",T_seg);
printf("\n Tc = %12.7f\n",Tc);
printf("\n Array Coefficients:\n");
for ( i=0 ; i<3*N ; i++ )
{
printf("\n A[%2d] = % 22.15e",i,A[i]);
}
printf("\n\n");
}
/*..........................................................................*/
/*--------------------------------------------------------------------------*/
/* Compute the interpolated position & velocity */
/*--------------------------------------------------------------------------*/
for ( i=0 ; i<3 ; i++ ) /* Compute interpolating polynomials */
{
Cp[0] = 1.0;
Cp[1] = Tc;
Cp[2] = 2.0 * Tc*Tc - 1.0;
Up[0] = 0.0;
Up[1] = 1.0;
Up[2] = 4.0 * Tc;
for ( j=3 ; j<N ; j++ )
{
Cp[j] = 2.0 * Tc * Cp[j-1] - Cp[j-2];
Up[j] = 2.0 * Tc * Up[j-1] + 2.0 * Cp[j-1] - Up[j-2];
}
P_Sum[i] = 0.0; /* Compute interpolated position & velocity */
V_Sum[i] = 0.0;
for ( j=N-1 ; j>-1 ; j-- ) P_Sum[i] = P_Sum[i] + A[j+i*N] * Cp[j];
for ( j=N-1 ; j>0 ; j-- ) V_Sum[i] = V_Sum[i] + A[j+i*N] * Up[j];
Position[i] = P_Sum[i];
Velocity[i] = V_Sum[i] * 2.0 * ((double) G) / (T_span * 86400.0);
}
/*--------------------------------------------------------------------------*/
/* Return computed values. */
/*--------------------------------------------------------------------------*/
return;
}
void Interpolate_Position( long double Time , int Target , long double Position[3] )
{
double A[50] , Cp[50] , sum[3] , T_break , T_seg , T_sub , Tc;
int i , j;
long int C , G , N , offset = 0;
/*--------------------------------------------------------------------------*/
/* This function doesn't "do" nutations or librations. */
/*--------------------------------------------------------------------------*/
if ( Target >= 11 ) /* Also protects against weird input errors */
{
printf("\n This function does not compute nutations or librations.\n");
return;
}
/*--------------------------------------------------------------------------*/
/* Initialize local coefficient array. */
/*--------------------------------------------------------------------------*/
for ( i=0 ; i<50 ; i++ )
{
A[i] = 0.0;
}
/*--------------------------------------------------------------------------*/
/* Determine if a new record needs to be input (if so, get it). */
/*--------------------------------------------------------------------------*/
if (Time < T_beg || Time > T_end) Read_Coefficients(Time);
/*--------------------------------------------------------------------------*/
/* Read the coefficients from the binary record. */
/*--------------------------------------------------------------------------*/
C = R1.coeffPtr[Target][0] - 1; /* Coefficient array entry point */
N = R1.coeffPtr[Target][1]; /* Number of coeff's per component */
G = R1.coeffPtr[Target][2]; /* Granules in current record */
/*...................................................Debug print (optional) */
if ( Debug )
{
printf("\n In: Interpolate_Position\n");
printf("\n Target = %2d",Target);
printf("\n C = %4d (before)",C);
printf("\n N = %4d",N);
printf("\n G = %4d\n",G);
}
/*--------------------------------------------------------------------------*/
/* Compute the normalized time, then load the Tchebeyshev coefficients */
/* into array A[]. If T_span is covered by a single granule this is easy. */
/* If not, the granule that contains the interpolation time is found, and */
/* an offset from the array entry point for the ephemeris body is used to */
/* load the coefficients. */
/*--------------------------------------------------------------------------*/
if ( G == 1 )
{
Tc = 2.0*(Time - T_beg) / T_span - 1.0;
for (i=C ; i<(C+3*N) ; i++) A[i-C] = Coeff_Array[i];
}
else if ( G > 1 )
{
T_sub = T_span / ((long double) G); /* Compute subgranule interval */
for ( j=G ; j>0 ; j-- )
{
T_break = T_beg + ((long double) j-1) * T_sub;
if ( Time > T_break )
{
T_seg = T_break;
offset = j-1;
break;
}
}
Tc = 2.0*(Time - T_seg) / T_sub - 1.0;
C = C + 3 * offset * N;
for (i=C ; i<(C+3*N) ; i++) A[i-C] = Coeff_Array[i];
}
else /* Something has gone terribly wrong */
{
printf("\n Number of granules must be >= 1: check header data.\n");
}
/*...................................................Debug print (optional) */
if ( Debug )
{
printf("\n C = %4d (after)",C);
printf("\n offset = %4d",offset);
printf("\n Time = %12.7f",Time);
printf("\n T_sub = %12.7f",T_sub);
printf("\n T_seg = %12.7f",T_seg);
printf("\n Tc = %12.7f\n",Tc);
printf("\n Array Coefficients:\n");
for ( i=0 ; i<3*N ; i++ )
{
printf("\n A[%2d] = % 22.15e",i,A[i]);
}
printf("\n\n");
}
/*..........................................................................*/
/*--------------------------------------------------------------------------*/
/* Compute interpolated the position. */
/*--------------------------------------------------------------------------*/
for ( i=0 ; i<3 ; i++ )
{
Cp[0] = 1.0; /* Begin polynomial sum */
Cp[1] = Tc;
sum[i] = A[i*N] + A[1+i*N]*Tc;
for ( j=2 ; j<N ; j++ ) /* Finish it */
{
Cp[j] = 2.0 * Tc * Cp[j-1] - Cp[j-2];
sum[i] = sum[i] + A[j+i*N] * Cp[j];
}
Position[i] = sum[i];
}
return;
}
