initial upload
This commit is contained in:
15
test/CMakeLists.txt
Normal file
15
test/CMakeLists.txt
Normal file
@@ -0,0 +1,15 @@
|
||||
# 设置编译选项
|
||||
set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -O2")
|
||||
if(WIN32)
|
||||
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -O2")
|
||||
else()
|
||||
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} --std=c++11 -O2")
|
||||
endif()
|
||||
|
||||
# 设置可执行文件的输出地址
|
||||
set(EXECUTABLE_OUTPUT_PATH ${PROJECT_BINARY_DIR}/bin/test)
|
||||
|
||||
# 添加可执行程序名称
|
||||
add_executable(test_all test_all.c)
|
||||
# 链接动态库
|
||||
target_link_libraries(test_all PUBLIC tesseroids)
|
||||
112
test/minunit.h
Executable file
112
test/minunit.h
Executable file
@@ -0,0 +1,112 @@
|
||||
/* This is a modified version of the MinUnit testing tool.
|
||||
|
||||
As with the original, you may use this code for any purpose, with the
|
||||
understanding that it comes with NO WARRANTY.
|
||||
|
||||
The original can be found at http://www.jera.com/techinfo/jtns/jtn002.html
|
||||
|
||||
USAGE:
|
||||
Simmply include minunit.h and implement the testing functions using the
|
||||
assertions. To run the tests, call mu_run_test. It will run the tests, print
|
||||
out the verbose and if the test passed or failed. Use mu_print_summary to
|
||||
print out a summary of the tests (how many were run, how long it took, how many
|
||||
failed and how many passed).
|
||||
|
||||
Ex:
|
||||
|
||||
#include "minunit.h"
|
||||
#include "myfuncs.h"
|
||||
|
||||
int tests_run = 0, tests_passed = 0, tests_failed = 0;
|
||||
|
||||
char * test_func1()
|
||||
{
|
||||
// Assert that func1 returns 3 when passed 1.2
|
||||
// assertion will return the fail message if fails
|
||||
mu_assert(func1(1.2) == 3, "func1 did not return 3 when passed 1.2");
|
||||
|
||||
// If the assertion passed, return 0
|
||||
return 0;
|
||||
}
|
||||
|
||||
int main()
|
||||
{
|
||||
mu_run_test(test_func1, "testing func1");
|
||||
|
||||
// If passed the time it took to run the tests will print it. Pass 0.0 to
|
||||
// ommit the time
|
||||
mu_print_summary(0.0);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
Simply compile and run the test program.
|
||||
|
||||
Author: Leonardo Uieda
|
||||
Date: 25 Jan 2011
|
||||
*/
|
||||
|
||||
#ifndef _MINUNIT_H_
|
||||
#define _MINUNIT_H_
|
||||
|
||||
#include <stdio.h>
|
||||
#include <math.h>
|
||||
|
||||
/* Global counters. WARNING: Don't forget to initialize in the main program
|
||||
before running the tests! */
|
||||
extern int tests_run, tests_passed, tests_failed;
|
||||
|
||||
|
||||
/* Basic assertion. If fails, returns msg. If passes, returns 0 */
|
||||
#define mu_assert(test, msg) do { if (!(test)) return msg; } while (0)
|
||||
|
||||
|
||||
/* Assert if val equals expect within a certain precision prec */
|
||||
#define mu_assert_almost_equals(val, expect, prec, msg) do { \
|
||||
if(!(val <= expect + prec && val >= expect - prec)) { return msg; }\
|
||||
} while (0)
|
||||
|
||||
/* Assert if val equals expect within a certain precision precision given in % */
|
||||
#define mu_assert_almost_equals_rel(val, expect, prec, msg) do { \
|
||||
if(fabs(val - expect) > 0.01*prec*fabs(expect)) { return msg; }\
|
||||
} while (0)
|
||||
|
||||
/* Run a test case, print the verbose and check if passed or failed */
|
||||
int mu_run_test(char *(*test)(void), char *verbose)
|
||||
{
|
||||
char *msg;
|
||||
|
||||
printf("\n%s... ", verbose);
|
||||
msg = test();
|
||||
tests_run++;
|
||||
if(msg)
|
||||
{
|
||||
tests_failed++;
|
||||
printf("FAIL:%s", msg);
|
||||
return 1;
|
||||
}
|
||||
else
|
||||
{
|
||||
tests_passed++;
|
||||
printf("pass");
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/* Print a summary of the tests ran and how long it took */
|
||||
#define mu_print_summary(test_time) \
|
||||
printf("\n\n-----------------------------------------------------------"); \
|
||||
printf("\nRan %d test(s)", tests_run); \
|
||||
if(test_time) { printf(" in %g seconds", test_time); } \
|
||||
printf(". %d passed and %d failed.\n", tests_passed, tests_failed);
|
||||
|
||||
|
||||
/* Utility for copying one array onto another */
|
||||
int mu_counter;
|
||||
#define mu_arraycp(original, copy, size) \
|
||||
do {for(mu_counter=0; mu_counter<size; mu_counter++){ \
|
||||
copy[mu_counter]=original[mu_counter]; } \
|
||||
} while (0)
|
||||
|
||||
#endif
|
||||
42
test/test_all.c
Executable file
42
test/test_all.c
Executable file
@@ -0,0 +1,42 @@
|
||||
/*
|
||||
Run all unit tests. This is compiled into a single executable (tesstest).
|
||||
*/
|
||||
|
||||
#include <stdio.h>
|
||||
#include <time.h>
|
||||
#include "../lib/logger.h"
|
||||
#include "minunit.h"
|
||||
#include "test_glq.c"
|
||||
#include "test_geometry.c"
|
||||
#include "test_parsers.c"
|
||||
#include "test_grav_prism.c"
|
||||
#include "test_grav_prism_sph.c"
|
||||
#include "test_grav_tess.c"
|
||||
|
||||
int tests_run = 0, tests_passed = 0, tests_failed = 0;
|
||||
|
||||
int main()
|
||||
{
|
||||
clock_t start = clock();
|
||||
int failed = 0;
|
||||
|
||||
log_init(LOG_INFO);
|
||||
|
||||
failed += glq_run_all();
|
||||
failed += geometry_run_all();
|
||||
failed += parsers_run_all();
|
||||
failed += grav_prism_run_all();
|
||||
failed += grav_prism_sph_run_all();
|
||||
failed += grav_tess_run_all();
|
||||
|
||||
mu_print_summary((double)(clock() - start)/CLOCKS_PER_SEC);
|
||||
|
||||
if(failed)
|
||||
{
|
||||
return 1;
|
||||
}
|
||||
else
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
289
test/test_geometry.c
Executable file
289
test/test_geometry.c
Executable file
@@ -0,0 +1,289 @@
|
||||
/*
|
||||
Unit tests for geometry module.
|
||||
*/
|
||||
|
||||
#include <stdio.h>
|
||||
#include <math.h>
|
||||
#include "minunit.h"
|
||||
#include "../lib/geometry.h"
|
||||
#include "../lib/constants.h"
|
||||
|
||||
/* To store fail messages */
|
||||
char msg[1000];
|
||||
|
||||
|
||||
static char * test_split_tess()
|
||||
{
|
||||
TESSEROID tess = {1, 2, 4, -1, 1, 5, 7},
|
||||
expect[] = {{1, 2, 3, -1, 0, 5, 6}, {1, 3, 4, -1, 0, 5, 6},
|
||||
{1, 2, 3, 0, 1, 5, 6}, {1, 3, 4, 0, 1, 5, 6},
|
||||
{1, 2, 3, -1, 0, 6, 7}, {1, 3, 4, -1, 0, 6, 7},
|
||||
{1, 2, 3, 0, 1, 6, 7}, {1, 3, 4, 0, 1, 6, 7}},
|
||||
res[8];
|
||||
int i, n;
|
||||
|
||||
n = split_tess(tess, 2, 2, 2, res);
|
||||
sprintf(msg, "splitting in %d instead of 8", n);
|
||||
mu_assert(n == 8, msg);
|
||||
for(i = 0; i < 8; i++)
|
||||
{
|
||||
sprintf(msg, "failed for split %d: %g %g %g %g %g %g %g", i, res[i].w,
|
||||
res[i].e, res[i].s, res[i].n, res[i].r1, res[i].r2,
|
||||
res[i].density);
|
||||
mu_assert(res[i].w == expect[i].w && res[i].e == expect[i].e &&
|
||||
res[i].s == expect[i].s && res[i].n == expect[i].n &&
|
||||
res[i].r1 == expect[i].r1 && res[i].r2 == expect[i].r2 &&
|
||||
res[i].density == expect[i].density, msg);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
static char * test_split_uneven_tess()
|
||||
{
|
||||
TESSEROID tess = {1, 2, 4, -1, 1, 5, 7},
|
||||
expect[] = {{1, 2, 3, -1, 0, 5, 7}, {1, 3, 4, -1, 0, 5, 7},
|
||||
{1, 2, 3, 0, 1, 5, 7}, {1, 3, 4, 0, 1, 5, 7}},
|
||||
res[4];
|
||||
int i, n;
|
||||
|
||||
n = split_tess(tess, 2, 2, 1, res);
|
||||
sprintf(msg, "splitting in %d instead of 4", n);
|
||||
mu_assert(n == 4, msg);
|
||||
for(i = 0; i < 4; i++)
|
||||
{
|
||||
sprintf(msg, "failed for split %d: %g %g %g %g %g %g %g", i, res[i].w,
|
||||
res[i].e, res[i].s, res[i].n, res[i].r1, res[i].r2,
|
||||
res[i].density);
|
||||
mu_assert(res[i].w == expect[i].w && res[i].e == expect[i].e &&
|
||||
res[i].s == expect[i].s && res[i].n == expect[i].n &&
|
||||
res[i].r1 == expect[i].r1 && res[i].r2 == expect[i].r2 &&
|
||||
res[i].density == expect[i].density, msg);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
static char * test_prism_volume()
|
||||
{
|
||||
PRISM prisms[4] = {
|
||||
{0,0,1,0,1,0,1,0,0,0},
|
||||
{0,0,2,0,1,0,1,0,0,0},
|
||||
{0,0,2,0,2,0,2,0,0,0},
|
||||
{0,1,2,-1,1,2,3,0,0,0}};
|
||||
double pvolumes[4] = {1, 2, 8, 2};
|
||||
double res;
|
||||
int i;
|
||||
|
||||
for(i = 0; i < 4; i++)
|
||||
{
|
||||
res = prism_volume(prisms[i]);
|
||||
sprintf(msg, "(prism %d) expected %g, got %g", i, pvolumes[i], res);
|
||||
mu_assert(res == pvolumes[i], msg);
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
static char * test_tess_volume()
|
||||
{
|
||||
TESSEROID tesses[4] = {{0,0,360,-90,90,0,1}, {0,0,360,0,90,0,1},
|
||||
{0,180,360,0,90,0,1}, {0,0,90,-90,0,0,1}};
|
||||
double tvolumes[4] = {4.188790205, 2.094395102, 1.047197551, 0.523598776};
|
||||
double res;
|
||||
int i;
|
||||
|
||||
for(i = 0; i < 4; i++)
|
||||
{
|
||||
res = tess_volume(tesses[i]);
|
||||
sprintf(msg, "(tess %d) expected %g, got %g", i, tvolumes[i], res);
|
||||
mu_assert_almost_equals(res, tvolumes[i], pow(10, -8), msg);
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
static char * test_tess_total_mass()
|
||||
{
|
||||
TESSEROID tesses[4] = {{1,0,360,-90,90,0,1}, {1,0,360,0,90,0,1},
|
||||
{1,180,360,0,90,0,1}, {1,0,90,-90,0,0,1}};
|
||||
double tvolumes[4] = {4.188790205, 2.094395102, 1.047197551, 0.523598776};
|
||||
double res, expect;
|
||||
int i;
|
||||
|
||||
res = tess_total_mass(tesses, 4);
|
||||
|
||||
for(expect = 0, i = 0; i < 4; i++)
|
||||
{
|
||||
expect += tvolumes[i];
|
||||
}
|
||||
|
||||
sprintf(msg, "(tess %d) expected %g, got %g", i, expect, res);
|
||||
mu_assert_almost_equals(res, expect, pow(10, -6), msg);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
static char * test_tess_range_mass()
|
||||
{
|
||||
TESSEROID tesses[4] = {{1,0,360,-90,90,0,1}, {-1,0,360,0,90,0,1},
|
||||
{-1,180,360,0,90,0,1}, {1,0,90,-90,0,0,1}};
|
||||
double tvolumes[4] = {4.188790205, 2.094395102, 1.047197551, 0.523598776};
|
||||
double res, expect;
|
||||
|
||||
res = tess_range_mass(tesses, 4, 0, 1);
|
||||
expect = tvolumes[0] + tvolumes[3];
|
||||
sprintf(msg, "Expected %g, got %g", expect, res);
|
||||
mu_assert_almost_equals(res, expect, pow(10, -6), msg);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
static char * test_tess2prism()
|
||||
{
|
||||
int i;
|
||||
double expect, res;
|
||||
double lons[4] = {0.5, 185, 180, -2.5},
|
||||
lats[4] = {0.5, 82.5, -80, 4},
|
||||
rs[4] = {6001000, 6301000, 6000000, 6505000},
|
||||
zs[4] = {1000, 1000, 500000, 5000};
|
||||
PRISM prism;
|
||||
TESSEROID tesses[4] = {
|
||||
{1,0,1,0,1,6000000,6001000},
|
||||
{1,180,190,80,85,6300000,6301000},
|
||||
{1,160,200,-90,-70,5500000,6000000},
|
||||
{1,-10,5,-7,15,6500000,6505000}};
|
||||
|
||||
for(i = 0; i < 4; i++)
|
||||
{
|
||||
tess2prism(tesses[i], &prism);
|
||||
/* check the volume */
|
||||
res = prism_volume(prism);
|
||||
expect = tess_volume(tesses[i]);
|
||||
sprintf(msg, "(tess %d) expected volume %g, got %g", i, expect, res);
|
||||
mu_assert_almost_equals((double)(res - expect)/expect, 0., 0.01, msg);
|
||||
/* check the mass */
|
||||
res *= prism.density;
|
||||
expect *= tesses[i].density;
|
||||
sprintf(msg, "(tess %d) expected mass %g, got %g", i, expect, res);
|
||||
mu_assert_almost_equals((double)(res - expect)/expect, 0., 0.01, msg);
|
||||
/* check the coordinates */
|
||||
res = prism.lon;
|
||||
expect = lons[i];
|
||||
sprintf(msg, "(tess %d) expected lon %g, got %g", i, expect, res);
|
||||
mu_assert_almost_equals((double)(res - expect)/expect, 0., 0.0001, msg);
|
||||
res = prism.lat;
|
||||
expect = lats[i];
|
||||
sprintf(msg, "(tess %d) expected lat %g, got %g", i, expect, res);
|
||||
mu_assert_almost_equals((double)(res - expect)/expect, 0., 0.0001, msg);
|
||||
res = prism.r;
|
||||
expect = rs[i];
|
||||
sprintf(msg, "(tess %d) expected r %g, got %g", i, expect, res);
|
||||
mu_assert_almost_equals((double)(res - expect)/expect, 0., 0.0001, msg);
|
||||
res = prism.z1;
|
||||
expect = 0.;
|
||||
sprintf(msg, "(tess %d) expected z1 %g, got %g", i, expect, res);
|
||||
mu_assert_almost_equals(res, 0., 0.000000000000001, msg);
|
||||
res = prism.z2;
|
||||
expect = zs[i];
|
||||
sprintf(msg, "(tess %d) expected z2 %g, got %g", i, expect, res);
|
||||
mu_assert_almost_equals((double)(res - expect)/expect, 0., 0.0001, msg);
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
static char * test_tess2prism_flatten()
|
||||
{
|
||||
double expect, res;
|
||||
PRISM prism;
|
||||
int i;
|
||||
TESSEROID tesses[4] = {
|
||||
{1,0,1,0,1,6000000,6001000},
|
||||
{1,180,190,80,85,6300000,6301000},
|
||||
{1,160,200,-90,-70,5500000,6000000},
|
||||
{1,-10,5,-7,15,6500000,6505000}};
|
||||
|
||||
for(i = 0; i < 4; i++)
|
||||
{
|
||||
tess2prism_flatten(tesses[i], &prism);
|
||||
res = prism_volume(prism)*prism.density;
|
||||
expect = tess_volume(tesses[i])*tesses[i].density;
|
||||
sprintf(msg, "(tess %d) expected mass %g, got %g", i, expect, res);
|
||||
mu_assert_almost_equals((double)(res - expect)/expect, 0., 0.01, msg);
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
static char * test_tess2sphere()
|
||||
{
|
||||
double expect, res;
|
||||
SPHERE sphere;
|
||||
int i;
|
||||
TESSEROID tesses[4] = {
|
||||
{1,0,1,0,1,6000000,6001000},
|
||||
{1,180,190,80,85,6300000,6301000},
|
||||
{1,160,200,-90,-70,5500000,6000000},
|
||||
{1,-10,5,-7,15,6500000,6505000}};
|
||||
|
||||
for(i = 0; i < 4; i++)
|
||||
{
|
||||
tess2sphere(tesses[i], &sphere);
|
||||
res = sphere_volume(sphere);
|
||||
expect = tess_volume(tesses[i]);
|
||||
sprintf(msg, "(tess %d) expected volume %g, got %g", i, expect, res);
|
||||
mu_assert_almost_equals(res/expect, 1., 0.01, msg);
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
static char * test_prism2sphere()
|
||||
{
|
||||
double expect, res;
|
||||
SPHERE sphere;
|
||||
int i;
|
||||
PRISM prisms[4] = {
|
||||
{1,0,1000,0,2000,100,2000,0,0,0},
|
||||
{1,-500,200,300,500,-1000,4000,0,0,0},
|
||||
{1,-10000000,5000000,5000000,8000000,0,3000000,0,0,0},
|
||||
{1,-1000000,50000,500000,800000,0,300000,0,0,0}};
|
||||
|
||||
for(i = 0; i < 4; i++)
|
||||
{
|
||||
prism2sphere(prisms[i], 0., 0., 0., &sphere);
|
||||
res = sphere_volume(sphere);
|
||||
expect = prism_volume(prisms[i]);
|
||||
sprintf(msg, "(prism %d) expected volume %g, got %g", i, expect, res);
|
||||
mu_assert_almost_equals(res/expect, 1., 0.001, msg);
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
int geometry_run_all()
|
||||
{
|
||||
int failed = 0;
|
||||
failed += mu_run_test(test_prism_volume, "prism_volume return correct results");
|
||||
failed += mu_run_test(test_tess_volume, "tess_volume return correct results");
|
||||
failed += mu_run_test(test_tess_total_mass, "tess_total_mass returns correct result");
|
||||
failed += mu_run_test(test_tess_range_mass, "tess_range_mass returns correct result");
|
||||
failed += mu_run_test(test_tess2prism, "tess2prism produces prism with right volume");
|
||||
failed += mu_run_test(test_tess2prism_flatten,
|
||||
"tess2prism_flatten produces prism with right mass");
|
||||
failed += mu_run_test(test_tess2sphere,
|
||||
"tess2sphere produces sphere with right volume");
|
||||
failed += mu_run_test(test_prism2sphere,
|
||||
"prism2sphere produces sphere with right volume");
|
||||
failed += mu_run_test(test_split_tess, "split_tess returns correct results for 2, 2, 2 split");
|
||||
failed += mu_run_test(test_split_uneven_tess, "split_tess returns correct results for 2, 2, 1 split");
|
||||
return failed;
|
||||
}
|
||||
514
test/test_glq.c
Executable file
514
test/test_glq.c
Executable file
@@ -0,0 +1,514 @@
|
||||
/*
|
||||
Unit tests for GLQ functions.
|
||||
*/
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <math.h>
|
||||
#include "minunit.h"
|
||||
#include "../lib/glq.h"
|
||||
#include "../lib/constants.h"
|
||||
|
||||
/* Test data taken from:
|
||||
http://mathworld.wolfram.com/Legendre-GaussQuadrature.html */
|
||||
double o2roots[2] = {-0.577350269, 0.577350269},
|
||||
o3roots[3] = {-0.774596669, 0., 0.774596669},
|
||||
o4roots[4] = {-0.861136312, -0.339981044, 0.339981044, 0.861136312},
|
||||
o5roots[5] = {-0.906179846, -0.53846931, 0., 0.53846931, 0.906179846},
|
||||
o19roots[19] = {-0.992406843843584350,
|
||||
-0.960208152134830020,
|
||||
-0.903155903614817900,
|
||||
-0.822714656537142820,
|
||||
-0.720966177335229390,
|
||||
-0.600545304661680990,
|
||||
-0.464570741375960940,
|
||||
-0.316564099963629830,
|
||||
-0.160358645640225370,
|
||||
0.000000000000000000,
|
||||
0.160358645640225370,
|
||||
0.316564099963629830,
|
||||
0.464570741375960940,
|
||||
0.600545304661680990,
|
||||
0.720966177335229390,
|
||||
0.822714656537142820,
|
||||
0.903155903614817900,
|
||||
0.960208152134830020,
|
||||
0.992406843843584350};
|
||||
|
||||
double o2weights[2] = {1., 1.},
|
||||
o3weights[3] = {0.555555556, 0.888888889, 0.555555556},
|
||||
o4weights[4] = {0.347854845, 0.652145155, 0.652145155, 0.347854845},
|
||||
o5weights[5] = {0.236926885, 0.47862867, 0.568888889, 0.47862867,
|
||||
0.236926885};
|
||||
|
||||
/* To store fail messages */
|
||||
char msg[1000];
|
||||
|
||||
/* UNIT TESTS */
|
||||
|
||||
static char * test_glq_next_root_fail()
|
||||
{
|
||||
double roots[10];
|
||||
int i, order, rc;
|
||||
|
||||
/* Test order fail */
|
||||
i = 1;
|
||||
order = -1;
|
||||
rc = glq_next_root(0.5, i, order, roots);
|
||||
sprintf(msg, "(order %d) return code %d, expected 1", order, rc);
|
||||
mu_assert(rc == 1, msg);
|
||||
|
||||
order = 0;
|
||||
rc = glq_next_root(-0.1, i, order, roots);
|
||||
sprintf(msg, "(order %d) return code %d, expected 1", order, rc);
|
||||
mu_assert(rc == 1, msg);
|
||||
|
||||
order = 1;
|
||||
rc = glq_next_root(1.1, i, order, roots);
|
||||
sprintf(msg, "(order %d) return code %d, expected 1", order, rc);
|
||||
mu_assert(rc == 1, msg);
|
||||
|
||||
/* Test index fail */
|
||||
order = 5;
|
||||
i = -1;
|
||||
rc = glq_next_root(0.5, i, order, roots);
|
||||
sprintf(msg, "(index %d, order %d) return code %d, expected 2", order, i,
|
||||
rc);
|
||||
mu_assert(rc == 2, msg);
|
||||
|
||||
i = 5;
|
||||
rc = glq_next_root(0.5, i, order, roots);
|
||||
sprintf(msg, "(index %d, order %d) return code %d, expected 2", order, i,
|
||||
rc);
|
||||
mu_assert(rc == 2, msg);
|
||||
|
||||
i = 10;
|
||||
rc = glq_next_root(0.5, i, order, roots);
|
||||
sprintf(msg, "(index %d, order %d) return code %d, expected 2", order, i,
|
||||
rc);
|
||||
mu_assert(rc == 2, msg);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
static char * test_glq_next_root()
|
||||
{
|
||||
double prec = pow(10, -9), root[19], initial;
|
||||
int rc, i, order;
|
||||
|
||||
/* Test order 2 */
|
||||
order = 2;
|
||||
for(i = 0; i < order; i++)
|
||||
{
|
||||
initial = cos(PI*((order - i) - 0.25)/(order + 0.5));
|
||||
|
||||
rc = glq_next_root(initial, i, order, root);
|
||||
|
||||
sprintf(msg, "(order %d, root %d) return code %d, expected 0", order, i,
|
||||
rc);
|
||||
mu_assert(rc == 0, msg);
|
||||
|
||||
sprintf(msg, "(order %d, root %d) expected %.15f got %.15f", order, i,
|
||||
o2roots[i], root[i]);
|
||||
mu_assert_almost_equals(root[i], o2roots[i], prec, msg);
|
||||
}
|
||||
|
||||
/* Test order 3 */
|
||||
order = 3;
|
||||
for(i = 0; i < order; i++)
|
||||
{
|
||||
initial = cos(PI*((order - i) - 0.25)/(order + 0.5));
|
||||
|
||||
rc = glq_next_root(initial, i, order, root);
|
||||
|
||||
sprintf(msg, "(order %d, root %d) return code %d, expected 0", order, i,
|
||||
rc);
|
||||
mu_assert(rc == 0, msg);
|
||||
|
||||
sprintf(msg, "(order %d, root %d) expected %.15f got %.15f", order, i,
|
||||
o3roots[i], root[i]);
|
||||
mu_assert_almost_equals(root[i], o3roots[i], prec, msg);
|
||||
}
|
||||
|
||||
/* Test order 4 */
|
||||
order = 4;
|
||||
for(i = 0; i < order; i++)
|
||||
{
|
||||
initial = cos(PI*((order - i) - 0.25)/(order + 0.5));
|
||||
|
||||
rc = glq_next_root(initial, i, order, root);
|
||||
|
||||
sprintf(msg, "(order %d, root %d) return code %d, expected 0", order, i,
|
||||
rc);
|
||||
mu_assert(rc == 0, msg);
|
||||
|
||||
sprintf(msg, "(order %d, root %d) expected %.15f got %.15f", order, i,
|
||||
o4roots[i], root[i]);
|
||||
mu_assert_almost_equals(root[i], o4roots[i], prec, msg);
|
||||
}
|
||||
|
||||
/* Test order 5 */
|
||||
order = 5;
|
||||
for(i = 0; i < order; i++)
|
||||
{
|
||||
initial = cos(PI*((order - i) - 0.25)/(order + 0.5));
|
||||
|
||||
rc = glq_next_root(initial, i, order, root);
|
||||
|
||||
sprintf(msg, "(order %d, root %d) return code %d, expected 0", order, i,
|
||||
rc);
|
||||
mu_assert(rc == 0, msg);
|
||||
|
||||
sprintf(msg, "(order %d, root %d) expected %.15f got %.15f", order, i,
|
||||
o5roots[i], root[i]);
|
||||
mu_assert_almost_equals(root[i], o5roots[i], prec, msg);
|
||||
}
|
||||
|
||||
/* Test order 19 */
|
||||
order = 19;
|
||||
for(i = 0; i < order; i++)
|
||||
{
|
||||
initial = cos(PI*((order - i) - 0.25)/(order + 0.5));
|
||||
|
||||
rc = glq_next_root(initial, i, order, root);
|
||||
|
||||
sprintf(msg, "(order %d, root %d) return code %d, expected 0", order, i,
|
||||
rc);
|
||||
mu_assert(rc == 0, msg);
|
||||
|
||||
sprintf(msg, "(order %d, root %d) expected %.15f got %.15f", order, i,
|
||||
o19roots[i], root[i]);
|
||||
mu_assert_almost_equals(root[i], o19roots[i], prec, msg);
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
static char * test_glq_weights()
|
||||
{
|
||||
double prec = pow(10, -9), weights[5];
|
||||
int rc, i, order;
|
||||
|
||||
/* Test order 2 */
|
||||
order = 2;
|
||||
|
||||
rc = glq_weights(order, o2roots, weights);
|
||||
|
||||
sprintf(msg, "(order %d) return code %d, expected 0", order, rc);
|
||||
mu_assert(rc == 0, msg);
|
||||
|
||||
for(i = 0; i < order; i++)
|
||||
{
|
||||
sprintf(msg, "(order %d, weight %d) expected %.15f got %.15f", order,
|
||||
i, o2weights[i], weights[i]);
|
||||
mu_assert_almost_equals(weights[i], o2weights[i], prec, msg);
|
||||
}
|
||||
|
||||
/* Test order 3 */
|
||||
order = 3;
|
||||
|
||||
rc = glq_weights(order, o3roots, weights);
|
||||
|
||||
sprintf(msg, "(order %d) return code %d, expected 0", order, rc);
|
||||
mu_assert(rc == 0, msg);
|
||||
|
||||
for(i = 0; i < order; i++)
|
||||
{
|
||||
sprintf(msg, "(order %d, weight %d) expected %.15f got %.15f", order,
|
||||
i, o3weights[i], weights[i]);
|
||||
mu_assert_almost_equals(weights[i], o3weights[i], prec, msg);
|
||||
}
|
||||
|
||||
/* Test order 4 */
|
||||
order = 4;
|
||||
|
||||
rc = glq_weights(order, o4roots, weights);
|
||||
|
||||
sprintf(msg, "(order %d) return code %d, expected 0", order, rc);
|
||||
mu_assert(rc == 0, msg);
|
||||
|
||||
for(i = 0; i < order; i++)
|
||||
{
|
||||
sprintf(msg, "(order %d, weight %d) expected %.15f got %.15f", order,
|
||||
i, o4weights[i], weights[i]);
|
||||
mu_assert_almost_equals(weights[i], o4weights[i], prec, msg);
|
||||
}
|
||||
|
||||
/* Test order 5 */
|
||||
order = 5;
|
||||
|
||||
rc = glq_weights(order, o5roots, weights);
|
||||
|
||||
sprintf(msg, "(order %d) return code %d, expected 0", order, rc);
|
||||
mu_assert(rc == 0, msg);
|
||||
|
||||
for(i = 0; i < order; i++)
|
||||
{
|
||||
sprintf(msg, "(order %d, weight %d) expected %.15f got %.15f", order,
|
||||
i, o5weights[i], weights[i]);
|
||||
mu_assert_almost_equals(weights[i], o5weights[i], prec, msg);
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
static char * test_glq_nodes()
|
||||
{
|
||||
double prec = pow(10, -9), nodes[19];
|
||||
int rc, i, order;
|
||||
|
||||
/* Test order 2 */
|
||||
order = 2;
|
||||
|
||||
rc = glq_nodes(order, nodes);
|
||||
|
||||
sprintf(msg, "(order %d) return code %d, expected 0", order, rc);
|
||||
mu_assert(rc == 0, msg);
|
||||
|
||||
for(i = 0; i < order; i++)
|
||||
{
|
||||
sprintf(msg, "(order %d, node %d) expected %.15f got %.15f", order,
|
||||
i, o2roots[i], nodes[i]);
|
||||
mu_assert_almost_equals(nodes[i], o2roots[i], prec, msg);
|
||||
}
|
||||
|
||||
/* Test order 3 */
|
||||
order = 3;
|
||||
|
||||
rc = glq_nodes(order, nodes);
|
||||
|
||||
sprintf(msg, "(order %d) return code %d, expected 0", order, rc);
|
||||
mu_assert(rc == 0, msg);
|
||||
|
||||
for(i = 0; i < order; i++)
|
||||
{
|
||||
sprintf(msg, "(order %d, node %d) expected %.15f got %.15f", order,
|
||||
i, o3roots[i], nodes[i]);
|
||||
mu_assert_almost_equals(nodes[i], o3roots[i], prec, msg);
|
||||
}
|
||||
|
||||
/* Test order 4 */
|
||||
order = 4;
|
||||
|
||||
rc = glq_nodes(order, nodes);
|
||||
|
||||
sprintf(msg, "(order %d) return code %d, expected 0", order, rc);
|
||||
mu_assert(rc == 0, msg);
|
||||
|
||||
for(i = 0; i < order; i++)
|
||||
{
|
||||
sprintf(msg, "(order %d, node %d) expected %.15f got %.15f", order,
|
||||
i, o4roots[i], nodes[i]);
|
||||
mu_assert_almost_equals(nodes[i], o4roots[i], prec, msg);
|
||||
}
|
||||
|
||||
/* Test order 5 */
|
||||
order = 5;
|
||||
|
||||
rc = glq_nodes(order, nodes);
|
||||
|
||||
sprintf(msg, "(order %d) return code %d, expected 0", order, rc);
|
||||
mu_assert(rc == 0, msg);
|
||||
|
||||
for(i = 0; i < order; i++)
|
||||
{
|
||||
sprintf(msg, "(order %d, node %d) expected %.15f got %.15f", order,
|
||||
i, o5roots[i], nodes[i]);
|
||||
mu_assert_almost_equals(nodes[i], o5roots[i], prec, msg);
|
||||
}
|
||||
|
||||
/* Test order 19 */
|
||||
order = 19;
|
||||
|
||||
rc = glq_nodes(order, nodes);
|
||||
|
||||
sprintf(msg, "(order %d) return code %d, expected 0", order, rc);
|
||||
mu_assert(rc == 0, msg);
|
||||
|
||||
for(i = 0; i < order; i++)
|
||||
{
|
||||
sprintf(msg, "(order %d, node %d) expected %.15f got %.15f", order,
|
||||
i, o19roots[i], nodes[i]);
|
||||
mu_assert_almost_equals(nodes[i], o19roots[i], prec, msg);
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
static char * test_glq_set_limits()
|
||||
{
|
||||
double prec = pow(10, -9), unscaled[5], scaled[5], a, b, correct;
|
||||
int rc, i;
|
||||
GLQ glq;
|
||||
|
||||
glq.nodes_unscaled = unscaled;
|
||||
glq.nodes = scaled;
|
||||
|
||||
glq.order = 2;
|
||||
a = -2.54;
|
||||
b = 14.9;
|
||||
mu_arraycp(o2roots, glq.nodes_unscaled, glq.order);
|
||||
|
||||
rc = glq_set_limits(a, b, &glq);
|
||||
sprintf(msg, "(order %d, a %g, b %g) return code %d, expected 0", glq.order,
|
||||
a, b, rc);
|
||||
mu_assert(rc == 0, msg);
|
||||
|
||||
for(i = 0; i < glq.order; i++)
|
||||
{
|
||||
correct = 8.72*o2roots[i] + 6.18;
|
||||
sprintf(msg,
|
||||
"(order %d, index %d, a %g, b %g) expected %.15f, got %.15f",
|
||||
glq.order, i, a, b, correct, glq.nodes[i]);
|
||||
mu_assert_almost_equals(glq.nodes[i], correct, prec, msg);
|
||||
}
|
||||
|
||||
glq.order = 3;
|
||||
a = 125.6;
|
||||
b = 234.84;
|
||||
mu_arraycp(o3roots, glq.nodes_unscaled, glq.order);
|
||||
|
||||
rc = glq_set_limits(a, b, &glq);
|
||||
sprintf(msg, "(order %d, a %g, b %g) return code %d, expected 0", glq.order,
|
||||
a, b, rc);
|
||||
mu_assert(rc == 0, msg);
|
||||
|
||||
for(i = 0; i < glq.order; i++)
|
||||
{
|
||||
correct = 54.62*o3roots[i] + 180.22;
|
||||
sprintf(msg,
|
||||
"(order %d, index %d, a %g, b %g) expected %.15f, got %.15f",
|
||||
glq.order, i, a, b, correct, glq.nodes[i]);
|
||||
mu_assert_almost_equals(glq.nodes[i], correct, prec, msg);
|
||||
}
|
||||
|
||||
glq.order = 4;
|
||||
a = 3.5;
|
||||
b = -12.4;
|
||||
mu_arraycp(o4roots, glq.nodes_unscaled, glq.order);
|
||||
|
||||
rc = glq_set_limits(a, b, &glq);
|
||||
sprintf(msg, "(order %d, a %g, b %g) return code %d, expected 0", glq.order,
|
||||
a, b, rc);
|
||||
mu_assert(rc == 0, msg);
|
||||
|
||||
for(i = 0; i < glq.order; i++)
|
||||
{
|
||||
correct = -7.95*o4roots[i] - 4.45;
|
||||
sprintf(msg,
|
||||
"(order %d, index %d, a %g, b %g) expected %.15f, got %.15f",
|
||||
glq.order, i, a, b, correct, glq.nodes[i]);
|
||||
mu_assert_almost_equals(glq.nodes[i], correct, prec, msg);
|
||||
}
|
||||
|
||||
glq.order = 5;
|
||||
a = 0.0;
|
||||
b = 0.0;
|
||||
mu_arraycp(o5roots, glq.nodes_unscaled, glq.order);
|
||||
|
||||
rc = glq_set_limits(a, b, &glq);
|
||||
sprintf(msg, "(order %d, a %g, b %g) return code %d, expected 0", glq.order,
|
||||
a, b, rc);
|
||||
mu_assert(rc == 0, msg);
|
||||
|
||||
for(i = 0; i < glq.order; i++)
|
||||
{
|
||||
correct = 0.0;
|
||||
sprintf(msg,
|
||||
"(order %d, index %d, a %g, b %g) expected %.15f, got %.15f",
|
||||
glq.order, i, a, b, correct, glq.nodes[i]);
|
||||
mu_assert_almost_equals(glq.nodes[i], correct, prec, msg);
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
static char * test_glq_intcos()
|
||||
{
|
||||
double result, expected;
|
||||
double angles[6];
|
||||
int i, t, orders[6] = {2, 3, 5, 8, 15, 25};
|
||||
GLQ *glq;
|
||||
|
||||
angles[0] = PI*0.1;
|
||||
angles[1] = PI;
|
||||
angles[2] = PI*1.2;
|
||||
angles[3] = PI*1.9;
|
||||
angles[4] = PI*4.3;
|
||||
angles[5] = PI*6.9;
|
||||
|
||||
for(t = 0; t < 6; t++)
|
||||
{
|
||||
glq = glq_new(orders[t], 0., angles[t]);
|
||||
|
||||
if(glq == NULL)
|
||||
{
|
||||
sprintf(msg,
|
||||
"(order %d, angle %g) failed to create new GLQ struct",
|
||||
orders[t], angles[t]);
|
||||
mu_assert(0, msg);
|
||||
}
|
||||
|
||||
for(i = 0, result = 0; i < orders[t]; i++)
|
||||
{
|
||||
result += glq->weights[i]*cos(glq->nodes[i]);
|
||||
}
|
||||
result *= 0.5*angles[t];
|
||||
|
||||
expected = sin(angles[t]);
|
||||
|
||||
glq_free(glq);
|
||||
|
||||
sprintf(msg, "(order %d, angle %g) expected %f, got %f", orders[t],
|
||||
angles[t], expected, result);
|
||||
mu_assert_almost_equals(result, expected, pow(10, -5), msg);
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static char * test_glq_sincos()
|
||||
{
|
||||
GLQ *glq;
|
||||
int i;
|
||||
double result, d2r = PI/180.;
|
||||
|
||||
glq = glq_new(10, 0, 90);
|
||||
glq_precompute_sincos(glq);
|
||||
|
||||
for(i = 0; i < glq->order; i++)
|
||||
{
|
||||
result = sin(d2r*glq->nodes[i]);
|
||||
sprintf(msg, "expected sin(%g)=%g, got %g", glq->nodes[i], result,
|
||||
glq->nodes_sin[i]);
|
||||
mu_assert_almost_equals(result, glq->nodes_sin[i], pow(10, -15), msg);
|
||||
result = cos(d2r*glq->nodes[i]);
|
||||
sprintf(msg, "expected cos(%g)=%g, got %g", glq->nodes[i], result,
|
||||
glq->nodes_cos[i]);
|
||||
mu_assert_almost_equals(result, glq->nodes_cos[i], pow(10, -15), msg);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
int glq_run_all()
|
||||
{
|
||||
int failed = 0;
|
||||
failed += mu_run_test(test_glq_next_root_fail,
|
||||
"glq_next_root returns correct fail code");
|
||||
failed += mu_run_test(test_glq_next_root, "glq_next_root produces correct results");
|
||||
failed += mu_run_test(test_glq_nodes, "glq_nodes produces correct results");
|
||||
failed += mu_run_test(test_glq_set_limits,
|
||||
"glq_set_limits produces correct results");
|
||||
failed += mu_run_test(test_glq_weights, "glq_weights produces correct results");
|
||||
failed += mu_run_test(test_glq_intcos,
|
||||
"glq cossine integration produces correct results");
|
||||
failed += mu_run_test(test_glq_sincos,
|
||||
"glq precomputes sin and cos correctly");
|
||||
return failed;
|
||||
}
|
||||
888
test/test_grav_prism.c
Executable file
888
test/test_grav_prism.c
Executable file
@@ -0,0 +1,888 @@
|
||||
/*
|
||||
Unit tests for grav_prism.c functions.
|
||||
*/
|
||||
|
||||
#include <stdio.h>
|
||||
#include <math.h>
|
||||
#include "../lib/grav_sphere.h"
|
||||
#include "../lib/grav_prism.h"
|
||||
#include "../lib/geometry.h"
|
||||
#include "../lib/constants.h"
|
||||
|
||||
|
||||
char msg[1000];
|
||||
|
||||
int sign(double x)
|
||||
{
|
||||
if(x >= 0)
|
||||
{
|
||||
return 1;
|
||||
}
|
||||
else
|
||||
{
|
||||
return -1;
|
||||
}
|
||||
}
|
||||
|
||||
static char * test_safe_atan2_sign()
|
||||
{
|
||||
double res,
|
||||
y[] = {1, -1, 1, -1},
|
||||
x[] = {1, 1, -1, -1};
|
||||
register int i;
|
||||
|
||||
for(i = 0; i < 4; i++)
|
||||
{
|
||||
res = safe_atan2(y[i], x[i]);
|
||||
sprintf(msg, "safe_atan2=%g for y=%g x=%g", res, y[i], x[i]);
|
||||
mu_assert(sign(y[i]*x[i]) == sign(res), msg);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
static char * test_safe_atan2_zero()
|
||||
{
|
||||
double res,
|
||||
x[] = {1, -1, 0};
|
||||
register int i;
|
||||
for(i = 0; i < 3; i++)
|
||||
{
|
||||
res = safe_atan2(0, x[i]);
|
||||
sprintf(msg, "safe_atan2=%g for x=%g", res, x[i]);
|
||||
mu_assert(res == 0, msg);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
static char * test_pot_around()
|
||||
{
|
||||
PRISM prism = {1000,-3000,3000,-3000,3000,-3000,3000,0,0,0};
|
||||
double planes[6], dist = 5000, i, j;
|
||||
register int p, k;
|
||||
|
||||
for(i = -10000; i <= 10000; i += 100)
|
||||
{
|
||||
for(j = -10000; j <= 10000; j += 100)
|
||||
{
|
||||
planes[0] = prism_pot(prism, i, j, -dist);
|
||||
planes[1] = prism_pot(prism, i, j, dist);
|
||||
planes[2] = prism_pot(prism, -dist, i, j);
|
||||
planes[3] = prism_pot(prism, dist, i, j);
|
||||
planes[4] = prism_pot(prism, i, -dist, j);
|
||||
planes[5] = prism_pot(prism, i, dist, j);
|
||||
for(p = 0; p < 5; p++)
|
||||
{
|
||||
for(k = p + 1; k < 6; k++)
|
||||
{
|
||||
sprintf(msg, "point (%g, %g) on planes %d n %d = (%.8f %.8f)",
|
||||
i, j, p, k, planes[p], planes[k]);
|
||||
mu_assert_almost_equals(planes[p], planes[k], 10E-10, msg);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
static char * test_gx_around()
|
||||
{
|
||||
PRISM prism = {1000,-3000,3000,-3000,3000,-3000,3000,0,0,0};
|
||||
double gz, above, below, north, south, east, west, dist = 5000, i, j;
|
||||
|
||||
for(i = -10000; i <= 10000; i += 100)
|
||||
{
|
||||
for(j = -10000; j <= 10000; j += 100)
|
||||
{
|
||||
above = prism_gx(prism, i, j, -dist);
|
||||
below = prism_gx(prism, i, j, dist);
|
||||
north = prism_gx(prism, dist, i, j);
|
||||
south = prism_gx(prism, -dist, i, j);
|
||||
east = prism_gx(prism, i, dist, j);
|
||||
west = prism_gx(prism, i, -dist, j);
|
||||
gz = prism_gz(prism, i, j, -dist);
|
||||
sprintf(msg, "point (%g, %g) on planes %s n %s = (%.8f %.8f)",
|
||||
i, j, "above", "below", above, below);
|
||||
mu_assert_almost_equals(above, below, 10E-10, msg);
|
||||
sprintf(msg, "point (%g, %g) on planes %s n %s = (%.8f %.8f)",
|
||||
i, j, "north", "south", north, south);
|
||||
mu_assert_almost_equals(north, -south, 10E-10, msg);
|
||||
sprintf(msg, "point (%g, %g) on planes %s n %s = (%.8f %.8f)",
|
||||
i, j, "east", "west", east, west);
|
||||
mu_assert_almost_equals(east, west, 10E-10, msg);
|
||||
sprintf(msg, "point (%g, %g) on planes %s n %s = (%.8f %.8f)",
|
||||
i, j, "east", "above", east, above);
|
||||
mu_assert_almost_equals(east, above, 10E-10, msg);
|
||||
sprintf(msg, "point (%g, %g) on planes %s n %s = (%.8f %.8f)",
|
||||
i, j, "north", "gz", north, gz);
|
||||
mu_assert_almost_equals(north, -gz, 10E-10, msg);
|
||||
sprintf(msg, "point (%g, %g) on planes %s n %s = (%.8f %.8f)",
|
||||
i, j, "south", "gz", south, gz);
|
||||
mu_assert_almost_equals(south, gz, 10E-10, msg);
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
static char * test_gy_around()
|
||||
{
|
||||
PRISM prism = {1000,-3000,3000,-3000,3000,-3000,3000,0,0,0};
|
||||
double gz, above, below, north, south, east, west, dist = 5000, i, j;
|
||||
|
||||
for(i = -10000; i <= 10000; i += 100)
|
||||
{
|
||||
for(j = -10000; j <= 10000; j += 100)
|
||||
{
|
||||
above = prism_gy(prism, i, j, -dist);
|
||||
below = prism_gy(prism, i, j, dist);
|
||||
north = prism_gy(prism, dist, j, i);
|
||||
south = prism_gy(prism, -dist, j, i);
|
||||
east = prism_gy(prism, i, dist, j);
|
||||
west = prism_gy(prism, i, -dist, j);
|
||||
gz = prism_gz(prism, i, j, -dist);
|
||||
sprintf(msg, "point (%g, %g) on planes %s n %s = (%.8f %.8f)",
|
||||
i, j, "above", "below", above, below);
|
||||
mu_assert_almost_equals(above, below, 10E-10, msg);
|
||||
sprintf(msg, "point (%g, %g) on planes %s n %s = (%.8f %.8f)",
|
||||
i, j, "north", "south", north, south);
|
||||
mu_assert_almost_equals(north, south, 10E-10, msg);
|
||||
sprintf(msg, "point (%g, %g) on planes %s n %s = (%.8f %.8f)",
|
||||
i, j, "east", "west", east, west);
|
||||
mu_assert_almost_equals(east, -west, 10E-10, msg);
|
||||
sprintf(msg, "point (%g, %g) on planes %s n %s = (%.8f %.8f)",
|
||||
i, j, "north", "above", north, above);
|
||||
mu_assert_almost_equals(north, above, 10E-10, msg);
|
||||
sprintf(msg, "point (%g, %g) on planes %s n %s = (%.8f %.8f)",
|
||||
i, j, "east", "gz", east, gz);
|
||||
mu_assert_almost_equals(east, -gz, 10E-10, msg);
|
||||
sprintf(msg, "point (%g, %g) on planes %s n %s = (%.8f %.8f)",
|
||||
i, j, "west", "gz", west, gz);
|
||||
mu_assert_almost_equals(west, gz, 10E-10, msg);
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
static char * test_gz_around()
|
||||
{
|
||||
PRISM prism = {1000,-3000,3000,-3000,3000,-3000,3000,0,0,0};
|
||||
double gy, above, below, north, south, east, west, dist = 5000, i, j;
|
||||
|
||||
for(i = -10000; i <= 10000; i += 100)
|
||||
{
|
||||
for(j = -10000; j <= 10000; j += 100)
|
||||
{
|
||||
above = prism_gz(prism, i, j, -dist);
|
||||
below = prism_gz(prism, i, j, dist);
|
||||
north = prism_gz(prism, dist, i, j);
|
||||
south = prism_gz(prism, -dist, i, j);
|
||||
east = prism_gz(prism, i, dist, j);
|
||||
west = prism_gz(prism, i, -dist, j);
|
||||
gy = prism_gy(prism, i, j, -dist);
|
||||
sprintf(msg, "point (%g, %g) on planes %s n %s = (%.8f %.8f)",
|
||||
i, j, "above", "below", above, below);
|
||||
mu_assert_almost_equals(above, -below, 10E-10, msg);
|
||||
sprintf(msg, "point (%g, %g) on planes %s n %s = (%.8f %.8f)",
|
||||
i, j, "north", "south", north, south);
|
||||
mu_assert_almost_equals(north, south, 10E-10, msg);
|
||||
sprintf(msg, "point (%g, %g) on planes %s n %s = (%.8f %.8f)",
|
||||
i, j, "east", "west", east, west);
|
||||
mu_assert_almost_equals(east, west, 10E-10, msg);
|
||||
sprintf(msg, "point (%g, %g) on planes %s n %s = (%.8f %.8f)",
|
||||
i, j, "north", "gy", north, gy);
|
||||
mu_assert_almost_equals(north, gy, 10E-10, msg);
|
||||
sprintf(msg, "point (%g, %g) on planes %s n %s = (%.8f %.8f)",
|
||||
i, j, "south", "gy", south, gy);
|
||||
mu_assert_almost_equals(south, gy, 10E-10, msg);
|
||||
sprintf(msg, "point (%g, %g) on planes %s n %s = (%.8f %.8f)",
|
||||
i, j, "east", "gy", east, gy);
|
||||
mu_assert_almost_equals(east, gy, 10E-10, msg);
|
||||
sprintf(msg, "point (%g, %g) on planes %s n %s = (%.8f %.8f)",
|
||||
i, j, "west", "gy", west, gy);
|
||||
mu_assert_almost_equals(west, gy, 10E-10, msg);
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
static char * test_gxx_around()
|
||||
{
|
||||
PRISM prism = {1000,-3000,3000,-3000,3000,-3000,3000,0,0,0};
|
||||
double gzz, above, below, north, south, east, west, dist = 5000, i, j;
|
||||
|
||||
for(i = -10000; i <= 10000; i += 100)
|
||||
{
|
||||
for(j = -10000; j <= 10000; j += 100)
|
||||
{
|
||||
above = prism_gxx(prism, i, j, -dist);
|
||||
below = prism_gxx(prism, i, j, dist);
|
||||
north = prism_gxx(prism, dist, i, j);
|
||||
south = prism_gxx(prism, -dist, i, j);
|
||||
east = prism_gxx(prism, i, dist, j);
|
||||
west = prism_gxx(prism, i, -dist, j);
|
||||
gzz = prism_gzz(prism, i, j, -dist);
|
||||
sprintf(msg, "point (%g, %g) on planes %s n %s = (%.8f %.8f)",
|
||||
i, j, "above", "below", above, below);
|
||||
mu_assert_almost_equals(above, below, 10E-10, msg);
|
||||
sprintf(msg, "point (%g, %g) on planes %s n %s = (%.8f %.8f)",
|
||||
i, j, "north", "south", north, south);
|
||||
mu_assert_almost_equals(north, south, 10E-10, msg);
|
||||
sprintf(msg, "point (%g, %g) on planes %s n %s = (%.8f %.8f)",
|
||||
i, j, "east", "west", east, west);
|
||||
mu_assert_almost_equals(east, west, 10E-10, msg);
|
||||
sprintf(msg, "point (%g, %g) on planes %s n %s = (%.8f %.8f)",
|
||||
i, j, "east", "above", east, above);
|
||||
mu_assert_almost_equals(east, above, 10E-10, msg);
|
||||
sprintf(msg, "point (%g, %g) on planes %s n %s = (%.8f %.8f)",
|
||||
i, j, "north", "gzz", north, gzz);
|
||||
mu_assert_almost_equals(north, gzz, 10E-10, msg);
|
||||
sprintf(msg, "point (%g, %g) on planes %s n %s = (%.8f %.8f)",
|
||||
i, j, "south", "gzz", south, gzz);
|
||||
mu_assert_almost_equals(south, gzz, 10E-10, msg);
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
static char * test_gxy_around()
|
||||
{
|
||||
PRISM prism = {1000, -3000, 3000, -3000, 3000, -3000, 3000, 0, 0, 0};
|
||||
double gyz, above, below, north, south, east, west, dist = 5000, i, j;
|
||||
|
||||
for(i = -10000; i <= 10000; i += 100)
|
||||
{
|
||||
for(j = -10000; j <= 10000; j += 100)
|
||||
{
|
||||
above = prism_gxy(prism, i, j, -dist);
|
||||
below = prism_gxy(prism, i, j, dist);
|
||||
north = prism_gxy(prism, dist, j, i);
|
||||
south = prism_gxy(prism, -dist, j, i);
|
||||
east = prism_gxy(prism, j, dist, i);
|
||||
west = prism_gxy(prism, j, -dist, i);
|
||||
gyz = prism_gyz(prism, i, j, -dist);
|
||||
sprintf(msg, " p (%g %g %g) on planes %s n %s = (%.15f n %.15f)",
|
||||
i, j, dist, "above", "below", above, below);
|
||||
mu_assert_almost_equals(above, below, 1e-5, msg);
|
||||
sprintf(msg, " p (%g %g %g) on planes %s n %s = (%.15f n %.15f)",
|
||||
i, j, dist, "north", "south", north, south);
|
||||
mu_assert_almost_equals(north, -south, 1e-5, msg);
|
||||
sprintf(msg, " p (%g %g %g) on planes %s n %s = (%.15f n %.15f)",
|
||||
i, j, dist, "east", "west", east, west);
|
||||
mu_assert_almost_equals(east, -west, 1e-5, msg);
|
||||
sprintf(msg, " p (%g %g %g) on planes %s n %s = (%.15f n %.15f)",
|
||||
i, j, dist, "east", "north", east, north);
|
||||
mu_assert_almost_equals(east, north, 1e-5, msg);
|
||||
sprintf(msg, " p (%g %g %g) on planes %s n %s = (%.15f n %.15f)",
|
||||
i, j, dist, "west", "south", west, south);
|
||||
mu_assert_almost_equals(west, south, 1e-5, msg);
|
||||
sprintf(msg, " p (%g %g %g) on planes %s n %s = (%.15f n %.15f)",
|
||||
i, j, dist, "north", "gyz", north, gyz);
|
||||
mu_assert_almost_equals(north, -gyz, 1e-5, msg);
|
||||
sprintf(msg, " p (%g %g %g) on planes %s n %s = (%.15f n %.15f)",
|
||||
i, j, dist, "south", "gyz", south, gyz);
|
||||
mu_assert_almost_equals(south, gyz, 1e-5, msg);
|
||||
}
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static char * test_gxz_around()
|
||||
{
|
||||
PRISM prism = {3000, -3000, 3000, -3000, 3000, -3000, 3000, 0, 0, 0};
|
||||
double other, above, below, north, south, east, west, dist = 5000, i, j;
|
||||
|
||||
for(i = -10000; i <= 10000; i += 100)
|
||||
{
|
||||
for(j = -10000; j <= 10000; j += 100)
|
||||
{
|
||||
above = prism_gxz(prism, i, j, -dist);
|
||||
below = prism_gxz(prism, i, j, dist);
|
||||
north = prism_gxz(prism, dist, j, i);
|
||||
south = prism_gxz(prism, -dist, j, i);
|
||||
east = prism_gxz(prism, i, dist, j);
|
||||
west = prism_gxz(prism, i, -dist, j);
|
||||
other = prism_gxy(prism, i, j, -dist);
|
||||
sprintf(msg, " p (%g %g %g) on planes %s n %s = (%.15f %.15f)",
|
||||
i, j, dist, "above", "below", above, below);
|
||||
mu_assert_almost_equals(above, -below, 1e-5, msg);
|
||||
sprintf(msg, " p (%g %g %g) on planes %s n %s = (%.15f %.15f)",
|
||||
i, j, dist, "north", "south", north, south);
|
||||
mu_assert_almost_equals(north, -south, 1e-5, msg);
|
||||
sprintf(msg, " p (%g %g %g) on planes %s n %s = (%.15f %.15f)",
|
||||
i, j, dist, "east", "west", east, west);
|
||||
mu_assert_almost_equals(east, west, 1e-5, msg);
|
||||
sprintf(msg, " p (%g %g %g) on planes %s n %s = (%.15f %.15f)",
|
||||
i, j, dist, "below", "north", below, north);
|
||||
mu_assert_almost_equals(below, north, 1e-5, msg);
|
||||
sprintf(msg, " p (%g %g %g) on planes %s n %s = (%.15f %.15f)",
|
||||
i, j, dist, "above", "south", above, south);
|
||||
mu_assert_almost_equals(above, south, 1e-5, msg);
|
||||
sprintf(msg, " p (%g %g %g) on planes %s n %s = (%.15f %.15f)",
|
||||
i, j, dist, "east", "gxy", east, other);
|
||||
mu_assert_almost_equals(east, other, 1e-5, msg);
|
||||
sprintf(msg, " p (%g %g %g) on planes %s n %s = (%.15f %.15f)",
|
||||
i, j, dist, "west", "gxy", west, other);
|
||||
mu_assert_almost_equals(west, other, 1e-5, msg);
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
static char * test_gyy_around()
|
||||
{
|
||||
PRISM prism = {1000,-3000,3000,-3000,3000,-3000,3000,0,0,0};
|
||||
double other, above, below, north, south, east, west, dist = 5000, i, j;
|
||||
|
||||
for(i = -10000; i <= 10000; i += 100)
|
||||
{
|
||||
for(j = -10000; j <= 10000; j += 100)
|
||||
{
|
||||
above = prism_gyy(prism, i, j, -dist);
|
||||
below = prism_gyy(prism, i, j, dist);
|
||||
north = prism_gyy(prism, dist, j, i);
|
||||
south = prism_gyy(prism, -dist, j, i);
|
||||
east = prism_gyy(prism, i, dist, j);
|
||||
west = prism_gyy(prism, i, -dist, j);
|
||||
other = prism_gzz(prism, i, j, -dist);
|
||||
sprintf(msg, "point (%g, %g) on planes %s n %s = (%.8f %.8f)",
|
||||
i, j, "above", "below", above, below);
|
||||
mu_assert_almost_equals(above, below, 10E-10, msg);
|
||||
sprintf(msg, "point (%g, %g) on planes %s n %s = (%.8f %.8f)",
|
||||
i, j, "north", "south", north, south);
|
||||
mu_assert_almost_equals(north, south, 10E-10, msg);
|
||||
sprintf(msg, "point (%g, %g) on planes %s n %s = (%.8f %.8f)",
|
||||
i, j, "east", "west", east, west);
|
||||
mu_assert_almost_equals(east, west, 10E-10, msg);
|
||||
sprintf(msg, "point (%g, %g) on planes %s n %s = (%.8f %.8f)",
|
||||
i, j, "above", "north", above, north);
|
||||
mu_assert_almost_equals(above, north, 10E-10, msg);
|
||||
sprintf(msg, "point (%g, %g) on planes %s n %s = (%.8f %.8f)",
|
||||
i, j, "east", "gzz", east, other);
|
||||
mu_assert_almost_equals(east, other, 10E-10, msg);
|
||||
sprintf(msg, "point (%g, %g) on planes %s n %s = (%.8f %.8f)",
|
||||
i, j, "west", "gzz", west, other);
|
||||
mu_assert_almost_equals(west, other, 10E-10, msg);
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
static char * test_gyz_around()
|
||||
{
|
||||
PRISM prism = {1000, -3000, 3000, -3000, 3000, -3000, 3000, 0, 0, 0};
|
||||
double other, above, below, north, south, east, west, dist = 5000, i, j;
|
||||
|
||||
for(i = -10000; i <= 10000; i += 100)
|
||||
{
|
||||
for(j = -10000; j <= 10000; j += 100)
|
||||
{
|
||||
above = prism_gyz(prism, i, j, -dist);
|
||||
below = prism_gyz(prism, i, j, dist);
|
||||
north = prism_gyz(prism, dist, j, i);
|
||||
south = prism_gyz(prism, -dist, j, i);
|
||||
east = prism_gyz(prism, i, dist, j);
|
||||
west = prism_gyz(prism, i, -dist, j);
|
||||
other = prism_gxy(prism, i, j, -dist);
|
||||
sprintf(msg, "point (%g, %g) on planes %s n %s = (%.8f %.8f)",
|
||||
i, j, "above", "below", above, below);
|
||||
mu_assert_almost_equals(above, -below, 1e-5, msg);
|
||||
sprintf(msg, "point (%g, %g) on planes %s n %s = (%.8f %.8f)",
|
||||
i, j, "north", "south", north, south);
|
||||
mu_assert_almost_equals(north, south, 1e-5, msg);
|
||||
sprintf(msg, "point (%g, %g) on planes %s n %s = (%.8f %.8f)",
|
||||
i, j, "east", "west", east, west);
|
||||
mu_assert_almost_equals(east, -west, 1e-5, msg);
|
||||
sprintf(msg, "point (%g, %g) on planes %s n %s = (%.8f %.8f)",
|
||||
i, j, "below", "east", below, east);
|
||||
mu_assert_almost_equals(below, east, 1e-5, msg);
|
||||
sprintf(msg, "point (%g, %g) on planes %s n %s = (%.8f %.8f)",
|
||||
i, j, "above", "west", above, west);
|
||||
mu_assert_almost_equals(above, west, 1e-5, msg);
|
||||
sprintf(msg, "point (%g, %g) on planes %s n %s = (%.8f %.8f)",
|
||||
i, j, "north", "gxy", north, other);
|
||||
mu_assert_almost_equals(north, other, 1e-5, msg);
|
||||
sprintf(msg, "point (%g, %g) on planes %s n %s = (%.8f %.8f)",
|
||||
i, j, "south", "gxy", south, other);
|
||||
mu_assert_almost_equals(south, other, 1e-5, msg);
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
static char * test_gzz_around()
|
||||
{
|
||||
PRISM prism = {1000,-3000,3000,-3000,3000,-3000,3000,0,0,0};
|
||||
double other, above, below, north, south, east, west, dist = 5000, i, j;
|
||||
|
||||
for(i = -10000; i <= 10000; i += 100)
|
||||
{
|
||||
for(j = -10000; j <= 10000; j += 100)
|
||||
{
|
||||
above = prism_gzz(prism, i, j, -dist);
|
||||
below = prism_gzz(prism, i, j, dist);
|
||||
north = prism_gzz(prism, dist, i, j);
|
||||
south = prism_gzz(prism, -dist, i, j);
|
||||
east = prism_gzz(prism, i, dist, j);
|
||||
west = prism_gzz(prism, i, -dist, j);
|
||||
other = prism_gyy(prism, i, j, -dist);
|
||||
sprintf(msg, "point (%g, %g) on planes %s n %s = (%.8f %.8f)",
|
||||
i, j, "above", "below", above, below);
|
||||
mu_assert_almost_equals(above, below, 10E-10, msg);
|
||||
sprintf(msg, "point (%g, %g) on planes %s n %s = (%.8f %.8f)",
|
||||
i, j, "north", "south", north, south);
|
||||
mu_assert_almost_equals(north, south, 10E-10, msg);
|
||||
sprintf(msg, "point (%g, %g) on planes %s n %s = (%.8f %.8f)",
|
||||
i, j, "east", "west", east, west);
|
||||
mu_assert_almost_equals(east, west, 10E-10, msg);
|
||||
sprintf(msg, "point (%g, %g) on planes %s n %s = (%.8f %.8f)",
|
||||
i, j, "north", "east", north, east);
|
||||
mu_assert_almost_equals(north, east, 10E-10, msg);
|
||||
sprintf(msg, "point (%g, %g) on planes %s n %s = (%.8f %.8f)",
|
||||
i, j, "north", "gyy", north, other);
|
||||
mu_assert_almost_equals(north, other, 10E-10, msg);
|
||||
sprintf(msg, "point (%g, %g) on planes %s n %s = (%.8f %.8f)",
|
||||
i, j, "south", "gyy", south, other);
|
||||
mu_assert_almost_equals(south, other, 10E-10, msg);
|
||||
sprintf(msg, "point (%g, %g) on planes %s n %s = (%.8f %.8f)",
|
||||
i, j, "east", "gyy", east, other);
|
||||
mu_assert_almost_equals(east, other, 10E-10, msg);
|
||||
sprintf(msg, "point (%g, %g) on planes %s n %s = (%.8f %.8f)",
|
||||
i, j, "west", "gyy", west, other);
|
||||
mu_assert_almost_equals(west, other, 10E-10, msg);
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
static char * test_gxx_below()
|
||||
{
|
||||
PRISM prism = {3000,-5000,5000,-5000,5000,-5000,5000,0,0,0};
|
||||
double dist, restop, resbelow;
|
||||
|
||||
for(dist=5010; dist <= 500000; dist += 100)
|
||||
{
|
||||
restop = prism_gxx(prism, 0, 0,-dist);
|
||||
resbelow = prism_gxx(prism, 0, 0, dist);
|
||||
|
||||
sprintf(msg, "(distance %g m) top = %.5f below = %.5f", dist,
|
||||
restop, resbelow);
|
||||
mu_assert_almost_equals(resbelow, restop, 0.1, msg);
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static char * test_gxy_below()
|
||||
{
|
||||
PRISM prism = {3000,-5000,5000,-5000,5000,-5000,5000,0,0,0};
|
||||
double dist, restop, resbelow;
|
||||
|
||||
for(dist=5010; dist <= 500000; dist += 100)
|
||||
{
|
||||
restop = prism_gxy(prism, 5000, 5000, -dist);
|
||||
resbelow = prism_gxy(prism, 5000, 5000, dist);
|
||||
|
||||
sprintf(msg, "(distance %g m) top = %.5f below = %.5f", dist,
|
||||
restop, resbelow);
|
||||
mu_assert_almost_equals(resbelow, restop, 1, msg);
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static char * test_gxz_below()
|
||||
{
|
||||
PRISM prism = {3000,-5000,5000,-5000,5000,-5000,5000,0,0,0};
|
||||
double dist, restop, resbelow;
|
||||
|
||||
for(dist=5010; dist <= 500000; dist += 100)
|
||||
{
|
||||
restop = prism_gxz(prism, 5000, 0,-dist);
|
||||
resbelow = prism_gxz(prism, 5000, 0, dist);
|
||||
|
||||
sprintf(msg, "(distance %g m) top = %.5f below = %.5f", dist,
|
||||
restop, resbelow);
|
||||
mu_assert_almost_equals(resbelow, -restop, 0.1, msg);
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static char * test_gyy_below()
|
||||
{
|
||||
PRISM prism = {3000,-5000,5000,-5000,5000,-5000,5000,0,0,0};
|
||||
double dist, restop, resbelow;
|
||||
|
||||
for(dist=5010; dist <= 500000; dist += 100)
|
||||
{
|
||||
restop = prism_gyy(prism, 0, 0,-dist);
|
||||
resbelow = prism_gyy(prism, 0, 0, dist);
|
||||
|
||||
sprintf(msg, "(distance %g m) top = %.5f below = %.5f", dist,
|
||||
restop, resbelow);
|
||||
mu_assert_almost_equals_rel(resbelow, restop, 1, msg);
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static char * test_gyz_below()
|
||||
{
|
||||
PRISM prism = {3000,-5000,5000,-5000,5000,-5000,5000,0,0,0};
|
||||
double dist, restop, resbelow;
|
||||
|
||||
for(dist=5010; dist <= 500000; dist += 100)
|
||||
{
|
||||
restop = prism_gyz(prism, 0, 5000, -dist);
|
||||
resbelow = prism_gyz(prism, 0, 5000, dist);
|
||||
|
||||
sprintf(msg, "(distance %g m) top = %.5f below = %.5f", dist,
|
||||
restop, resbelow);
|
||||
mu_assert_almost_equals(resbelow, -restop, 0.1, msg);
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static char * test_gzz_below()
|
||||
{
|
||||
PRISM prism = {3000,-5000,5000,-5000,5000,-5000,5000,0,0,0};
|
||||
double dist, restop, resbelow;
|
||||
|
||||
for(dist=5010; dist <= 500000; dist += 100)
|
||||
{
|
||||
restop = prism_gzz(prism, 0, 0, -dist);
|
||||
resbelow = prism_gzz(prism, 0, 0, dist);
|
||||
|
||||
sprintf(msg, "(distance %g m) top = %.5f below = %.5f", dist,
|
||||
restop, resbelow);
|
||||
mu_assert_almost_equals(resbelow, restop, 0.1, msg);
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static char * test_prism2sphere_pot()
|
||||
{
|
||||
SPHERE sphere;
|
||||
PRISM prism = {3000,-5000,5000,-5000,5000,-5000,5000,0,0,0};
|
||||
double dist, resprism, ressphere;
|
||||
|
||||
/* Make a sphere with the same mass as the prism and put it at the origin */
|
||||
prism2sphere(prism, 0, 0, 0, &sphere);
|
||||
|
||||
for(dist=50000; dist <= 500000; dist += 500)
|
||||
{
|
||||
resprism = prism_pot(prism,0,0,-dist);
|
||||
ressphere = sphere_pot(sphere,0,90,dist);
|
||||
|
||||
sprintf(msg, "(distance %g m) prism = %.5f sphere = %.5f", dist,
|
||||
resprism, ressphere);
|
||||
mu_assert_almost_equals(resprism, ressphere, 0.001, msg);
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static char * test_prism2sphere_gx()
|
||||
{
|
||||
SPHERE sphere;
|
||||
PRISM prism = {3000,-5000,5000,-5000,5000,-5000,5000,0,0,0};
|
||||
double dist, resprism, ressphere;
|
||||
|
||||
/* Make a sphere with the same mass as the prism and put it at the origin */
|
||||
prism2sphere(prism, 0, 0, 0, &sphere);
|
||||
|
||||
for(dist=10000; dist <= 500000; dist += 500)
|
||||
{
|
||||
resprism = prism_gx(prism,0,0,-dist);
|
||||
ressphere = sphere_gx(sphere,0,90,dist);
|
||||
|
||||
sprintf(msg, "(distance %g m) prism = %.5f sphere = %.5f", dist,
|
||||
resprism, ressphere);
|
||||
mu_assert_almost_equals(resprism, ressphere, 0.00000001, msg);
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
static char * test_prism2sphere_gy()
|
||||
{
|
||||
SPHERE sphere;
|
||||
PRISM prism = {3000,-5000,5000,-5000,5000,-5000,5000,0,0,0};
|
||||
double dist, resprism, ressphere;
|
||||
|
||||
/* Make a sphere with the same mass as the prism and put it at the origin */
|
||||
prism2sphere(prism, 0, 0, 0, &sphere);
|
||||
|
||||
for(dist=10000; dist <= 500000; dist += 500)
|
||||
{
|
||||
resprism = prism_gy(prism,0,0,-dist);
|
||||
ressphere = sphere_gy(sphere,0,90,dist);
|
||||
|
||||
sprintf(msg, "(distance %g m) prism = %.5f sphere = %.5f", dist,
|
||||
resprism, ressphere);
|
||||
mu_assert_almost_equals(resprism, ressphere, 0.00000001, msg);
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
static char * test_prism2sphere_gz()
|
||||
{
|
||||
SPHERE sphere;
|
||||
PRISM prism = {3000,-5000,5000,-5000,5000,-5000,5000,0,0,0};
|
||||
double dist, resprism, ressphere;
|
||||
|
||||
/* Make a sphere with the same mass as the prism and put it at the origin */
|
||||
prism2sphere(prism, 0, 0, 0, &sphere);
|
||||
|
||||
for(dist=50000; dist <= 500000; dist += 500)
|
||||
{
|
||||
resprism = prism_gz(prism,0,0,-dist);
|
||||
ressphere = sphere_gz(sphere,0,90,dist);
|
||||
|
||||
sprintf(msg, "(distance %g m) prism = %.5f sphere = %.5f", dist,
|
||||
resprism, ressphere);
|
||||
mu_assert_almost_equals(resprism, -1*ressphere, 0.01, msg);
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
static char * test_prism2sphere_gxx()
|
||||
{
|
||||
SPHERE sphere;
|
||||
PRISM prism = {3000,-5000,5000,-5000,5000,-5000,5000,0,0,0};
|
||||
double dist, resprism, ressphere;
|
||||
|
||||
/* Make a sphere with the same mass as the prism and put it at the origin */
|
||||
prism2sphere(prism, 0, 0, 0, &sphere);
|
||||
|
||||
for(dist=50000; dist <= 500000; dist += 500)
|
||||
{
|
||||
resprism = prism_gxx(prism,0,0,-dist);
|
||||
ressphere = sphere_gxx(sphere,0,90,dist);
|
||||
|
||||
sprintf(msg, "(distance %g m) prism = %.5f sphere = %.5f", dist,
|
||||
resprism, ressphere);
|
||||
mu_assert_almost_equals(resprism, ressphere, 0.001, msg);
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
static char * test_prism2sphere_gxy()
|
||||
{
|
||||
SPHERE sphere;
|
||||
PRISM prism = {3000,-5000,5000,-5000,5000,-5000,5000,0,0,0};
|
||||
double dist, resprism, ressphere;
|
||||
|
||||
/* Make a sphere with the same mass as the prism and put it at the origin */
|
||||
prism2sphere(prism, 0, 0, 0, &sphere);
|
||||
|
||||
for(dist=50000; dist <= 500000; dist += 500)
|
||||
{
|
||||
resprism = prism_gxy(prism,0,0,-dist);
|
||||
ressphere = sphere_gxy(sphere,0,90,dist);
|
||||
|
||||
sprintf(msg, "(distance %g m) prism = %.5f sphere = %.5f", dist,
|
||||
resprism, ressphere);
|
||||
mu_assert_almost_equals(resprism, ressphere, 0.001, msg);
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
static char * test_prism2sphere_gxz()
|
||||
{
|
||||
SPHERE sphere;
|
||||
PRISM prism = {3000,-5000,5000,-5000,5000,-5000,5000,0,0,0};
|
||||
double dist, resprism, ressphere;
|
||||
|
||||
/* Make a sphere with the same mass as the prism and put it at the origin */
|
||||
prism2sphere(prism, 0, 0, 0, &sphere);
|
||||
|
||||
for(dist=50000; dist <= 500000; dist += 500)
|
||||
{
|
||||
resprism = prism_gxz(prism,0,0,-dist);
|
||||
ressphere = sphere_gxz(sphere,0,90,dist);
|
||||
|
||||
sprintf(msg, "(distance %g m) prism = %.5f sphere = %.5f", dist,
|
||||
resprism, ressphere);
|
||||
mu_assert_almost_equals(resprism, -1*ressphere, 0.001, msg);
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
static char * test_prism2sphere_gyy()
|
||||
{
|
||||
SPHERE sphere;
|
||||
PRISM prism = {3000,-5000,5000,-5000,5000,-5000,5000,0,0,0};
|
||||
double dist, resprism, ressphere;
|
||||
|
||||
/* Make a sphere with the same mass as the prism and put it at the origin */
|
||||
prism2sphere(prism, 0, 0, 0, &sphere);
|
||||
|
||||
for(dist=50000; dist <= 500000; dist += 500)
|
||||
{
|
||||
resprism = prism_gyy(prism,0,0,-dist);
|
||||
ressphere = sphere_gyy(sphere,0,90,dist);
|
||||
|
||||
sprintf(msg, "(distance %g m) prism = %.5f sphere = %.5f", dist,
|
||||
resprism, ressphere);
|
||||
mu_assert_almost_equals(resprism, ressphere, 0.001, msg);
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
static char * test_prism2sphere_gyz()
|
||||
{
|
||||
SPHERE sphere;
|
||||
PRISM prism = {3000,-5000,5000,-5000,5000,-5000,5000,0,0,0};
|
||||
double dist, resprism, ressphere;
|
||||
|
||||
/* Make a sphere with the same mass as the prism and put it at the origin */
|
||||
prism2sphere(prism, 0, 0, 0, &sphere);
|
||||
|
||||
for(dist=50000; dist <= 500000; dist += 500)
|
||||
{
|
||||
resprism = prism_gyz(prism,0,0,-dist);
|
||||
ressphere = sphere_gyz(sphere,0,90,dist);
|
||||
|
||||
sprintf(msg, "(distance %g m) prism = %.5f sphere = %.5f", dist,
|
||||
resprism, ressphere);
|
||||
mu_assert_almost_equals(resprism, -1*ressphere, 0.001, msg);
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
static char * test_prism2sphere_gzz()
|
||||
{
|
||||
SPHERE sphere;
|
||||
PRISM prism = {3000,-5000,5000,-5000,5000,-5000,5000,0,0,0};
|
||||
double dist, resprism, ressphere;
|
||||
|
||||
/* Make a sphere with the same mass as the prism and put it at the origin */
|
||||
prism2sphere(prism, 0, 0, 0, &sphere);
|
||||
|
||||
for(dist=60000; dist <= 500000; dist += 500)
|
||||
{
|
||||
resprism = prism_gzz(prism,0,0,-dist);
|
||||
ressphere = sphere_gzz(sphere,0,90,dist);
|
||||
|
||||
sprintf(msg, "(distance %g m) prism = %.5f sphere = %.5f", dist,
|
||||
resprism, ressphere);
|
||||
mu_assert_almost_equals(resprism, ressphere, 0.001, msg);
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static char * test_prism_tensor_trace()
|
||||
{
|
||||
#define N 4
|
||||
TESSEROID tesses[N] = {
|
||||
{1,0,1,0,1,6000000,6001000},
|
||||
{1,180,183,80,81.5,6300000,6302000},
|
||||
{1,200,203,-90,-88,5500000,5500100},
|
||||
{1,-10,-7,7,7.5,6500000,6505000}};
|
||||
PRISM prism;
|
||||
int i;
|
||||
double trace, dist, x, y;
|
||||
|
||||
for(i = 0; i < N; i++)
|
||||
{
|
||||
tess2prism_flatten(tesses[i], &prism);
|
||||
x = 0.5*(prism.x1 + prism.x2);
|
||||
y = 0.5*(prism.y1 + prism.y2);
|
||||
|
||||
for(dist=1000; dist <= 5000000; dist += 1000)
|
||||
{
|
||||
|
||||
trace = prism_gxx(prism, x, y, prism.z1 - dist)
|
||||
+ prism_gyy(prism, x, y, prism.z1 - dist)
|
||||
+ prism_gzz(prism, x, y, prism.z1 - dist);
|
||||
|
||||
sprintf(msg, "(prism %d dist %g) trace %.10f", i, dist, trace);
|
||||
mu_assert_almost_equals(trace, 0, 0.0000000001, msg);
|
||||
}
|
||||
}
|
||||
#undef N
|
||||
return 0;
|
||||
}
|
||||
|
||||
int grav_prism_run_all()
|
||||
{
|
||||
int failed = 0;
|
||||
failed += mu_run_test(test_safe_atan2_sign,
|
||||
"safe_atan2 result has same sign as angle");
|
||||
failed += mu_run_test(test_safe_atan2_zero,
|
||||
"safe_atan2 returns 0 for y == 0");
|
||||
failed += mu_run_test(test_pot_around,
|
||||
"prism_pot results equal around the prism");
|
||||
failed += mu_run_test(test_gx_around,
|
||||
"prism_gx results consistent around the prism");
|
||||
failed += mu_run_test(test_gy_around,
|
||||
"prism_gy results consistent around the prism");
|
||||
failed += mu_run_test(test_gz_around,
|
||||
"prism_gz results consistent around the prism");
|
||||
failed += mu_run_test(test_gxx_around,
|
||||
"prism_gxx results consistent around the prism");
|
||||
failed += mu_run_test(test_gxy_around,
|
||||
"prism_gxy results consistent around the prism");
|
||||
failed += mu_run_test(test_gxz_around,
|
||||
"prism_gxz results consistent around the prism");
|
||||
failed += mu_run_test(test_gyy_around,
|
||||
"prism_gyy results consistent around the prism");
|
||||
failed += mu_run_test(test_gyz_around,
|
||||
"prism_gyz results consistent around the prism");
|
||||
failed += mu_run_test(test_gzz_around,
|
||||
"prism_gzz results consistent around the prism");
|
||||
failed += mu_run_test(test_gxx_below,
|
||||
"prism_gxx results equal above and below the prism");
|
||||
failed += mu_run_test(test_gxy_below,
|
||||
"prism_gxy results equal above and below the prism");
|
||||
failed += mu_run_test(test_gxz_below,
|
||||
"prism_gxz results equal above and below the prism");
|
||||
failed += mu_run_test(test_gyy_below,
|
||||
"prism_gyy results equal above and below the prism");
|
||||
failed += mu_run_test(test_gyz_below,
|
||||
"prism_gyz results equal above and below the prism");
|
||||
failed += mu_run_test(test_gzz_below,
|
||||
"prism_gzz results equal above and below the prism");
|
||||
failed += mu_run_test(test_prism2sphere_pot,
|
||||
"prism_pot results equal to sphere of same mass at distance");
|
||||
failed += mu_run_test(test_prism2sphere_gx,
|
||||
"prism_gx results equal to sphere of same mass at distance");
|
||||
failed += mu_run_test(test_prism2sphere_gy,
|
||||
"prism_gy results equal to sphere of same mass at distance");
|
||||
failed += mu_run_test(test_prism2sphere_gz,
|
||||
"prism_gz results equal to sphere of same mass at distance");
|
||||
failed += mu_run_test(test_prism2sphere_gxx,
|
||||
"prism_gxx results equal to sphere of same mass at distance");
|
||||
failed += mu_run_test(test_prism2sphere_gxy,
|
||||
"prism_gxy results equal to sphere of same mass at distance");
|
||||
failed += mu_run_test(test_prism2sphere_gxz,
|
||||
"prism_gxz results equal to sphere of same mass at distance");
|
||||
failed += mu_run_test(test_prism2sphere_gyy,
|
||||
"prism_gyy results equal to sphere of same mass at distance");
|
||||
failed += mu_run_test(test_prism2sphere_gyz,
|
||||
"prism_gyz results equal to sphere of same mass at distance");
|
||||
failed += mu_run_test(test_prism2sphere_gzz,
|
||||
"prism_gzz results equal to sphere of same mass at distance");
|
||||
failed += mu_run_test(test_prism_tensor_trace,
|
||||
"trace of GGT for prism in Cartesian coordinates is zero");
|
||||
return failed;
|
||||
}
|
||||
160
test/test_grav_prism_sph.c
Executable file
160
test/test_grav_prism_sph.c
Executable file
@@ -0,0 +1,160 @@
|
||||
/*
|
||||
Unit tests for grav_prism.c functions.
|
||||
*/
|
||||
|
||||
#include <stdio.h>
|
||||
#include <math.h>
|
||||
#include "../lib/grav_prism_sph.h"
|
||||
#include "../lib/grav_prism.h"
|
||||
#include "../lib/geometry.h"
|
||||
#include "../lib/constants.h"
|
||||
|
||||
|
||||
char msg[1000];
|
||||
|
||||
|
||||
/* Test coordinate transformation */
|
||||
static char * test_global2local()
|
||||
{
|
||||
#define R 6378137.0
|
||||
#define N 3
|
||||
PRISM prisms[N] = {
|
||||
{3000,-5000,5000,-5000,5000,0,5000, 2.45, -36.32, R},
|
||||
{2000,-3000,3000,-2000,2000,0,800, -45.45, -103.1, R},
|
||||
{1000,-2000,2000,-1000,1000,0,234, -80.45, 183.2, R}};
|
||||
double x, y, z, newz[N] = {-3000, 1234, -2.3456};
|
||||
int i;
|
||||
|
||||
for(i = 0; i < N; i++)
|
||||
{
|
||||
global2local(prisms[i].lon, prisms[i].lat, R - newz[i], prisms[i],
|
||||
&x, &y, &z);
|
||||
sprintf(msg, "(prism %d) x: expect %.10g got %.10g", i, 0., x);
|
||||
mu_assert_almost_equals(x, 0., 0.00000001, msg);
|
||||
sprintf(msg, "(prism %d) y: expect %.10g got %.10g", i, 0., y);
|
||||
mu_assert_almost_equals(y, 0., 0.00000001, msg);
|
||||
sprintf(msg, "(prism %d) z: expect %.10g got %.10g", i, newz[i], z);
|
||||
mu_assert_almost_equals(z, newz[i], 0.00000001, msg);
|
||||
}
|
||||
#undef R
|
||||
#undef N
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* Test agains grav_prism */
|
||||
static char * test_prism_pot_sph()
|
||||
{
|
||||
#define R 6378137.0
|
||||
PRISM prism = {3000,-5000,5000,-5000,5000,0,5000,187,38,R};
|
||||
double res, expect;
|
||||
int fix;
|
||||
|
||||
fix = 1;
|
||||
res = prism_pot_sph(prism, 187, 38, R + 1000);
|
||||
expect = prism_pot(prism, 0, 0, -1000);
|
||||
sprintf(msg, "(fixture %d) expect %.10g got %.10g", fix, expect, res);
|
||||
mu_assert_almost_equals(res, expect, 0.0000000001, msg);
|
||||
|
||||
#undef R
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
static char * test_prism_g_sph()
|
||||
{
|
||||
#define R 6378137.0
|
||||
PRISM prism = {3000,-5000,5000,-5000,5000,0,5000,27,-78,R};
|
||||
double resx, resy, resz, expectx, expecty, expectz;
|
||||
int fix;
|
||||
|
||||
fix = 1;
|
||||
prism_g_sph(prism, 27, -78, R + 1000, &resx, &resy, &resz);
|
||||
expectx = prism_gx(prism, 0, 0, -1000);
|
||||
expecty = prism_gy(prism, 0, 0, -1000);
|
||||
expectz = prism_gz(prism, 0, 0, -1000);
|
||||
sprintf(msg, "(fixture %d) gx: expect %.10g got %.10g", fix, expectx, resx);
|
||||
mu_assert_almost_equals(resx, expectx, 0.0000000001, msg);
|
||||
sprintf(msg, "(fixture %d) gy: expect %.10g got %.10g", fix, expecty, resy);
|
||||
mu_assert_almost_equals(resy, expecty, 0.0000000001, msg);
|
||||
sprintf(msg, "(fixture %d) gz: expect %.10g got %.10g", fix, expectz, resz);
|
||||
mu_assert_almost_equals(resz, expectz, 0.0000000001, msg);
|
||||
|
||||
#undef R
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
static char * test_prism_ggt_sph()
|
||||
{
|
||||
#define R 6378137.0
|
||||
PRISM prism = {3000,-5000,5000,-5000,5000,0,5000,-7,8,R};
|
||||
double res[6], expect[6];
|
||||
int fix, i;
|
||||
|
||||
fix = 1;
|
||||
prism_ggt_sph(prism, -7, 8, R + 1000, res);
|
||||
expect[0] = prism_gxx(prism, 0, 0, -1000);
|
||||
expect[1] = prism_gxy(prism, 0, 0, -1000);
|
||||
expect[2] = prism_gxz(prism, 0, 0, -1000);
|
||||
expect[3] = prism_gyy(prism, 0, 0, -1000);
|
||||
expect[4] = prism_gyz(prism, 0, 0, -1000);
|
||||
expect[5] = prism_gzz(prism, 0, 0, -1000);
|
||||
for(i = 0; i < 6; i++)
|
||||
{
|
||||
sprintf(msg, "(fixture %d) cmp %d: expect %.10f got %.10f", fix, i,
|
||||
expect[i], res[i]);
|
||||
mu_assert_almost_equals(res[i], expect[i], 0.000000001, msg);
|
||||
}
|
||||
#undef R
|
||||
return 0;
|
||||
}
|
||||
|
||||
static char * test_prism_tensor_sph_trace()
|
||||
{
|
||||
#define N 4
|
||||
#define GXX 0
|
||||
#define GYY 3
|
||||
#define GZZ 5
|
||||
TESSEROID tesses[N] = {
|
||||
{1,0,1,0,1,6000000,6001000},
|
||||
{1,180,183,80,81.5,6300000,6302000},
|
||||
{1,200,203,-90,-88,5500000,5500100},
|
||||
{1,-10,-7,7,7.5,6500000,6505000}};
|
||||
PRISM prism;
|
||||
int i;
|
||||
double trace, dist, tensor[6];
|
||||
|
||||
for(i = 0; i < N; i++)
|
||||
{
|
||||
tess2prism(tesses[i], &prism);
|
||||
for(dist=1000; dist <= 5000000; dist += 1000)
|
||||
{
|
||||
prism_ggt_sph(prism, prism.lon, prism.lat, prism.r + dist, tensor);
|
||||
trace = tensor[GXX] + tensor[GYY] + tensor[GZZ];
|
||||
|
||||
sprintf(msg, "(prism %d dist %g) trace %.10f", i, dist, trace);
|
||||
mu_assert_almost_equals(trace, 0, 0.0000000001, msg);
|
||||
}
|
||||
}
|
||||
#undef N
|
||||
#undef GXX
|
||||
#undef GYY
|
||||
#undef GZZ
|
||||
return 0;
|
||||
}
|
||||
|
||||
int grav_prism_sph_run_all()
|
||||
{
|
||||
int failed = 0;
|
||||
failed += mu_run_test(test_prism_pot_sph,
|
||||
"prism_pot_sph results equal to prism_pot when on top of prism");
|
||||
failed += mu_run_test(test_prism_g_sph,
|
||||
"prism_g_sph results equal to prism_gx, etc, when on top of prism");
|
||||
failed += mu_run_test(test_prism_ggt_sph,
|
||||
"prism_ggt_sph results equal to prism_gxx, etc, when on top of prism");
|
||||
failed += mu_run_test(test_prism_tensor_sph_trace,
|
||||
"trace of GGT for prism in spherical coordinates is zero");
|
||||
failed += mu_run_test(test_global2local,
|
||||
"global2local returns correct result");
|
||||
return failed;
|
||||
}
|
||||
633
test/test_grav_tess.c
Executable file
633
test/test_grav_tess.c
Executable file
@@ -0,0 +1,633 @@
|
||||
/*
|
||||
Unit tests for grav_tess.c functions.
|
||||
*/
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <math.h>
|
||||
#include "../lib/grav_sphere.h"
|
||||
#include "../lib/grav_tess.h"
|
||||
#include "../lib/glq.h"
|
||||
#include "../lib/geometry.h"
|
||||
#include "../lib/constants.h"
|
||||
|
||||
|
||||
char msg[1000];
|
||||
|
||||
|
||||
static char * test_tess2sphere_pot()
|
||||
{
|
||||
SPHERE sphere;
|
||||
TESSEROID tess;
|
||||
double radius, dist, restess, ressphere;
|
||||
GLQ *glqlon, *glqlat, *glqr;
|
||||
|
||||
tess.density = 1000.;
|
||||
tess.w = 44;
|
||||
tess.e = 46;
|
||||
tess.s = -1;
|
||||
tess.n = 1;
|
||||
tess.r1 = MEAN_EARTH_RADIUS - 100000;
|
||||
tess.r2 = MEAN_EARTH_RADIUS;
|
||||
|
||||
glqlon = glq_new(8, tess.w, tess.e);
|
||||
if(glqlon == NULL)
|
||||
mu_assert(0, "GLQ allocation error");
|
||||
|
||||
glqlat = glq_new(8, tess.s, tess.n);
|
||||
if(glqlat == NULL)
|
||||
mu_assert(0, "GLQ allocation error");
|
||||
|
||||
glqr = glq_new(8, tess.r1, tess.r2);
|
||||
if(glqr == NULL)
|
||||
mu_assert(0, "GLQ allocation error");
|
||||
|
||||
glq_precompute_sincos(glqlat);
|
||||
|
||||
radius = tess.r2;
|
||||
|
||||
/* Make a sphere with the same mass as the tesseroid */
|
||||
tess2sphere(tess, &sphere);
|
||||
for(dist=1000000; dist <= 2000000; dist += 1000)
|
||||
{
|
||||
restess = tess_pot(tess,0,40,radius+dist,*glqlon,*glqlat,*glqr);
|
||||
ressphere = sphere_pot(sphere,0,40,radius+dist);
|
||||
sprintf(msg, "(distance %g m) tess = %.5f sphere = %.5f", dist,
|
||||
restess, ressphere);
|
||||
mu_assert_almost_equals(restess, ressphere, 0.01, msg);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
static char * test_tess2sphere_gx()
|
||||
{
|
||||
SPHERE sphere;
|
||||
TESSEROID tess;
|
||||
double radius, dist, restess, ressphere;
|
||||
GLQ *glqlon, *glqlat, *glqr;
|
||||
|
||||
tess.density = 1000.;
|
||||
tess.w = 44;
|
||||
tess.e = 46;
|
||||
tess.s = -1;
|
||||
tess.n = 1;
|
||||
tess.r1 = MEAN_EARTH_RADIUS - 100000;
|
||||
tess.r2 = MEAN_EARTH_RADIUS;
|
||||
|
||||
glqlon = glq_new(8, tess.w, tess.e);
|
||||
if(glqlon == NULL)
|
||||
mu_assert(0, "GLQ allocation error");
|
||||
|
||||
glqlat = glq_new(8, tess.s, tess.n);
|
||||
if(glqlat == NULL)
|
||||
mu_assert(0, "GLQ allocation error");
|
||||
|
||||
glqr = glq_new(8, tess.r1, tess.r2);
|
||||
if(glqr == NULL)
|
||||
mu_assert(0, "GLQ allocation error");
|
||||
|
||||
glq_precompute_sincos(glqlat);
|
||||
|
||||
radius = tess.r2;
|
||||
|
||||
/* Make a sphere with the same mass as the tesseroid */
|
||||
tess2sphere(tess, &sphere);
|
||||
|
||||
for(dist=1000000; dist <= 2000000; dist += 1000)
|
||||
{
|
||||
restess = tess_gx(tess,0,40,radius+dist,*glqlon,*glqlat,*glqr);
|
||||
ressphere = sphere_gx(sphere,0,40,radius+dist);
|
||||
sprintf(msg, "(distance %g m) tess = %.5f sphere = %.5f", dist,
|
||||
restess, ressphere);
|
||||
mu_assert_almost_equals(restess, ressphere, 0.1, msg);
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
static char * test_tess2sphere_gy()
|
||||
{
|
||||
SPHERE sphere;
|
||||
TESSEROID tess;
|
||||
double radius, dist, restess, ressphere;
|
||||
GLQ *glqlon, *glqlat, *glqr;
|
||||
|
||||
tess.density = 1000.;
|
||||
tess.w = 44;
|
||||
tess.e = 46;
|
||||
tess.s = -1;
|
||||
tess.n = 1;
|
||||
tess.r1 = MEAN_EARTH_RADIUS - 100000;
|
||||
tess.r2 = MEAN_EARTH_RADIUS;
|
||||
|
||||
glqlon = glq_new(8, tess.w, tess.e);
|
||||
if(glqlon == NULL)
|
||||
mu_assert(0, "GLQ allocation error");
|
||||
|
||||
glqlat = glq_new(8, tess.s, tess.n);
|
||||
if(glqlat == NULL)
|
||||
mu_assert(0, "GLQ allocation error");
|
||||
|
||||
glqr = glq_new(8, tess.r1, tess.r2);
|
||||
if(glqr == NULL)
|
||||
mu_assert(0, "GLQ allocation error");
|
||||
|
||||
glq_precompute_sincos(glqlat);
|
||||
|
||||
radius = tess.r2;
|
||||
|
||||
/* Make a sphere with the same mass as the tesseroid */
|
||||
tess2sphere(tess, &sphere);
|
||||
|
||||
for(dist=1000000; dist <= 2000000; dist += 1000)
|
||||
{
|
||||
restess = tess_gy(tess,5,45,radius+dist,*glqlon,*glqlat,*glqr);
|
||||
ressphere = sphere_gy(sphere,5,45,radius+dist);
|
||||
|
||||
sprintf(msg, "(distance %g m) tess = %.5f sphere = %.5f", dist,
|
||||
restess, ressphere);
|
||||
mu_assert_almost_equals(restess, ressphere, 0.1, msg);
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
static char * test_tess2sphere_gz()
|
||||
{
|
||||
SPHERE sphere;
|
||||
TESSEROID tess;
|
||||
double radius, dist, restess, ressphere;
|
||||
GLQ *glqlon, *glqlat, *glqr;
|
||||
|
||||
tess.density = 1000.;
|
||||
tess.w = 44;
|
||||
tess.e = 46;
|
||||
tess.s = -1;
|
||||
tess.n = 1;
|
||||
tess.r1 = MEAN_EARTH_RADIUS - 100000;
|
||||
tess.r2 = MEAN_EARTH_RADIUS;
|
||||
|
||||
glqlon = glq_new(8, tess.w, tess.e);
|
||||
if(glqlon == NULL)
|
||||
mu_assert(0, "GLQ allocation error");
|
||||
|
||||
glqlat = glq_new(8, tess.s, tess.n);
|
||||
if(glqlat == NULL)
|
||||
mu_assert(0, "GLQ allocation error");
|
||||
|
||||
glqr = glq_new(8, tess.r1, tess.r2);
|
||||
if(glqr == NULL)
|
||||
mu_assert(0, "GLQ allocation error");
|
||||
|
||||
glq_precompute_sincos(glqlat);
|
||||
|
||||
radius = tess.r2;
|
||||
|
||||
/* Make a sphere with the same mass as the tesseroid */
|
||||
tess2sphere(tess, &sphere);
|
||||
|
||||
for(dist=1500000; dist <= 2000000; dist += 1000)
|
||||
{
|
||||
restess = -tess_gz(tess,0,45,radius+dist,*glqlon,*glqlat,*glqr);
|
||||
ressphere = sphere_gz(sphere,0,45,radius+dist);
|
||||
|
||||
sprintf(msg, "(distance %g m) tess = %.5f sphere = %.5f", dist,
|
||||
restess, ressphere);
|
||||
mu_assert_almost_equals(restess, ressphere, 0.1, msg);
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
static char * test_tess2sphere_gxx()
|
||||
{
|
||||
SPHERE sphere;
|
||||
TESSEROID tess;
|
||||
double radius, dist, restess, ressphere;
|
||||
GLQ *glqlon, *glqlat, *glqr;
|
||||
|
||||
tess.density = 1000.;
|
||||
tess.w = 44;
|
||||
tess.e = 46;
|
||||
tess.s = -1;
|
||||
tess.n = 1;
|
||||
tess.r1 = MEAN_EARTH_RADIUS - 100000;
|
||||
tess.r2 = MEAN_EARTH_RADIUS;
|
||||
|
||||
glqlon = glq_new(8, tess.w, tess.e);
|
||||
if(glqlon == NULL)
|
||||
mu_assert(0, "GLQ allocation error");
|
||||
|
||||
glqlat = glq_new(8, tess.s, tess.n);
|
||||
if(glqlat == NULL)
|
||||
mu_assert(0, "GLQ allocation error");
|
||||
|
||||
glqr = glq_new(8, tess.r1, tess.r2);
|
||||
if(glqr == NULL)
|
||||
mu_assert(0, "GLQ allocation error");
|
||||
|
||||
glq_precompute_sincos(glqlat);
|
||||
|
||||
radius = tess.r2;
|
||||
|
||||
/* Make a sphere with the same mass as the tesseroid */
|
||||
tess2sphere(tess, &sphere);
|
||||
|
||||
for(dist=1300000; dist <= 2000000; dist += 1000)
|
||||
{
|
||||
restess = tess_gxx(tess,0,45,radius+dist,*glqlon,*glqlat,*glqr);
|
||||
ressphere = sphere_gxx(sphere,0,45,radius+dist);
|
||||
|
||||
sprintf(msg, "(distance %g m) tess = %.5f sphere = %.5f", dist,
|
||||
restess, ressphere);
|
||||
mu_assert_almost_equals(restess, ressphere, 0.001, msg);
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
static char * test_tess2sphere_gxy()
|
||||
{
|
||||
SPHERE sphere;
|
||||
TESSEROID tess;
|
||||
double radius, dist, restess, ressphere;
|
||||
GLQ *glqlon, *glqlat, *glqr;
|
||||
|
||||
tess.density = 1000.;
|
||||
tess.w = 44;
|
||||
tess.e = 46;
|
||||
tess.s = -1;
|
||||
tess.n = 1;
|
||||
tess.r1 = MEAN_EARTH_RADIUS - 100000;
|
||||
tess.r2 = MEAN_EARTH_RADIUS;
|
||||
|
||||
glqlon = glq_new(8, tess.w, tess.e);
|
||||
if(glqlon == NULL)
|
||||
mu_assert(0, "GLQ allocation error");
|
||||
|
||||
glqlat = glq_new(8, tess.s, tess.n);
|
||||
if(glqlat == NULL)
|
||||
mu_assert(0, "GLQ allocation error");
|
||||
|
||||
glqr = glq_new(8, tess.r1, tess.r2);
|
||||
if(glqr == NULL)
|
||||
mu_assert(0, "GLQ allocation error");
|
||||
|
||||
glq_precompute_sincos(glqlat);
|
||||
|
||||
radius = tess.r2;
|
||||
|
||||
/* Make a sphere with the same mass as the tesseroid */
|
||||
tess2sphere(tess, &sphere);
|
||||
|
||||
for(dist=1500000; dist <= 2000000; dist += 1000)
|
||||
{
|
||||
restess = tess_gxy(tess,5,50,radius+dist,*glqlon,*glqlat,*glqr);
|
||||
ressphere = sphere_gxy(sphere,5,50,radius+dist);
|
||||
|
||||
sprintf(msg, "(distance %g m) tess = %.5f sphere = %.5f", dist,
|
||||
restess, ressphere);
|
||||
mu_assert_almost_equals(restess, ressphere, 0.001, msg);
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
static char * test_tess2sphere_gxz()
|
||||
{
|
||||
SPHERE sphere;
|
||||
TESSEROID tess;
|
||||
double radius, dist, restess, ressphere;
|
||||
GLQ *glqlon, *glqlat, *glqr;
|
||||
|
||||
tess.density = 1000.;
|
||||
tess.w = 44;
|
||||
tess.e = 46;
|
||||
tess.s = -1;
|
||||
tess.n = 1;
|
||||
tess.r1 = MEAN_EARTH_RADIUS - 100000;
|
||||
tess.r2 = MEAN_EARTH_RADIUS;
|
||||
|
||||
glqlon = glq_new(8, tess.w, tess.e);
|
||||
if(glqlon == NULL)
|
||||
mu_assert(0, "GLQ allocation error");
|
||||
|
||||
glqlat = glq_new(8, tess.s, tess.n);
|
||||
if(glqlat == NULL)
|
||||
mu_assert(0, "GLQ allocation error");
|
||||
|
||||
glqr = glq_new(8, tess.r1, tess.r2);
|
||||
if(glqr == NULL)
|
||||
mu_assert(0, "GLQ allocation error");
|
||||
|
||||
glq_precompute_sincos(glqlat);
|
||||
|
||||
radius = tess.r2;
|
||||
|
||||
/* Make a sphere with the same mass as the tesseroid */
|
||||
tess2sphere(tess, &sphere);
|
||||
|
||||
for(dist=1500000; dist <= 2000000; dist += 1000)
|
||||
{
|
||||
restess = tess_gxz(tess,0,50,radius+dist,*glqlon,*glqlat,*glqr);
|
||||
ressphere = sphere_gxz(sphere,0,50,radius+dist);
|
||||
|
||||
sprintf(msg, "(distance %g m) tess = %.5f sphere = %.5f", dist,
|
||||
restess, ressphere);
|
||||
mu_assert_almost_equals(restess, ressphere, 0.001, msg);
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
static char * test_tess2sphere_gyy()
|
||||
{
|
||||
SPHERE sphere;
|
||||
TESSEROID tess;
|
||||
double radius, dist, restess, ressphere;
|
||||
GLQ *glqlon, *glqlat, *glqr;
|
||||
|
||||
tess.density = 1000.;
|
||||
tess.w = 44;
|
||||
tess.e = 46;
|
||||
tess.s = -1;
|
||||
tess.n = 1;
|
||||
tess.r1 = MEAN_EARTH_RADIUS - 100000;
|
||||
tess.r2 = MEAN_EARTH_RADIUS;
|
||||
|
||||
glqlon = glq_new(8, tess.w, tess.e);
|
||||
if(glqlon == NULL)
|
||||
mu_assert(0, "GLQ allocation error");
|
||||
|
||||
glqlat = glq_new(8, tess.s, tess.n);
|
||||
if(glqlat == NULL)
|
||||
mu_assert(0, "GLQ allocation error");
|
||||
|
||||
glqr = glq_new(8, tess.r1, tess.r2);
|
||||
if(glqr == NULL)
|
||||
mu_assert(0, "GLQ allocation error");
|
||||
|
||||
glq_precompute_sincos(glqlat);
|
||||
|
||||
radius = tess.r2;
|
||||
|
||||
/* Make a sphere with the same mass as the tesseroid */
|
||||
tess2sphere(tess, &sphere);
|
||||
|
||||
for(dist=1500000; dist <= 2000000; dist += 1000)
|
||||
{
|
||||
restess = tess_gyy(tess,0,45,radius+dist,*glqlon,*glqlat,*glqr);
|
||||
ressphere = sphere_gyy(sphere,0,45,radius+dist);
|
||||
|
||||
sprintf(msg, "(distance %g m) tess = %.5f sphere = %.5f", dist,
|
||||
restess, ressphere);
|
||||
mu_assert_almost_equals(restess, ressphere, 0.001, msg);
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
static char * test_tess2sphere_gyz()
|
||||
{
|
||||
SPHERE sphere;
|
||||
TESSEROID tess;
|
||||
double radius, dist, restess, ressphere;
|
||||
GLQ *glqlon, *glqlat, *glqr;
|
||||
|
||||
tess.density = 1000.;
|
||||
tess.w = 44;
|
||||
tess.e = 46;
|
||||
tess.s = -1;
|
||||
tess.n = 1;
|
||||
tess.r1 = MEAN_EARTH_RADIUS - 100000;
|
||||
tess.r2 = MEAN_EARTH_RADIUS;
|
||||
|
||||
glqlon = glq_new(8, tess.w, tess.e);
|
||||
if(glqlon == NULL)
|
||||
mu_assert(0, "GLQ allocation error");
|
||||
|
||||
glqlat = glq_new(8, tess.s, tess.n);
|
||||
if(glqlat == NULL)
|
||||
mu_assert(0, "GLQ allocation error");
|
||||
|
||||
glqr = glq_new(8, tess.r1, tess.r2);
|
||||
if(glqr == NULL)
|
||||
mu_assert(0, "GLQ allocation error");
|
||||
|
||||
glq_precompute_sincos(glqlat);
|
||||
|
||||
radius = tess.r2;
|
||||
|
||||
/* Make a sphere with the same mass as the tesseroid */
|
||||
tess2sphere(tess, &sphere);
|
||||
|
||||
for(dist=1500000; dist <= 2000000; dist += 1000)
|
||||
{
|
||||
restess = tess_gyz(tess,5,45,radius+dist,*glqlon,*glqlat,*glqr);
|
||||
ressphere = sphere_gyz(sphere,5,45,radius+dist);
|
||||
|
||||
sprintf(msg, "(distance %g m) tess = %.5f sphere = %.5f", dist,
|
||||
restess, ressphere);
|
||||
mu_assert_almost_equals(restess, ressphere, 0.001, msg);
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
static char * test_tess2sphere_gzz()
|
||||
{
|
||||
SPHERE sphere;
|
||||
TESSEROID tess;
|
||||
double radius, dist, restess, ressphere;
|
||||
GLQ *glqlon, *glqlat, *glqr;
|
||||
|
||||
tess.density = 1000.;
|
||||
tess.w = 44;
|
||||
tess.e = 46;
|
||||
tess.s = -1;
|
||||
tess.n = 1;
|
||||
tess.r1 = MEAN_EARTH_RADIUS - 100000;
|
||||
tess.r2 = MEAN_EARTH_RADIUS;
|
||||
|
||||
glqlon = glq_new(8, tess.w, tess.e);
|
||||
if(glqlon == NULL)
|
||||
mu_assert(0, "GLQ allocation error");
|
||||
|
||||
glqlat = glq_new(8, tess.s, tess.n);
|
||||
if(glqlat == NULL)
|
||||
mu_assert(0, "GLQ allocation error");
|
||||
|
||||
glqr = glq_new(8, tess.r1, tess.r2);
|
||||
if(glqr == NULL)
|
||||
mu_assert(0, "GLQ allocation error");
|
||||
|
||||
glq_precompute_sincos(glqlat);
|
||||
|
||||
radius = tess.r2;
|
||||
|
||||
/* Make a sphere with the same mass as the tesseroid */
|
||||
tess2sphere(tess, &sphere);
|
||||
|
||||
for(dist=1500000; dist <= 2000000; dist += 1000)
|
||||
{
|
||||
restess = tess_gzz(tess,0,45,radius+dist,*glqlon,*glqlat,*glqr);
|
||||
ressphere = sphere_gzz(sphere,0,45,radius+dist);
|
||||
|
||||
sprintf(msg, "(distance %g m) tess = %.5f sphere = %.5f", dist,
|
||||
restess, ressphere);
|
||||
mu_assert_almost_equals(restess, ressphere, 0.001, msg);
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
static char * test_tess_tensor_trace()
|
||||
{
|
||||
#define N 4
|
||||
TESSEROID tesses[N] = {
|
||||
{1,0,1,0,1,6000000,6001000},
|
||||
{1,180,183,80,81.5,6300000,6302000},
|
||||
{1,200,203,-90,-88,5500000,5500100},
|
||||
{1,-10,-7,7,7.5,6500000,6505000}};
|
||||
GLQ *glqlon, *glqlat, *glqr;
|
||||
int i;
|
||||
double lon, lat, r, trace, dist;
|
||||
|
||||
glqlon = glq_new(8, tesses[0].w, tesses[0].e);
|
||||
if(glqlon == NULL)
|
||||
mu_assert(0, "GLQ allocation error");
|
||||
|
||||
glqlat = glq_new(8, tesses[0].s, tesses[0].n);
|
||||
if(glqlat == NULL)
|
||||
mu_assert(0, "GLQ allocation error");
|
||||
|
||||
glqr = glq_new(8, tesses[0].r1, tesses[0].r2);
|
||||
if(glqr == NULL)
|
||||
mu_assert(0, "GLQ allocation error");
|
||||
|
||||
for(i = 0; i < N; i++)
|
||||
{
|
||||
lon = 0.5*(tesses[i].w + tesses[i].e);
|
||||
lat = 0.5*(tesses[i].n + tesses[i].s);
|
||||
r = tesses[i].r2;
|
||||
|
||||
for(dist=100000; dist <= 5000000; dist += 5000)
|
||||
{
|
||||
trace = calc_tess_model_adapt(&tesses[i], 1, lon, lat, r + dist,
|
||||
glqlon, glqlat, glqr, tess_gxx,
|
||||
TESSEROID_GXX_SIZE_RATIO) +
|
||||
calc_tess_model_adapt(&tesses[i], 1, lon, lat, r + dist,
|
||||
glqlon, glqlat, glqr, tess_gyy,
|
||||
TESSEROID_GYY_SIZE_RATIO) +
|
||||
calc_tess_model_adapt(&tesses[i], 1, lon, lat, r + dist,
|
||||
glqlon, glqlat, glqr, tess_gzz,
|
||||
TESSEROID_GZZ_SIZE_RATIO);
|
||||
|
||||
sprintf(msg, "(tess %d dist %g) trace %.10f", i, dist, trace);
|
||||
mu_assert_almost_equals(trace, 0, 0.0000000001, msg);
|
||||
}
|
||||
}
|
||||
|
||||
glq_free(glqlon);
|
||||
glq_free(glqlat);
|
||||
glq_free(glqr);
|
||||
#undef N
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
static char * test_adaptative()
|
||||
{
|
||||
/* Check if the adaptative is dividing properly and returning the same thing
|
||||
as the non-adaptative (do spliting by hand) */
|
||||
TESSEROID tess,
|
||||
split[10000];
|
||||
GLQ *glqlon, *glqlat, *glqr;
|
||||
double mindist, resadapt, resnormal;
|
||||
double lon, lat;
|
||||
int n;
|
||||
|
||||
tess.density = 1000.;
|
||||
tess.w = -0.5;
|
||||
tess.e = 0.5;
|
||||
tess.s = -0.5;
|
||||
tess.n = 0.5;
|
||||
tess.r1 = MEAN_EARTH_RADIUS - 10000;
|
||||
tess.r2 = MEAN_EARTH_RADIUS;
|
||||
|
||||
glqlon = glq_new(2, tess.w, tess.e);
|
||||
if(glqlon == NULL)
|
||||
mu_assert(0, "GLQ allocation error");
|
||||
|
||||
glqlat = glq_new(2, tess.s, tess.n);
|
||||
if(glqlat == NULL)
|
||||
mu_assert(0, "GLQ allocation error");
|
||||
|
||||
glqr = glq_new(2, tess.r1, tess.r2);
|
||||
if(glqr == NULL)
|
||||
mu_assert(0, "GLQ allocation error");
|
||||
|
||||
mindist = 100000;
|
||||
|
||||
/* If at half mindist should only divide once */
|
||||
for(lon = -0.5; lon <= 0.5; lon += 0.05)
|
||||
{
|
||||
for(lat = -0.5; lat <= 0.5; lat += 0.05)
|
||||
{
|
||||
resadapt = calc_tess_model_adapt(&tess, 1, lon, lat,
|
||||
0.5*mindist + MEAN_EARTH_RADIUS,
|
||||
glqlon, glqlat, glqr,
|
||||
tess_gzz,
|
||||
TESSEROID_GZZ_SIZE_RATIO);
|
||||
n = split_tess(tess, 20, 20, 20, split);
|
||||
sprintf(msg, "splitting in %d instead of 8000", n);
|
||||
mu_assert(n == 8000, msg);
|
||||
resnormal = calc_tess_model(split, n, lon, lat,
|
||||
0.5*mindist + MEAN_EARTH_RADIUS, glqlon,
|
||||
glqlat, glqr, tess_gzz);
|
||||
sprintf(msg, "adapt = %.10f normal = %.10f", resadapt, resnormal);
|
||||
mu_assert_almost_equals(resadapt, resnormal, pow(10, -2), msg);
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
int grav_tess_run_all()
|
||||
{
|
||||
int failed = 0;
|
||||
failed += mu_run_test(test_tess2sphere_pot,
|
||||
"tess_pot results equal to sphere of same mass at distance");
|
||||
failed += mu_run_test(test_tess2sphere_gx,
|
||||
"tess_gx results equal to sphere of same mass at distance");
|
||||
failed += mu_run_test(test_tess2sphere_gy,
|
||||
"tess_gy results equal to sphere of same mass at distance");
|
||||
failed += mu_run_test(test_tess2sphere_gz,
|
||||
"tess_gz results equal to sphere of same mass at distance");
|
||||
failed += mu_run_test(test_tess2sphere_gxx,
|
||||
"tess_gxx results equal to sphere of same mass at distance");
|
||||
failed += mu_run_test(test_tess2sphere_gxy,
|
||||
"tess_gxy results equal to sphere of same mass at distance");
|
||||
failed += mu_run_test(test_tess2sphere_gxz,
|
||||
"tess_gxz results equal to sphere of same mass at distance");
|
||||
failed += mu_run_test(test_tess2sphere_gyy,
|
||||
"tess_gyy results equal to sphere of same mass at distance");
|
||||
failed += mu_run_test(test_tess2sphere_gyz,
|
||||
"tess_gyz results equal to sphere of same mass at distance");
|
||||
failed += mu_run_test(test_tess2sphere_gzz,
|
||||
"tess_gzz results equal to sphere of same mass at distance");
|
||||
failed += mu_run_test(test_tess_tensor_trace, "trace of GGT for tesseroid is zero");
|
||||
failed += mu_run_test(test_adaptative,
|
||||
"calc_tess_model_adapt results as non-adapt with split by hand");
|
||||
return failed;
|
||||
}
|
||||
229
test/test_parsers.c
Executable file
229
test/test_parsers.c
Executable file
@@ -0,0 +1,229 @@
|
||||
/*
|
||||
Unit tests for I/O parser functions.
|
||||
*/
|
||||
|
||||
#include <stdio.h>
|
||||
#include <math.h>
|
||||
#include "minunit.h"
|
||||
#include "../lib/parsers.h"
|
||||
#include "../lib/constants.h"
|
||||
|
||||
/* To store fail messages */
|
||||
char msg[1000];
|
||||
|
||||
|
||||
/* UNIT TESTS */
|
||||
|
||||
static char * test_gets_tess()
|
||||
{
|
||||
int i;
|
||||
char str[1000];
|
||||
TESSEROID res;
|
||||
TESSEROID tesses[4] = {
|
||||
{1,0,1,0,1,6000000,6001000},
|
||||
{1,180,190,80,85,6300000,6301000},
|
||||
{1,160,200,-90,-70,5500000,6000000},
|
||||
{1,-10,5,-7,15,6500000,6505000}};
|
||||
|
||||
for(i = 0; i < 4; i++)
|
||||
{
|
||||
sprintf(str, "%15.5f %15.5f %15.5f %15.5f %15.5f %15.5f %15.5f",
|
||||
tesses[i].w, tesses[i].e, tesses[i].s, tesses[i].n,
|
||||
tesses[i].r2 - MEAN_EARTH_RADIUS,
|
||||
tesses[i].r1 - MEAN_EARTH_RADIUS,
|
||||
tesses[i].density);
|
||||
|
||||
gets_tess(str, &res);
|
||||
|
||||
sprintf(msg, "(tess %d) failed to read w. read=%g true=%g diff=%g", i,
|
||||
res.w, tesses[i].w, res.w - tesses[i].w);
|
||||
mu_assert_almost_equals(res.w, tesses[i].w, 10E-10, msg);
|
||||
sprintf(msg, "(tess %d) failed to read e. read=%g true=%g diff=%g", i,
|
||||
res.e, tesses[i].e, res.e - tesses[i].e);
|
||||
mu_assert_almost_equals(res.e, tesses[i].e, 10E-10, msg);
|
||||
sprintf(msg, "(tess %d) failed to read s. read=%g true=%g diff=%g", i,
|
||||
res.s, tesses[i].s, res.s - tesses[i].s);
|
||||
mu_assert_almost_equals(res.s, tesses[i].s, 10E-10, msg);
|
||||
sprintf(msg, "(tess %d) failed to read n. read=%g true=%g diff=%g", i,
|
||||
res.n, tesses[i].n, res.n - tesses[i].n);
|
||||
mu_assert_almost_equals(res.n, tesses[i].n, 10E-10, msg);
|
||||
sprintf(msg, "(tess %d) failed to read r2. read=%g true=%g diff=%g",
|
||||
i, res.r2, tesses[i].r2, res.r2 - tesses[i].r2);
|
||||
mu_assert_almost_equals(res.r2, tesses[i].r2, 10E-10, msg);
|
||||
sprintf(msg, "(tess %d) failed to read r1. read=%g true=%g diff=%g",
|
||||
i, res.r1, tesses[i].r1, res.r1 - tesses[i].r1);
|
||||
mu_assert_almost_equals(res.r1, tesses[i].r1, 10E-10, msg);
|
||||
sprintf(msg, "(tess %d) failed to read dens. read=%g true=%g diff=%g",
|
||||
i, res.density, tesses[i].density,
|
||||
res.density - tesses[i].density);
|
||||
mu_assert_almost_equals(res.density, tesses[i].density, 10E-10, msg);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
static char * test_gets_prism()
|
||||
{
|
||||
int i;
|
||||
char str[1000];
|
||||
PRISM res;
|
||||
PRISM prisms[4] = {
|
||||
{1,0,1000,0,2000,100,2000,0,0,0},
|
||||
{1,-500,200,300,500,-1000,4000,0,0,0},
|
||||
{1,-10000000,5000000,5000000,8000000,0,3000000,0,0,0},
|
||||
{1,-1000000,50000,500000,800000,0,300000,0,0,0}};
|
||||
|
||||
for(i = 0; i < 4; i++)
|
||||
{
|
||||
sprintf(str, "%g %g %g %g %g %g %g", prisms[i].x1, prisms[i].x2,
|
||||
prisms[i].y1, prisms[i].y2, prisms[i].z1, prisms[i].z2,
|
||||
prisms[i].density);
|
||||
|
||||
if(gets_prism(str, &res))
|
||||
{
|
||||
sprintf(msg, "(prism %d) gets_prism returned 1", i);
|
||||
mu_assert(0, msg);
|
||||
}
|
||||
|
||||
sprintf(msg, "(prism %d) failed to read x1. read=%g true=%g", i, res.x1,
|
||||
prisms[i].x1);
|
||||
mu_assert(res.x1 == prisms[i].x1, msg);
|
||||
sprintf(msg, "(prism %d) failed to read x2. read=%g true=%g", i, res.x2,
|
||||
prisms[i].x2);
|
||||
mu_assert(res.x2 == prisms[i].x2, msg);
|
||||
sprintf(msg, "(prism %d) failed to read y1. read=%g true=%g", i, res.y1,
|
||||
prisms[i].y1);
|
||||
mu_assert(res.y1 == prisms[i].y1, msg);
|
||||
sprintf(msg, "(prism %d) failed to read y2. read=%g true=%g", i, res.y2,
|
||||
prisms[i].y2);
|
||||
mu_assert(res.y2 == prisms[i].y2, msg);
|
||||
sprintf(msg, "(prism %d) failed to read z1. read=%g true=%g", i, res.z1,
|
||||
prisms[i].z1);
|
||||
mu_assert(res.z1 == prisms[i].z1, msg);
|
||||
sprintf(msg, "(prism %d) failed to read z2. read=%g true=%g", i, res.z2,
|
||||
prisms[i].z2);
|
||||
mu_assert(res.z2 == prisms[i].z2, msg);
|
||||
sprintf(msg, "(prism %d) failed to read density. read=%g true=%g", i,
|
||||
res.density, prisms[i].density);
|
||||
mu_assert(res.density == prisms[i].density, msg);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
static char * test_gets_prism_sph()
|
||||
{
|
||||
int i;
|
||||
char str[1000];
|
||||
PRISM res;
|
||||
PRISM prisms[4] = {
|
||||
{1,-1000,1000,-2000,2000,0,2000,2,3,1},
|
||||
{1,-500,500,-500,500,0,4000,-3,1.2344,18.048},
|
||||
{1,-10000000,10000000,-8000000,8000000,0,3000000,2123.2,2,45.33},
|
||||
{1,-50000,50000,-800000,800000,0,300000,783.245,3.57,345}};
|
||||
|
||||
for(i = 0; i < 4; i++)
|
||||
{
|
||||
|
||||
sprintf(str, "%g %g %g %g %g %g %g",
|
||||
prisms[i].x2 - prisms[i].x1,
|
||||
prisms[i].y2 - prisms[i].y1,
|
||||
prisms[i].z2 - prisms[i].z1,
|
||||
prisms[i].density,
|
||||
prisms[i].lon, prisms[i].lat, prisms[i].r);
|
||||
|
||||
if(gets_prism_sph(str, &res))
|
||||
{
|
||||
sprintf(msg, "(prism %d) gets_prism_sph returned 1", i);
|
||||
mu_assert(0, msg);
|
||||
}
|
||||
|
||||
sprintf(msg, "(prism %d) failed to read x1. read=%g true=%g", i, res.x1,
|
||||
prisms[i].x1);
|
||||
mu_assert(res.x1 == prisms[i].x1, msg);
|
||||
sprintf(msg, "(prism %d) failed to read x2. read=%g true=%g", i, res.x2,
|
||||
prisms[i].x2);
|
||||
mu_assert(res.x2 == prisms[i].x2, msg);
|
||||
sprintf(msg, "(prism %d) failed to read y1. read=%g true=%g", i, res.y1,
|
||||
prisms[i].y1);
|
||||
mu_assert(res.y1 == prisms[i].y1, msg);
|
||||
sprintf(msg, "(prism %d) failed to read y2. read=%g true=%g", i, res.y2,
|
||||
prisms[i].y2);
|
||||
mu_assert(res.y2 == prisms[i].y2, msg);
|
||||
sprintf(msg, "(prism %d) failed to read z1. read=%g true=%g", i, res.z1,
|
||||
prisms[i].z1);
|
||||
mu_assert(res.z1 == prisms[i].z1, msg);
|
||||
sprintf(msg, "(prism %d) failed to read z2. read=%g true=%g", i, res.z2,
|
||||
prisms[i].z2);
|
||||
mu_assert(res.z2 == prisms[i].z2, msg);
|
||||
sprintf(msg, "(prism %d) failed to read density. read=%g true=%g", i,
|
||||
res.density, prisms[i].density);
|
||||
mu_assert(res.density == prisms[i].density, msg);
|
||||
sprintf(msg, "(prism %d) failed to read lon. read=%g true=%g", i,
|
||||
res.lon, prisms[i].lon);
|
||||
mu_assert(res.lon == prisms[i].lon, msg);
|
||||
sprintf(msg, "(prism %d) failed to read lat. read=%g true=%g", i,
|
||||
res.lat, prisms[i].lat);
|
||||
mu_assert(res.lat == prisms[i].lat, msg);
|
||||
sprintf(msg, "(prism %d) failed to read r. read=%g true=%g", i,
|
||||
res.r, prisms[i].r);
|
||||
mu_assert(res.r == prisms[i].r, msg);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
static char * test_gets_prism_fail()
|
||||
{
|
||||
int i = 0, j;
|
||||
char str[1000];
|
||||
PRISM res;
|
||||
PRISM prisms[4] = {
|
||||
{1,0,1000,0,2000,100,2000,0,0,0},
|
||||
{1,-500,200,300,500,-1000,4000,0,0,0},
|
||||
{1,-10000000,5000000,5000000,8000000,0,3000000,0,0,0},
|
||||
{1,-1000000,50000,500000,800000,0,300000,0,0,0}};
|
||||
|
||||
j = 1;
|
||||
sprintf(str, "%g %g %g %g %g %g %g 1", prisms[i].x1, prisms[i].x2,
|
||||
prisms[i].y1, prisms[i].y2, prisms[i].z1, prisms[i].z2,
|
||||
prisms[i].density);
|
||||
sprintf(msg, "(test %d) gets_prism did not fail for bad input", j);
|
||||
mu_assert(gets_prism(str, &res), msg);
|
||||
|
||||
j = 2;
|
||||
sprintf(str, "%g %g %g %g %g %g %g 1.3", prisms[i].x1, prisms[i].x2,
|
||||
prisms[i].y1, prisms[i].y2, prisms[i].z1, prisms[i].z2,
|
||||
prisms[i].density);
|
||||
sprintf(msg, "(test %d) gets_prism did not fail for bad input", j);
|
||||
mu_assert(gets_prism(str, &res), msg);
|
||||
|
||||
j = 3;
|
||||
sprintf(str, "%g %g %g %g %g %g %g meh", prisms[i].x1, prisms[i].x2,
|
||||
prisms[i].y1, prisms[i].y2, prisms[i].z1, prisms[i].z2,
|
||||
prisms[i].density);
|
||||
sprintf(msg, "(test %d) gets_prism did not fail for bad input", j);
|
||||
mu_assert(gets_prism(str, &res), msg);
|
||||
|
||||
j = 4;
|
||||
sprintf(str, "%g %g %g %g %g %g %g 1 4.5 234556 blablabla",
|
||||
prisms[i].x1, prisms[i].x2,
|
||||
prisms[i].y1, prisms[i].y2, prisms[i].z1, prisms[i].z2,
|
||||
prisms[i].density);
|
||||
sprintf(msg, "(test %d) gets_prism did not fail for bad input", j);
|
||||
mu_assert(gets_prism(str, &res), msg);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
int parsers_run_all()
|
||||
{
|
||||
int failed = 0;
|
||||
failed += mu_run_test(test_gets_tess, "gets_tess reads correctly from string");
|
||||
failed += mu_run_test(test_gets_prism, "gets_prism reads correctly from string");
|
||||
failed += mu_run_test(test_gets_prism_sph,
|
||||
"gets_prism_sph reads correctly from string");
|
||||
failed += mu_run_test(test_gets_prism_fail, "gets_prism fails for bad input");
|
||||
return failed;
|
||||
}
|
||||
Reference in New Issue
Block a user