IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Changeset 3352


Ignore:
Timestamp:
Mar 1, 2005, 11:40:29 AM (21 years ago)
Author:
evanalst
Message:

Update psSphereTransformApply test cases.

Location:
trunk/psLib/test/astronomy
Files:
2 edited

Legend:

Unmodified
Added
Removed

  • trunk/psLib/test/astronomy/tst_psCoord.c

    r3333 r3352  
    66*  @author GLG, MHPCC
    77*
    8 *  @version $Revision: 1.18 $ $Name: not supported by cvs2svn $
    9 *  @date $Date: 2005-02-25 22:27:37 $
     8*  @version $Revision: 1.19 $ $Name: not supported by cvs2svn $
     9*  @date $Date: 2005-03-01 21:40:28 $
    1010*
    1111*  XXX: Must test psSpherePrecess.
    … …  
    2929static psS32 testSphereTransformApply1( void );
    3030static psS32 testSphereTransformApply2( void );
     31static psS32 testSphereTransformApply3( void );
     32static psS32 testSphereTransformApply4( void );
     33static psS32 testSphereTransformApply5( void );
    3134static psS32 testSphereTransformICRSToEcliptic( void );
    3235static psS32 testSphereTransformEclipticToICRS( void );
    … …  
    4548                              {test2, 0000, "psPlaneTransformApply()", 0, false},
    4649                              {test3, 0000, "psPlaneDistortApply()", 0, false},
    47                               {testSphereTransformApply1, 820, "psPSphereTransformApply()", 0, false},
    48                               {testSphereTransformApply2, 820, "psPSphereTransformApply()", 0, false},
     50                              {testSphereTransformApply1, 820, "psSphereTransformApply()", 0, false},
     51                              {testSphereTransformApply2, 820, "psSphereTransformApply()", 0, false},
     52                              {testSphereTransformApply3, 820, "psSphereTransformApply()", 0, false},
     53                              {testSphereTransformApply4, 820, "psSphereTransformApply()", 0, false},
     54                              {testSphereTransformApply5, 820, "psSphereTransformApply()", 0, false},
    4955                              {testSphereTransformICRSToEcliptic, 821, "psSphereTransformICRSToEcliptic()", 0, false},
    5056                              {testSphereTransformEclipticToICRS, 822, "psSphereTransformEclipticToICRS()", 0, false},
    … …  
    6672    return ( ! runTestSuite( stderr, "psCoord", tests, argc, argv ) );
    6773}
     74
     75#define MJD_1900  15021.0        // Modified Julian Day 1/1/1900 00:00:00
     76#define MJD_2000  51544.0        // Modified Julian Day 1/1/2000 00:00:00
     77#define MJD_2100  88069.0        // Modified Julian Day 1/1/2100 00:00:00
     78
     79#define ERROR_TOL   0.0001
    6880
    6981#define MY_TINY 0.0001
    … …  
    456468                return 1;
    457469            }
    458             if (FLT_EPSILON < fabs(out->r - in->r)) {
     470            if (ERROR_TOL < fabs(out->r - in->r)) {
    459471                psError(PS_ERR_UNKNOWN,true,"out->r is %f, should be %f\n", out->r, in->r);
    460472                return 2;
    461473            }
    462             if (FLT_EPSILON < fabs(out->d - in->d)) {
     474            if (ERROR_TOL < fabs(out->d - in->d)) {
    463475                psError(PS_ERR_UNKNOWN,true,"out->d is %f, should be %f\n", out->d, in->d);
    464476                return 3;
    … …  
    583595}
    584596
    585 #define MJD_1900  15021.0        // Modified Julian Day 1/1/1900 00:00:00
    586 #define MJD_2000  51544.0        // Modified Julian Day 1/1/2000 00:00:00
    587 #define MJD_2100  88069.0        // Modified Julian Day 1/1/2100 00:00:00
     597// Test point 1  ADD  ICRS(0,0) to Galactic (96.337272,-60.188553)
     598//                              to Ecliptic (0,0) with T=1
     599#define SPHERE_COORD_TP1_GAL_R           1.681409       //  96.337272 degrees
     600#define SPHERE_COORD_TP1_GAL_D          -1.050488       // -60.188553 degrees
     601#define SPHERE_COORD_TP1_ECL_R           0.0
     602#define SPHERE_COORD_TP1_ECL_D           0.0
     603#define SPHERE_COORD_TP1_INVERSE_R       0.0
     604#define SPHERE_COORD_TP1_INVERSE_D       0.0
     605
     606// Test point 2 ADD  ICRS(0,90) to Galactic (122.93192, 27.12825)
     607//                              to Ecliptic (90,66.560719) with T=1
     608#define SPHERE_COORD_TP2_GAL_R           2.145567       // 122.93192 degrees
     609#define SPHERE_COORD_TP2_GAL_D           0.473477       // 27.12825  degrees
     610#define SPHERE_COORD_TP2_ECL_R           1.570796       // 90        degrees
     611#define SPHERE_COORD_TP2_ECL_D           1.161704       // 66.560719 degrees
     612#define SPHERE_COORD_TP2_INVERSE_R       0.0            // 0         degrees
     613#define SPHERE_COORD_TP2_INVERSE_D       1.570796       // 90        degrees
     614
     615// Test point 3 ADD  ICRS(180,30) to Galactic (195.639488, 78.353806)
     616//                                to Ecliptic (167.072470, 27.308813) with T=2
     617#define SPHERE_COORD_TP3_GAL_R           3.414553       // 195.639488 degrees
     618#define SPHERE_COORD_TP3_GAL_D           1.367532       // 78.353806  degrees
     619#define SPHERE_COORD_TP3_ECL_R           2.915965       // 167.07247  degrees
     620#define SPHERE_COORD_TP3_ECL_D           0.476629       // 27.308813  degrees
     621#define SPHERE_COORD_TP3_INVERSE_R       3.141593       // 180.0      degrees
     622#define SPHERE_COORD_TP3_INVERSE_D       0.523599       // 30.0       degrees
     623
     624psS32 testSphereTransformApply3( void)
     625{
     626
     627    psSphereTransform*  testTransform;
     628    psSphere*           inputCoord = psSphereAlloc();
     629    psSphere*           outputCoord = NULL;
     630    psSphere*           inverseOutputCoord = NULL;
     631
     632    inputCoord->r = SPHERE_COORD_TP1_INVERSE_R;
     633    inputCoord->d = SPHERE_COORD_TP1_INVERSE_D;
     634    inputCoord->rErr = 0.0;
     635    inputCoord->dErr = 0.0;
     636
     637    // Set test date time to 1/1/2000 00:00:00
     638    psTime* testDateTime = psTimeFromMJD(MJD_2000);
     639
     640    // Create transform ICRS to Galactic
     641    testTransform = psSphereTransformICRSToGalactic();
     642
     643    // Perform transform from ICRS to Galactic
     644    outputCoord = psSphereTransformApply(outputCoord,testTransform,inputCoord);
     645    // Verify output not NULL and member values set correctly
     646    if(outputCoord == NULL) {
     647        psError(PS_ERR_UNKNOWN,true,"psSphereTransformApply returned NULL");
     648        return 1;
     649    }
     650    if(fabs(outputCoord->r - SPHERE_COORD_TP1_GAL_R) > ERROR_TOL) {
     651        psError(PS_ERR_UNKNOWN,true,"psSphereTransformApply return coord r %lg not as expected %lg",
     652                outputCoord->r, SPHERE_COORD_TP1_GAL_R);
     653        return 2;
     654    }
     655    if(fabs(outputCoord->d - SPHERE_COORD_TP1_GAL_D) > ERROR_TOL) {
     656        psError(PS_ERR_UNKNOWN,true,"psSphereTransformApply return coord d %ld not as expected %lg",
     657                outputCoord->d, SPHERE_COORD_TP1_GAL_D);
     658        return 3;
     659    }
     660    psFree(testTransform);
     661
     662    // Create inverse transform Galactic to ICRS
     663    testTransform = psSphereTransformGalacticToICRS();
     664
     665    // Perform transform from Galactic to ICRS
     666    inverseOutputCoord = psSphereTransformApply(inverseOutputCoord,testTransform,outputCoord);
     667    // Verify output not NULL and member values set correctly
     668    if(inverseOutputCoord == NULL) {
     669        psError(PS_ERR_UNKNOWN,true,"psSphereTransformApply returned NULL");
     670        return 4;
     671    }
     672
     673    if(fabs(inverseOutputCoord->r - SPHERE_COORD_TP1_INVERSE_R) > ERROR_TOL) {
     674        psError(PS_ERR_UNKNOWN,true,"psSphereTransformApply return coord r %lg not as expected %lg",
     675                inverseOutputCoord->r, SPHERE_COORD_TP1_INVERSE_R);
     676        return 5;
     677    }
     678    if(fabs(inverseOutputCoord->d - SPHERE_COORD_TP1_INVERSE_D) > ERROR_TOL) {
     679        psError(PS_ERR_UNKNOWN,true,"psSphereTransformApply return coord d %ld not as expected %lg",
     680                inverseOutputCoord->d, SPHERE_COORD_TP1_INVERSE_D);
     681        return 6;
     682    }
     683    psFree(testTransform);
     684
     685    // Create transform ICRS to Ecliptic
     686    testTransform = psSphereTransformICRSToEcliptic(testDateTime);
     687
     688    // Perform transform from ICRS to Ecliptic
     689    outputCoord = psSphereTransformApply(outputCoord,testTransform,inputCoord);
     690    // Verify output not NULL and member values set correctly
     691    if(outputCoord == NULL) {
     692        psError(PS_ERR_UNKNOWN,true,"psSphereTransformApply returned NULL");
     693        return 7;
     694    }
     695    if(fabs(outputCoord->r - SPHERE_COORD_TP1_ECL_R) > ERROR_TOL) {
     696        psError(PS_ERR_UNKNOWN,true,"psSphereTransformApply return coord r %lg not as expected %lg",
     697                outputCoord->r, SPHERE_COORD_TP1_ECL_R);
     698        return 8;
     699    }
     700    if(fabs(outputCoord->d - SPHERE_COORD_TP1_ECL_D) > ERROR_TOL) {
     701        psError(PS_ERR_UNKNOWN,true,"psSphereTransformApply return coord d %ld not as expected %lg",
     702                outputCoord->d, SPHERE_COORD_TP1_ECL_D);
     703        return 9;
     704    }
     705    psFree(testTransform);
     706
     707    // Create inverse transform Ecliptic to ICRS
     708    testTransform = psSphereTransformEclipticToICRS(testDateTime);
     709
     710    // Perform transform from Ecliptic to ICRS
     711    inverseOutputCoord = psSphereTransformApply(inverseOutputCoord,testTransform,outputCoord);
     712    // Verify output not NULL and member values set correctly
     713    if(inverseOutputCoord == NULL) {
     714        psError(PS_ERR_UNKNOWN,true,"psSphereTransformApply returned NULL");
     715        return 10;
     716    }
     717    if(fabs(inverseOutputCoord->r - SPHERE_COORD_TP1_INVERSE_R) > ERROR_TOL) {
     718        psError(PS_ERR_UNKNOWN,true,"psSphereTransformApply return coord r %lg not as expected %lg",
     719                inverseOutputCoord->r, SPHERE_COORD_TP1_INVERSE_R);
     720        return 11;
     721    }
     722    if(fabs(inverseOutputCoord->d - SPHERE_COORD_TP1_INVERSE_D) > ERROR_TOL) {
     723        psError(PS_ERR_UNKNOWN,true,"psSphereTransformApply return coord d %ld not as expected %lg",
     724                inverseOutputCoord->d, SPHERE_COORD_TP1_INVERSE_D);
     725        return 12;
     726    }
     727    psFree(testTransform);
     728
     729    psFree(testDateTime);
     730    psFree(outputCoord);
     731    psFree(inputCoord);
     732    psFree(inverseOutputCoord);
     733
     734    return 0;
     735}
     736
     737psS32 testSphereTransformApply4( void)
     738{
     739
     740    psSphereTransform*  testTransform;
     741    psSphere*           inputCoord = psSphereAlloc();
     742    psSphere*           outputCoord = NULL;
     743    psSphere*           inverseOutputCoord = NULL;
     744
     745    inputCoord->r = SPHERE_COORD_TP2_INVERSE_R;
     746    inputCoord->d = SPHERE_COORD_TP2_INVERSE_D;
     747    inputCoord->rErr = 0.0;
     748    inputCoord->dErr = 0.0;
     749
     750    // Set test date time to 1/1/2000 00:00:00
     751    psTime* testDateTime = psTimeFromMJD(MJD_2000);
     752
     753    // Create transform ICRS to Galactic
     754    testTransform = psSphereTransformICRSToGalactic();
     755
     756    // Perform transform from ICRS to Galactic
     757    outputCoord = psSphereTransformApply(outputCoord,testTransform,inputCoord);
     758    // Verify output not NULL and member values set correctly
     759    if(outputCoord == NULL) {
     760        psError(PS_ERR_UNKNOWN,true,"psSphereTransformApply returned NULL");
     761        return 1;
     762    }
     763    if(fabs(outputCoord->r - SPHERE_COORD_TP2_GAL_R) > ERROR_TOL) {
     764        psError(PS_ERR_UNKNOWN,true,"psSphereTransformApply return coord r %lg not as expected %lg",
     765                outputCoord->r, SPHERE_COORD_TP2_GAL_R);
     766        return 2;
     767    }
     768    if(fabs(outputCoord->d - SPHERE_COORD_TP2_GAL_D) > ERROR_TOL) {
     769        psError(PS_ERR_UNKNOWN,true,"psSphereTransformApply return coord d %ld not as expected %lg",
     770                outputCoord->d, SPHERE_COORD_TP2_GAL_D);
     771        return 3;
     772    }
     773    psFree(testTransform);
     774
     775    // Create inverse transform Galactic to ICRS
     776    testTransform = psSphereTransformGalacticToICRS();
     777
     778    // Perform transform from Galactic to ICRS
     779    inverseOutputCoord = psSphereTransformApply(inverseOutputCoord,testTransform,outputCoord);
     780    // Verify output not NULL and member values set correctly
     781    if(inverseOutputCoord == NULL) {
     782        psError(PS_ERR_UNKNOWN,true,"psSphereTransformApply returned NULL");
     783        return 4;
     784    }
     785    // atan2 function introduces some error with y close to zero, increased error tolerance
     786    if(fabs(inverseOutputCoord->r - SPHERE_COORD_TP2_INVERSE_R) > ERROR_TOL+0.1) {
     787        psError(PS_ERR_UNKNOWN,true,"psSphereTransformApply return coord r %lg not as expected %lg",
     788                inverseOutputCoord->r, SPHERE_COORD_TP2_INVERSE_R);
     789        return 5;
     790    }
     791    if(fabs(inverseOutputCoord->d - SPHERE_COORD_TP2_INVERSE_D) > ERROR_TOL) {
     792        psError(PS_ERR_UNKNOWN,true,"psSphereTransformApply return coord d %ld not as expected %lg",
     793                inverseOutputCoord->d, SPHERE_COORD_TP2_INVERSE_D);
     794        return 6;
     795    }
     796    psFree(testTransform);
     797
     798    // Create transform ICRS to Ecliptic
     799    testTransform = psSphereTransformICRSToEcliptic(testDateTime);
     800
     801    // Perform transform from ICRS to Ecliptic
     802    outputCoord = psSphereTransformApply(outputCoord,testTransform,inputCoord);
     803    // Verify output not NULL and member values set correctly
     804    if(outputCoord == NULL) {
     805        psError(PS_ERR_UNKNOWN,true,"psSphereTransformApply returned NULL");
     806        return 7;
     807    }
     808    if(fabs(outputCoord->r - SPHERE_COORD_TP2_ECL_R) > ERROR_TOL) {
     809        psError(PS_ERR_UNKNOWN,true,"psSphereTransformApply return coord r %lg not as expected %lg",
     810                outputCoord->r, SPHERE_COORD_TP2_ECL_R);
     811        return 8;
     812    }
     813    if(fabs(outputCoord->d - SPHERE_COORD_TP2_ECL_D) > ERROR_TOL) {
     814        psError(PS_ERR_UNKNOWN,true,"psSphereTransformApply return coord d %ld not as expected %lg",
     815                outputCoord->d, SPHERE_COORD_TP2_ECL_D);
     816        return 9;
     817    }
     818    psFree(testTransform);
     819
     820    // Create inverse transform Ecliptic to ICRS
     821    testTransform = psSphereTransformEclipticToICRS(testDateTime);
     822
     823    // Perform transform from Ecliptic to ICRS
     824    inverseOutputCoord = psSphereTransformApply(inverseOutputCoord,testTransform,outputCoord);
     825    // Verify output not NULL and member values set correctly
     826    if(inverseOutputCoord == NULL) {
     827        psError(PS_ERR_UNKNOWN,true,"psSphereTransformApply returned NULL");
     828        return 10;
     829    }
     830    if(fabs(inverseOutputCoord->r - SPHERE_COORD_TP2_INVERSE_R) > ERROR_TOL) {
     831        psError(PS_ERR_UNKNOWN,true,"psSphereTransformApply return coord r %lg not as expected %lg",
     832                inverseOutputCoord->r, SPHERE_COORD_TP2_INVERSE_R);
     833        return 11;
     834    }
     835    if(fabs(inverseOutputCoord->d - SPHERE_COORD_TP2_INVERSE_D) > ERROR_TOL) {
     836        psError(PS_ERR_UNKNOWN,true,"psSphereTransformApply return coord d %ld not as expected %lg",
     837                inverseOutputCoord->d, SPHERE_COORD_TP2_INVERSE_D);
     838        return 12;
     839    }
     840    psFree(testTransform);
     841
     842    psFree(testDateTime);
     843    psFree(outputCoord);
     844    psFree(inputCoord);
     845    psFree(inverseOutputCoord);
     846
     847    return 0;
     848}
     849
     850psS32 testSphereTransformApply5( void)
     851{
     852
     853    psSphereTransform*  testTransform;
     854    psSphere*           inputCoord = psSphereAlloc();
     855    psSphere*           outputCoord = NULL;
     856    psSphere*           inverseOutputCoord = NULL;
     857
     858    inputCoord->r = SPHERE_COORD_TP3_INVERSE_R;
     859    inputCoord->d = SPHERE_COORD_TP3_INVERSE_D;
     860    inputCoord->rErr = 0.0;
     861    inputCoord->dErr = 0.0;
     862
     863    // Set test date time to 1/1/2100 00:00:00
     864    psTime* testDateTime = psTimeFromMJD(MJD_2100);
     865
     866    // Create transform ICRS to Galactic
     867    testTransform = psSphereTransformICRSToGalactic();
     868
     869    // Perform transform from ICRS to Galactic
     870    outputCoord = psSphereTransformApply(outputCoord,testTransform,inputCoord);
     871    // Verify output not NULL and member values set correctly
     872    if(outputCoord == NULL) {
     873        psError(PS_ERR_UNKNOWN,true,"psSphereTransformApply returned NULL");
     874        return 1;
     875    }
     876    if(fabs(outputCoord->r - SPHERE_COORD_TP3_GAL_R) > ERROR_TOL) {
     877        psError(PS_ERR_UNKNOWN,true,"psSphereTransformApply return coord r %lg not as expected %lg",
     878                outputCoord->r, SPHERE_COORD_TP3_GAL_R);
     879        return 2;
     880    }
     881    if(fabs(outputCoord->d - SPHERE_COORD_TP3_GAL_D) > ERROR_TOL) {
     882        psError(PS_ERR_UNKNOWN,true,"psSphereTransformApply return coord d %ld not as expected %lg",
     883                outputCoord->d, SPHERE_COORD_TP3_GAL_D);
     884        return 3;
     885    }
     886    psFree(testTransform);
     887
     888    // Create inverse transform Galactic to ICRS
     889    testTransform = psSphereTransformGalacticToICRS();
     890
     891    // Perform transform from Galactic to ICRS
     892    inverseOutputCoord = psSphereTransformApply(inverseOutputCoord,testTransform,outputCoord);
     893    // Verify output not NULL and member values set correctly
     894    if(inverseOutputCoord == NULL) {
     895        psError(PS_ERR_UNKNOWN,true,"psSphereTransformApply returned NULL");
     896        return 4;
     897    }
     898    if(fabs(inverseOutputCoord->r - SPHERE_COORD_TP3_INVERSE_R) > ERROR_TOL+0.1) {
     899        psError(PS_ERR_UNKNOWN,true,"psSphereTransformApply return coord r %lg not as expected %lg",
     900                inverseOutputCoord->r, SPHERE_COORD_TP3_INVERSE_R);
     901        return 5;
     902    }
     903    if(fabs(inverseOutputCoord->d - SPHERE_COORD_TP3_INVERSE_D) > ERROR_TOL) {
     904        psError(PS_ERR_UNKNOWN,true,"psSphereTransformApply return coord d %ld not as expected %lg",
     905                inverseOutputCoord->d, SPHERE_COORD_TP3_INVERSE_D);
     906        return 6;
     907    }
     908    psFree(testTransform);
     909
     910    // Create transform ICRS to Ecliptic
     911    testTransform = psSphereTransformICRSToEcliptic(testDateTime);
     912
     913    // Perform transform from ICRS to Ecliptic
     914    outputCoord = psSphereTransformApply(outputCoord,testTransform,inputCoord);
     915    // Verify output not NULL and member values set correctly
     916    if(outputCoord == NULL) {
     917        psError(PS_ERR_UNKNOWN,true,"psSphereTransformApply returned NULL");
     918        return 7;
     919    }
     920    if(fabs(outputCoord->r - SPHERE_COORD_TP3_ECL_R) > ERROR_TOL) {
     921        psError(PS_ERR_UNKNOWN,true,"psSphereTransformApply return coord r %lg not as expected %lg",
     922                outputCoord->r, SPHERE_COORD_TP3_ECL_R);
     923        return 8;
     924    }
     925    if(fabs(outputCoord->d - SPHERE_COORD_TP3_ECL_D) > ERROR_TOL) {
     926        psError(PS_ERR_UNKNOWN,true,"psSphereTransformApply return coord d %ld not as expected %lg",
     927                outputCoord->d, SPHERE_COORD_TP3_ECL_D);
     928        return 9;
     929    }
     930    psFree(testTransform);
     931
     932    // Create inverse transform Ecliptic to ICRS
     933    testTransform = psSphereTransformEclipticToICRS(testDateTime);
     934
     935    // Perform transform from Ecliptic to ICRS
     936    inverseOutputCoord = psSphereTransformApply(inverseOutputCoord,testTransform,outputCoord);
     937    // Verify output not NULL and member values set correctly
     938    if(inverseOutputCoord == NULL) {
     939        psError(PS_ERR_UNKNOWN,true,"psSphereTransformApply returned NULL");
     940        return 10;
     941    }
     942    if(fabs(inverseOutputCoord->r - SPHERE_COORD_TP3_INVERSE_R) > ERROR_TOL) {
     943        psError(PS_ERR_UNKNOWN,true,"psSphereTransformApply return coord r %lg not as expected %lg",
     944                inverseOutputCoord->r, SPHERE_COORD_TP3_INVERSE_R);
     945        return 11;
     946    }
     947    if(fabs(inverseOutputCoord->d - SPHERE_COORD_TP3_INVERSE_D) > ERROR_TOL) {
     948        psError(PS_ERR_UNKNOWN,true,"psSphereTransformApply return coord d %ld not as expected %lg",
     949                inverseOutputCoord->d, SPHERE_COORD_TP3_INVERSE_D);
     950        return 12;
     951    }
     952    psFree(testTransform);
     953
     954    psFree(testDateTime);
     955    psFree(outputCoord);
     956    psFree(inputCoord);
     957    psFree(inverseOutputCoord);
     958
     959    return 0;
     960}
    588961
    589962// Thes values calculated from ADD-09 equations
    … …  
    593966#define EXPECT_SIN_DELTAP_2100    0.397567
    594967
    595 #define ERROR_TOL   0.0001
    596 
    597968psS32 testSphereTransformICRSToEcliptic( void )
    598969{
    … …  
    600971    psF64  expectedAlphaP = 0.0;
    601972    psF64  expectedCosDeltaP = EXPECT_COS_DELTAP_2000;
    602     psF64  expectedSinDeltaP = -EXPECT_SIN_DELTAP_2000;
     973    psF64  expectedSinDeltaP = EXPECT_SIN_DELTAP_2000;
    603974
    604975    // Set test date time to 1/1/2000 00:00:00
    … …  
    6331004
    6341005    expectedCosDeltaP = EXPECT_COS_DELTAP_2100;
    635     expectedSinDeltaP = -EXPECT_SIN_DELTAP_2100;
     1006    expectedSinDeltaP = EXPECT_SIN_DELTAP_2100;
    6361007
    6371008    // Set test date time to 1/1/2100 00:00:00
    … …  
    6921063    psF64  expectedAlphaP = 0.0;
    6931064    psF64  expectedCosDeltaP = EXPECT_COS_DELTAP_2000;
    694     psF64  expectedSinDeltaP = EXPECT_SIN_DELTAP_2000;
     1065    psF64  expectedSinDeltaP = -EXPECT_SIN_DELTAP_2000;
    6951066
    6961067    // Set test date time to 1/1/2000 00:00:00
    … …  
    7251096
    7261097    expectedCosDeltaP = EXPECT_COS_DELTAP_2100;
    727     expectedSinDeltaP = EXPECT_SIN_DELTAP_2100;
     1098    expectedSinDeltaP = -EXPECT_SIN_DELTAP_2100;
    7281099
    7291100    // Set test date time to 1/1/2100 00:00:00
    … …  
    7781149}
    7791150
    780 #define ITG_EXPECT_PHIP        4.93683
    781 #define ITG_EXPECT_SINDELTAP  -0.88999
     1151#define ITG_EXPECT_ALPHAP      4.93683
     1152#define ITG_EXPECT_SINDELTAP   0.88999
    7821153#define ITG_EXPECT_COSDELTAP   0.45598
    783 #define ITG_EXPECT_ALPHAP      0.57477
     1154#define ITG_EXPECT_PHIP        0.57477
    7841155
    7851156psS32 testSphereTransformICRSToGalactic( void )
    … …  
    8201191}
    8211192
    822 #define GTI_EXPECT_ALPHAP      4.93683
    823 #define GTI_EXPECT_SINDELTAP   0.88999
     1193#define GTI_EXPECT_PHIP        4.93683
     1194#define GTI_EXPECT_SINDELTAP  -0.88999
    8241195#define GTI_EXPECT_COSDELTAP   0.45598
    825 #define GTI_EXPECT_PHIP        0.57477
     1196#define GTI_EXPECT_ALPHAP      0.57477
    8261197
    8271198psS32 testSphereTransformGalacticToICRS( void )

  • trunk/psLib/test/astronomy/verified/tst_psCoord.stderr

    r3333 r3352  
    7474/***************************** TESTPOINT ******************************************\
    7575*             TestFile: tst_psCoord.c                                              *
    76 *            TestPoint: psCoord{psPSphereTransformApply()}                         *
     76*            TestPoint: psCoord{psSphereTransformApply()}                          *
    7777*             TestType: Positive                                                   *
    7878\**********************************************************************************/
    … …  
    8787    Unallowable operation: coord is NULL.
    8888
    89 ---> TESTPOINT PASSED (psCoord{psPSphereTransformApply()} | tst_psCoord.c)
    90 
    91 /***************************** TESTPOINT ******************************************\
    92 *             TestFile: tst_psCoord.c                                              *
    93 *            TestPoint: psCoord{psPSphereTransformApply()}                         *
    94 *             TestType: Positive                                                   *
    95 \**********************************************************************************/
    96 
    97 
    98 ---> TESTPOINT PASSED (psCoord{psPSphereTransformApply()} | tst_psCoord.c)
     89---> TESTPOINT PASSED (psCoord{psSphereTransformApply()} | tst_psCoord.c)
     90
     91/***************************** TESTPOINT ******************************************\
     92*             TestFile: tst_psCoord.c                                              *
     93*            TestPoint: psCoord{psSphereTransformApply()}                          *
     94*             TestType: Positive                                                   *
     95\**********************************************************************************/
     96
     97
     98---> TESTPOINT PASSED (psCoord{psSphereTransformApply()} | tst_psCoord.c)
     99
     100/***************************** TESTPOINT ******************************************\
     101*             TestFile: tst_psCoord.c                                              *
     102*            TestPoint: psCoord{psSphereTransformApply()}                          *
     103*             TestType: Positive                                                   *
     104\**********************************************************************************/
     105
     106
     107---> TESTPOINT PASSED (psCoord{psSphereTransformApply()} | tst_psCoord.c)
     108
     109/***************************** TESTPOINT ******************************************\
     110*             TestFile: tst_psCoord.c                                              *
     111*            TestPoint: psCoord{psSphereTransformApply()}                          *
     112*             TestType: Positive                                                   *
     113\**********************************************************************************/
     114
     115
     116---> TESTPOINT PASSED (psCoord{psSphereTransformApply()} | tst_psCoord.c)
     117
     118/***************************** TESTPOINT ******************************************\
     119*             TestFile: tst_psCoord.c                                              *
     120*            TestPoint: psCoord{psSphereTransformApply()}                          *
     121*             TestType: Positive                                                   *
     122\**********************************************************************************/
     123
     124
     125---> TESTPOINT PASSED (psCoord{psSphereTransformApply()} | tst_psCoord.c)
    99126
    100127/***************************** TESTPOINT ******************************************\
Note: See TracChangeset for help on using the changeset viewer.