asc26 amss-ncku initialized
This commit is contained in:
690
AMSS_NCKU_source/Ansorg.C
Normal file
690
AMSS_NCKU_source/Ansorg.C
Normal file
@@ -0,0 +1,690 @@
|
||||
|
||||
#ifdef newc
|
||||
#include <iostream>
|
||||
#include <iomanip>
|
||||
#include <fstream>
|
||||
#include <strstream>
|
||||
#include <cmath>
|
||||
#include <cstdio>
|
||||
using namespace std;
|
||||
#else
|
||||
#include <iostream.h>
|
||||
#include <iomanip.h>
|
||||
#include <fstream.h>
|
||||
#include <string.h>
|
||||
#include <math.h>
|
||||
#include <stdio.h>
|
||||
#endif
|
||||
|
||||
#include "Ansorg.h"
|
||||
#include <cstring>
|
||||
/* read spectral data from file
|
||||
special: pad phi direction with ghosts for periodic interpolation
|
||||
order = 4: (-2 -1) 0 ... n-1 (n n+1)
|
||||
*/
|
||||
Ansorg::Ansorg(char *filename, int orderi) : pu_ps(0), coordA(0), coordB(0), coordphi(0)
|
||||
{
|
||||
MPI_Comm_rank(MPI_COMM_WORLD, &myrank);
|
||||
|
||||
order = orderi / 2 * 2; // order must be even
|
||||
PIh = PI / 2.0;
|
||||
char s[1000], *t;
|
||||
FILE *fp;
|
||||
double *v;
|
||||
int nghosts;
|
||||
int i;
|
||||
|
||||
double x1, y1, z1, x2, y2, z2, dx, dy;
|
||||
|
||||
/* open file */
|
||||
fp = fopen(filename, "r");
|
||||
if (myrank == 0 && !fp)
|
||||
{
|
||||
cout << "could not open " << filename << " for reading Ansorg" << endl;
|
||||
MPI_Abort(MPI_COMM_WORLD, 1);
|
||||
}
|
||||
if (myrank == 0)
|
||||
printf(" reading data from %s\n", filename);
|
||||
|
||||
/* skip to line starting with data, extract size info */
|
||||
n1 = n2 = n3 = ntotal = -1;
|
||||
while (fgets(s, 1000, fp))
|
||||
{
|
||||
t = strstr(s, "bhx1 ");
|
||||
if (t == s)
|
||||
sscanf(s + 15, "%lf", &x1);
|
||||
t = strstr(s, "bhy1 ");
|
||||
if (t == s)
|
||||
sscanf(s + 15, "%lf", &y1);
|
||||
t = strstr(s, "bhz1 ");
|
||||
if (t == s)
|
||||
sscanf(s + 15, "%lf", &z1);
|
||||
t = strstr(s, "bhx2 ");
|
||||
if (t == s)
|
||||
sscanf(s + 15, "%lf", &x2);
|
||||
t = strstr(s, "bhy2 ");
|
||||
if (t == s)
|
||||
sscanf(s + 15, "%lf", &y2);
|
||||
t = strstr(s, "bhz2 ");
|
||||
if (t == s)
|
||||
sscanf(s + 15, "%lf", &z2);
|
||||
|
||||
t = strstr(s, "data ");
|
||||
if (t != s)
|
||||
continue;
|
||||
sscanf(s + 5, "%d%d%d", &n1, &n2, &n3);
|
||||
ntotal = n1 * n2 * n3;
|
||||
if (myrank == 0)
|
||||
printf(" found data with dimensions %d x %d x %d = %d\n",
|
||||
n1, n2, n3, ntotal);
|
||||
break;
|
||||
}
|
||||
|
||||
if (myrank == 0)
|
||||
cout << " bhx1 = " << x1 << endl
|
||||
<< " bhy1 = " << y1 << endl
|
||||
<< " bhz1 = " << z1 << endl
|
||||
<< " bhx2 = " << x2 << endl
|
||||
<< " bhy2 = " << y2 << endl
|
||||
<< " bhz2 = " << z2 << endl;
|
||||
|
||||
dx = x1 - x2;
|
||||
dy = y1 - y2;
|
||||
|
||||
/* x-axis */
|
||||
if (dx != 0 && y1 == 0 && y2 == 0 && z1 == 0 && z2 == 0)
|
||||
{
|
||||
ps_b = dx / 2;
|
||||
ps_dx = (x1 + x2) / 2;
|
||||
ps_rxx = 1;
|
||||
ps_rxy = 0;
|
||||
ps_ryx = 0;
|
||||
ps_ryy = 1;
|
||||
}
|
||||
|
||||
/* y-axis */
|
||||
else if (dy != 0 && x1 == 0 && x2 == 0 && z1 == 0 && z2 == 0)
|
||||
{
|
||||
ps_b = dy / 2;
|
||||
ps_dx = (y1 + y2) / 2;
|
||||
ps_rxx = 0;
|
||||
ps_rxy = +1;
|
||||
ps_ryx = -1;
|
||||
ps_ryy = 0;
|
||||
}
|
||||
|
||||
/* else */
|
||||
else if (myrank == 0)
|
||||
{
|
||||
cout << "puncture location not allowed" << endl;
|
||||
MPI_Abort(MPI_COMM_WORLD, 1);
|
||||
}
|
||||
|
||||
if (ntotal == -1 && myrank == 0)
|
||||
{
|
||||
cout << "file does not contain the expected data" << endl;
|
||||
MPI_Abort(MPI_COMM_WORLD, 1);
|
||||
}
|
||||
|
||||
/* get storage if needed */
|
||||
int pad = order / 2;
|
||||
nghosts = n1 * n2 * pad;
|
||||
if (!(pu_ps))
|
||||
pu_ps = new double[ntotal + 2 * nghosts];
|
||||
v = pu_ps + nghosts;
|
||||
|
||||
/* read data */
|
||||
i = 0;
|
||||
while (fgets(s, 1000, fp))
|
||||
{
|
||||
if (i < ntotal)
|
||||
v[i] = atof(t);
|
||||
i++;
|
||||
}
|
||||
if (myrank == 0)
|
||||
{
|
||||
printf(" read %d data lines\n", i);
|
||||
cout << endl;
|
||||
}
|
||||
if (myrank == 0 && i < ntotal)
|
||||
{
|
||||
cout << "file contains too few data lines" << endl;
|
||||
MPI_Abort(MPI_COMM_WORLD, 1);
|
||||
}
|
||||
if (myrank == 0 && i > ntotal)
|
||||
{
|
||||
cout << "file contains too many data lines" << endl;
|
||||
MPI_Abort(MPI_COMM_WORLD, 1);
|
||||
}
|
||||
|
||||
/* copy data into ghosts */
|
||||
for (i = 0; i < nghosts; i++)
|
||||
{
|
||||
(pu_ps)[i] = v[i + ntotal - nghosts];
|
||||
(pu_ps)[i + ntotal + nghosts] = v[i];
|
||||
}
|
||||
|
||||
if (0)
|
||||
for (i = 0; i < ntotal + 2 * nghosts; i++)
|
||||
printf("yoyo %10d %.16e\n", i - nghosts, (pu_ps)[i]);
|
||||
|
||||
/* done */
|
||||
fclose(fp);
|
||||
|
||||
set_ABp();
|
||||
|
||||
if (0)
|
||||
{
|
||||
if (myrank == 0)
|
||||
{
|
||||
cout << ps_u_at_xyz(0.015625, -4.578125, 0.015625) << endl;
|
||||
cout << ps_u_at_xyz(0.046875, -4.578125, 0.015625) << endl;
|
||||
cout << ps_u_at_xyz(0.078125, -4.578125, 0.015625) << endl;
|
||||
MPI_Abort(MPI_COMM_WORLD, 1);
|
||||
}
|
||||
else
|
||||
for (int i = 0;; i++)
|
||||
;
|
||||
}
|
||||
}
|
||||
Ansorg::~Ansorg()
|
||||
{
|
||||
if (coordA)
|
||||
delete[] coordA;
|
||||
if (coordB)
|
||||
delete[] coordB;
|
||||
if (coordphi)
|
||||
delete[] coordphi;
|
||||
if (pu_ps)
|
||||
delete[] pu_ps;
|
||||
}
|
||||
/* interpolate to point given in Cartesian coordinates
|
||||
calls function in utility/interpolation/barycentric.c
|
||||
*/
|
||||
double Ansorg::ps_u_at_xyz(double x, double y, double z)
|
||||
{
|
||||
double A, B, phi, u, U;
|
||||
/*
|
||||
// rotate THETA along clockwise direction
|
||||
#define THETA (PI*0.25)
|
||||
A = x;
|
||||
B = y;
|
||||
x = A*cos(THETA)+B*sin(THETA);
|
||||
y =-A*sin(THETA)+B*cos(THETA);
|
||||
*/
|
||||
xyz_to_ABp(x, y, z, &A, &B, &phi);
|
||||
if (0)
|
||||
printf("x %f y %f z %f phi %f %.1f\n", x, y, z, phi, 180 * phi / PI);
|
||||
if (0)
|
||||
printf("A %f B %f phi %f\n", A, B, phi);
|
||||
|
||||
U = interpolate_tri_bar(A, B, phi, n1, n2, n3 + (order / 2) * 2,
|
||||
coordA, coordB, coordphi, pu_ps);
|
||||
u = 2 * (A - 1) * U;
|
||||
if (U > 0.025)
|
||||
cout << x << "," << y << "," << z << "," << A << "," << B << "," << phi << "," << U << "," << u << endl;
|
||||
if (!finite(u))
|
||||
{
|
||||
cout << "find NaN in Ansorg::ps_u_at_xyz at (" << x << "," << y << "," << z << ")" << endl;
|
||||
MPI_Abort(MPI_COMM_WORLD, 1);
|
||||
}
|
||||
|
||||
return u;
|
||||
}
|
||||
/* set 1d arrays for spectral coordinates
|
||||
see Punctures_functions.c for reference
|
||||
special: pad phi direction with ghosts for periodicity
|
||||
*/
|
||||
void Ansorg::set_ABp()
|
||||
{
|
||||
int pad = order / 2;
|
||||
int i;
|
||||
double Acode;
|
||||
int pr = 0;
|
||||
|
||||
coordA = new double[n1];
|
||||
coordB = new double[n2];
|
||||
coordphi = new double[n3 + 2 * pad];
|
||||
|
||||
for (i = 0; i < n1; i++)
|
||||
{
|
||||
Acode = -cos(PIh * (2 * i + 1) / n1);
|
||||
coordA[i] = (Acode + 1) / 2;
|
||||
if (pr && myrank == 0)
|
||||
printf("coordA[%2d] = %f\n", i, coordA[i]);
|
||||
}
|
||||
|
||||
for (i = 0; i < n2; i++)
|
||||
{
|
||||
coordB[i] = -cos(PIh * (2 * i + 1) / n2);
|
||||
if (pr && myrank == 0)
|
||||
printf("coordB[%2d] = %f\n", i, coordB[i]);
|
||||
}
|
||||
|
||||
for (i = 0; i < n3 + 2 * pad; i++)
|
||||
{
|
||||
coordphi[i] = 2 * PI * (i - pad) / n3;
|
||||
if (pr && myrank == 0)
|
||||
printf("coordphi[%2d] = %f %f\n",
|
||||
i, coordphi[i], coordphi[i] * 180 / PI);
|
||||
}
|
||||
}
|
||||
/* from cartesian to spectral
|
||||
see coordtrans.m etc
|
||||
The problem is that the inverse transformation requires several
|
||||
nested square roots with 8 possible solutions, only one of them relevant.
|
||||
We have picked the correct solution by testing in Mathematica.
|
||||
Furthermore, there are special coordinates where the formulas have
|
||||
to be specialized.
|
||||
|
||||
fixme: needs proper treatment of quantities that are almost zero/singular
|
||||
*/
|
||||
#if 0
|
||||
void Ansorg::xyz_to_ABp(double x, double y, double z,
|
||||
double *A, double *B, double *phi)
|
||||
{
|
||||
const double s2 = sqrt(2.0);
|
||||
double r, rr, xx;
|
||||
double t, st, u, su, v, sv, w, sw;
|
||||
|
||||
/* rotate onto x-axis if required */
|
||||
w = x;
|
||||
x = ps_rxx * w + ps_rxy * y;
|
||||
y = ps_ryx * w + ps_ryy * y;
|
||||
|
||||
/* center black holes at +b and -b */
|
||||
x -= ps_dx;
|
||||
|
||||
/* offset parameter b rescales the coordinates */
|
||||
x /= ps_b;
|
||||
y /= ps_b;
|
||||
z /= ps_b;
|
||||
|
||||
/* helpers */
|
||||
r = sqrt(y*y + z*z);
|
||||
rr = r*r;
|
||||
xx = x*x;
|
||||
|
||||
|
||||
/* phi as in cylindrical coordinates about x-axis
|
||||
acos covers [0,pi], we need [0,2pi)
|
||||
*/
|
||||
if (r>0.0)
|
||||
*phi = (z < 0.0) ? 2*PI - acos(y/r) : acos(y/r);
|
||||
else
|
||||
*phi = 0;
|
||||
|
||||
|
||||
/* r > 0 */
|
||||
if (r>0.0) {
|
||||
|
||||
/* x != 0, r > 0 */
|
||||
if (x != 0.0) {
|
||||
|
||||
t = (1+rr)*(1+rr) + 2*(-1 + rr)*xx + xx*xx;
|
||||
st = sqrt(t);
|
||||
u = 1 - xx + rr*(2 + rr + xx + st) + st;
|
||||
su = sqrt(u);
|
||||
v = 1 + rr*rr - xx + rr*(2 + xx + st) + st;
|
||||
sv = sqrt(v);
|
||||
w = 1 + rr - s2*su + st;
|
||||
sw = sqrt(w);
|
||||
|
||||
*A = (2*sw*(1 + rr + st - xx) + s2*sv*(-1 - rr + 2*sw + st - xx))
|
||||
/(4.*r*xx);
|
||||
|
||||
*B = -(sw/x);
|
||||
}
|
||||
|
||||
/* x == 0, r > 0 */
|
||||
else {
|
||||
*A = (sqrt(1+rr) - 1)/r;
|
||||
*B = 0;
|
||||
}
|
||||
}
|
||||
|
||||
/* r == 0 */
|
||||
else {
|
||||
|
||||
/* x > 1, r == 0 */
|
||||
if (x>1.0) {
|
||||
*A = sqrt(x-1)/sqrt(x+1);
|
||||
*B = -1;
|
||||
}
|
||||
|
||||
/* x < -1, r == 0 */
|
||||
else if (x<-1.0) {
|
||||
*A = sqrt(-x-1)/sqrt(-x+1);
|
||||
*B = +1;
|
||||
}
|
||||
|
||||
/* -1 <= x <= 1, r == 0 */
|
||||
else {
|
||||
*A = 0;
|
||||
|
||||
/* x != 0 */
|
||||
if (x != 0.0)
|
||||
*B = (sqrt(1-xx) - 1)/x;
|
||||
|
||||
/* x == 0 */
|
||||
else
|
||||
*B = 0;
|
||||
}
|
||||
}
|
||||
if(!finite(*A) || !finite(*B) || (*A)<0 || (*A)>1 || (*B)<-1 || (*B)>1) {*A = 1; *B = 0;}
|
||||
if(!finite(*A) || !finite(*B) || (*A)<0 || (*A)>1 || (*B)<-1 || (*B)>1 || (*phi)<0 || (*phi)>2*PI){
|
||||
cout<<"find ("<<*A<<","<<*B<<","<<*phi<<") in Ansorg::xyz_to_ABp at ("<<x<<","<<y<<","<<z
|
||||
<<") t u v w "<<t<<","<<u<<","<<v<<","<<w<<endl;
|
||||
cout<<2*sw*(rr + st + 1 - xx)<<","<< s2*sv*(st - rr - 1 + 2*sw - xx)<<"LAST"<<endl;
|
||||
MPI_Abort(MPI_COMM_WORLD,1);
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if 0
|
||||
void Ansorg::xyz_to_ABp(double x, double y, double z,
|
||||
double *A, double *B, double *phi)
|
||||
{
|
||||
const double s2 = sqrt(2.0);
|
||||
const double exp = 3.0/2.0;
|
||||
|
||||
double r, rr, xx;
|
||||
double t, st, u, su, v, sv, w, sw;
|
||||
|
||||
/* rotate onto x-axis if required */
|
||||
w = x;
|
||||
x = ps_rxx * w + ps_rxy * y;
|
||||
y = ps_ryx * w + ps_ryy * y;
|
||||
|
||||
/* center black holes at +b and -b */
|
||||
x -= ps_dx;
|
||||
|
||||
/* offset parameter b rescales the coordinates */
|
||||
x /= ps_b;
|
||||
y /= ps_b;
|
||||
z /= ps_b;
|
||||
|
||||
/* helpers */
|
||||
r = sqrt(y*y + z*z);
|
||||
rr = r*r;
|
||||
xx = x*x;
|
||||
|
||||
|
||||
/* phi as in cylindrical coordinates about x-axis
|
||||
acos covers [0,pi], we need [0,2pi)
|
||||
*/
|
||||
if (r>0)
|
||||
*phi = (z<0) ? 2*PI - acos(y/r) : acos(y/r);
|
||||
else
|
||||
*phi = 0;
|
||||
|
||||
/* r > 0 */
|
||||
{
|
||||
|
||||
/* x != 0, r > 0 */
|
||||
{
|
||||
t = (1+rr)*(1+rr) + 2*(-1 + rr)*xx + xx*xx;
|
||||
st = sqrt(t);
|
||||
u = rr*(2 + rr + xx + st) + st + 1.0 - xx;
|
||||
su = sqrt(u);
|
||||
v = rr*rr + rr*(2 + xx + st) + st + 1.0 - xx;
|
||||
sv = sqrt(v);
|
||||
w = rr - s2*su + st + 1.0;
|
||||
sw = sqrt(w);
|
||||
|
||||
*A = (2*sw*(rr + st + 1 - xx) + s2*sv*(st - rr - 1 + 2*sw - xx))
|
||||
/(4.*r*xx);
|
||||
|
||||
*B = -(sw/x);
|
||||
}
|
||||
/* x == 0, r > 0 */
|
||||
if(!finite(*A) || !finite(*B) || (*A)<0 || (*A)>1 || (*B)<-1 || (*B)>1)
|
||||
{
|
||||
*A = (sqrt(1 + rr) - 1)/r + ((sqrt(1 + rr) - 1)*xx)/(2*r*pow((1 + rr),exp));
|
||||
|
||||
*B = -x/(2*sqrt(1 + rr));
|
||||
}
|
||||
}
|
||||
|
||||
/* r == 0 */
|
||||
if(!finite(*A) || !finite(*B) || (*A)<0 || (*A)>1 || (*B)<-1 || (*B)>1)
|
||||
{
|
||||
|
||||
/* x > 1, r == 0 */
|
||||
if (x>1) {
|
||||
*A = sqrt(x-1)/sqrt(x+1);
|
||||
*B = -1;
|
||||
}
|
||||
|
||||
/* x < -1, r == 0 */
|
||||
else if (x<-1) {
|
||||
*A = sqrt(-x-1)/sqrt(-x+1);
|
||||
*B = +1;
|
||||
}
|
||||
|
||||
/* -1 <= x <= 1, r == 0 */
|
||||
else {
|
||||
*A = 0;
|
||||
|
||||
/* x != 0 */
|
||||
if (x != 0)
|
||||
*B = (sqrt(1-xx) - 1)/x;
|
||||
|
||||
/* x == 0 */
|
||||
else
|
||||
*B = 0;
|
||||
}
|
||||
}
|
||||
|
||||
double aux1 = 0.5 * (x * x + rr - 1);
|
||||
double aux2 = sqrt (aux1 * aux1 + rr);
|
||||
double X = asinh (sqrt (aux1 + aux2));
|
||||
double R = asin (min(1.0, sqrt (-aux1 + aux2)));
|
||||
if (x < 0) R = PI - R;
|
||||
|
||||
*A = tanh (0.5 * X);
|
||||
*B = tan (0.5 * R - PI/4);
|
||||
|
||||
if((*A)<0 || (*A)>1 || (*B)<-1 || (*B)>1 || (*phi)<0 || (*phi)>2*PI){
|
||||
cout<<"find ("<<*A<<","<<*B<<","<<*phi<<") in Ansorg::xyz_to_ABp at ("<<x<<","<<y<<","<<z
|
||||
<<") t u v w "<<t<<","<<u<<","<<v<<","<<w<<endl;
|
||||
cout<<2*sw*(rr + st + 1 - xx)<<","<< s2*sv*(st - rr - 1 + 2*sw - xx)<<"LAST"<<endl;
|
||||
MPI_Abort(MPI_COMM_WORLD,1);
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if 1
|
||||
// adopting the coordinate transformation in TwoPunctures Thorn on Jan 23, 2011
|
||||
void Ansorg::xyz_to_ABp(double x, double y, double z,
|
||||
double *A, double *B, double *phi)
|
||||
{
|
||||
const double s2 = sqrt(2.0);
|
||||
const double exp = 3.0 / 2.0;
|
||||
|
||||
double r, rr, xx;
|
||||
double t, st, u, su, v, sv, w, sw;
|
||||
|
||||
/* rotate onto x-axis if required */
|
||||
w = x;
|
||||
x = ps_rxx * w + ps_rxy * y;
|
||||
y = ps_ryx * w + ps_ryy * y;
|
||||
|
||||
/* center black holes at +b and -b */
|
||||
x -= ps_dx;
|
||||
|
||||
/* offset parameter b rescales the coordinates */
|
||||
x /= ps_b;
|
||||
y /= ps_b;
|
||||
z /= ps_b;
|
||||
|
||||
/* helpers */
|
||||
r = sqrt(y * y + z * z);
|
||||
rr = r * r;
|
||||
xx = x * x;
|
||||
/* this work worse than the next one
|
||||
*phi = atan2(z, y);
|
||||
if (*phi < 0) *phi += 2 * PI;
|
||||
*/
|
||||
if (r > 0)
|
||||
*phi = (z < 0) ? 2 * PI - acos(y / r) : acos(y / r);
|
||||
else
|
||||
*phi = 0;
|
||||
|
||||
double aux1 = 0.5 * (x * x + rr - 1);
|
||||
double aux2 = sqrt(aux1 * aux1 + rr);
|
||||
double X = asinh(sqrt(aux1 + aux2));
|
||||
double R = asin(min(1.0, sqrt(-aux1 + aux2)));
|
||||
if (x < 0)
|
||||
R = PI - R;
|
||||
|
||||
*A = tanh(0.5 * X);
|
||||
*B = tan(0.5 * R - PI / 4);
|
||||
}
|
||||
#endif
|
||||
/* three dimensional polynomial interpolation, barycentric */
|
||||
double Ansorg::interpolate_tri_bar(double x, double y, double z,
|
||||
int n1, int n2, int n3,
|
||||
double *x1, double *x2, double *x3, double *yp)
|
||||
{
|
||||
double u;
|
||||
double *w, *omega;
|
||||
double **v;
|
||||
|
||||
int i, j, k, ijk;
|
||||
int i1, i2, i3;
|
||||
int di = 1, dj = n1, dk = n1 * n2;
|
||||
int order1 = order > n1 ? n1 : order;
|
||||
int order2 = order > n2 ? n2 : order;
|
||||
int order3 = order > n3 ? n3 : order;
|
||||
|
||||
w = new double[order];
|
||||
omega = new double[order];
|
||||
v = new double *[order];
|
||||
for (int i = 0; i < order; i++)
|
||||
v[i] = new double[order];
|
||||
|
||||
i1 = find_point_bisection(x, n1, x1, order1 / 2);
|
||||
i2 = find_point_bisection(y, n2, x2, order2 / 2);
|
||||
i3 = find_point_bisection(z, n3, x3, order3 / 2);
|
||||
ijk = i1 * di + i2 * dj + i3 * dk;
|
||||
if (0)
|
||||
printf("%d %d %d\n", i1, i2, i3);
|
||||
|
||||
barycentric_omega(order1, 1, &x1[i1], omega);
|
||||
for (k = 0; k < order3; k++)
|
||||
for (j = 0; j < order2; j++)
|
||||
v[k][j] = barycentric(x, order1, 1, &x1[i1], &yp[ijk + j * dj + k * dk], omega);
|
||||
|
||||
if (0)
|
||||
for (k = 0; k < order3; k++)
|
||||
for (j = 0; j < order2; j++)
|
||||
printf("%2d %2d %.15f\n", k, j, v[k][j]);
|
||||
|
||||
barycentric_omega(order2, 1, &x2[i2], omega);
|
||||
for (k = 0; k < order3; k++)
|
||||
w[k] = barycentric(y, order2, 1, &x2[i2], &v[k][0], omega);
|
||||
|
||||
if (0)
|
||||
for (k = 0; k < order3; k++)
|
||||
printf("%2d %.15f\n", k, w[k]);
|
||||
|
||||
barycentric_omega(order3, 1, &x3[i3], omega);
|
||||
u = barycentric(z, order3, 1, &x3[i3], w, omega);
|
||||
|
||||
if (!finite(u))
|
||||
{
|
||||
cout << "find NaN in Ansorg::interpolate_tri_bar at (" << x << "," << y << "," << z << ")" << endl;
|
||||
MPI_Abort(MPI_COMM_WORLD, 1);
|
||||
}
|
||||
|
||||
for (i = 0; i < order; i++)
|
||||
delete[] v[i];
|
||||
|
||||
delete[] w;
|
||||
delete[] omega;
|
||||
delete[] v;
|
||||
|
||||
return u;
|
||||
}
|
||||
/* find index such that xp[i] <= x < xp[i+1]
|
||||
uses bisection, which relies on x being ordered
|
||||
o is "offset", number of points smaller than x that are required
|
||||
returns j = i-(o-1), i.e. if o = 2, then
|
||||
xp[j] < xp[j+1] <= x < xp[j+2] < xp[j+3]
|
||||
which is useful for interpolation
|
||||
*/
|
||||
int Ansorg::find_point_bisection(double x, int n, double *xp, int o)
|
||||
{
|
||||
int i0 = o - 1, i1 = n - o;
|
||||
int i;
|
||||
|
||||
if (n < 2 * o)
|
||||
{
|
||||
cout << "bisection failed" << endl;
|
||||
MPI_Abort(MPI_COMM_WORLD, 1);
|
||||
}
|
||||
|
||||
if (x <= xp[i0])
|
||||
return 0;
|
||||
if (x > xp[i1])
|
||||
return n - 2 * o;
|
||||
|
||||
while (i0 != i1 - 1)
|
||||
{
|
||||
i = (i0 + i1) / 2;
|
||||
if (x < xp[i])
|
||||
i1 = i;
|
||||
else
|
||||
i0 = i;
|
||||
}
|
||||
|
||||
return i0 - o + 1;
|
||||
}
|
||||
/* compute omega[] for barycentric interpolation */
|
||||
// SIAM_review 46, 501 (2004)
|
||||
void Ansorg::barycentric_omega(int n, int s, double *x, double *omega)
|
||||
{
|
||||
double o;
|
||||
int i, j;
|
||||
|
||||
if (0)
|
||||
printf("%d %d %p %p\n", n, s, x, omega);
|
||||
|
||||
for (i = 0; i < n; i += s)
|
||||
{
|
||||
o = 1;
|
||||
for (j = 0; j < n; j += s)
|
||||
{
|
||||
if (j != i)
|
||||
{
|
||||
o /= (x[i] - x[j]);
|
||||
}
|
||||
}
|
||||
omega[i / s] = o;
|
||||
|
||||
if (0)
|
||||
printf("x[%d] = %9.6f omega[%d] = %13.6e\n", i / s, x[i], i / s, o);
|
||||
}
|
||||
}
|
||||
/* barycentric interpolation with precomputed omega */
|
||||
double Ansorg::barycentric(double x0, int n, int s, double *x, double *y,
|
||||
double *omega)
|
||||
{
|
||||
double a, b, c, d;
|
||||
int i;
|
||||
|
||||
if (0)
|
||||
printf("%f %d %d %p %p %p\n", x0, n, s, x, y, omega);
|
||||
|
||||
a = b = 0;
|
||||
for (i = 0; i < n; i += s)
|
||||
{
|
||||
d = x0 - x[i];
|
||||
if (d == 0)
|
||||
return y[i];
|
||||
c = omega[i / s] / d;
|
||||
b += c;
|
||||
a += c * y[i];
|
||||
}
|
||||
|
||||
return a / b;
|
||||
}
|
||||
Reference in New Issue
Block a user