ssht_sampling.c

Go to the documentation of this file.

// SSHT package to perform spin spherical harmonic transforms
// Copyright (C) 2011  Jason McEwen
// See LICENSE.txt for license details
 
#include <complex.h>
#include <math.h>
#include "ssht_types.h"
 
#define ABS(x) ((x) >= 0 ? (x) : -(x))
 
void gauleg(double x1, double x2, double *x, double *w, int n);
 
 
//============================================================================
// Sampling weights
//============================================================================
 
 
SSHT_COMPLEX(double) ssht_sampling_weight_mw(int p) {
 
  if (p == 1) {
    return I * SSHT_PION2;
  }
  else if (p == -1) {
     return - I * SSHT_PION2;
  }
  else if (p % 2 == 0) {
    return 2.0 / (1.0 - p*p);
  }
  else {
    return 0.0;
  }
  
}
  
 
double ssht_sampling_weight_dh(double theta_t, int L) {
 
  double w;
  int k;
 
  w = 0.0;
  for (k=0; k<=L-1; k++)
    w += sin((2.0*k+1.0)*theta_t) / (double)(2.0*k+1.0);
 
  w *= 2.0/((double) L) * sin(theta_t);
 
  return w;
 
}
 
 
void ssht_sampling_gl_thetas_weights(double *thetas, double *weights, int L) {
   
  int t;
  double tmp;
 
  gauleg(-1.0, 1.0, thetas, weights, L);
 
  for (t=0; t<=L-1; t++)
    thetas[t] = acos(thetas[t]);
 
  // Reorder thetas array.
  for (t=0; t<=(L-1)/2; t++) {
    tmp = thetas[t];
    thetas[t] = thetas[L-1-t];
    thetas[L-1-t] = tmp;
  }
 
}
 
 
void gauleg(double x1, double x2, double *x, double *w, int n) {
 
  double EPS = 1e-14;
  int i,j,m;
  double p1,p2,p3,pp,xl,xm,z,z1;
 
  m=(n+1)/2;
  xm=0.5*(x2+x1);
  xl=0.5*(x2-x1);
 
  for (i=1; i<=m; i++) {
    z=cos(3.141592654*(i-.25)/(n+.5));
    do {
      p1=1.0;
      p2=0.0;
      for (j=1; j<=n; j++) {
        p3=p2;
        p2=p1;
        p1=((2.0*j-1.0)*z*p2-(j-1.0)*p3)/j;
      }
      pp=n*(z*p1-p2)/(z*z-1.0);
      z1=z;
      z=z1-p1/pp;
    } while (ABS(z-z1) > EPS);
    x[i-1]=xm-xl*z;
    x[n+1-i-1]=xm+xl*z;
    w[i-1]=2.0*xl/((1.0-z*z)*pp*pp);
    w[n+1-i-1]=w[i-1];
  }
 
}
 
 
//============================================================================
// Sampling relations
//============================================================================
 
 
int ssht_sampling_mw_ntheta(int L) {
 
  return L;
 
}
 
 
double ssht_sampling_mw_t2theta(int t, int L) {
 
  return (2.0*t + 1.0) * SSHT_PI / (2.0*L - 1.0);
 
}
 
 
int ssht_sampling_mw_nphi(int L) {
 
  return 2*L-1;
 
}
 
 
double ssht_sampling_mw_p2phi(int p, int L) {
 
  return 2.0 * p * SSHT_PI / (2.0*L - 1.0);
 
}
 
 
int ssht_sampling_mw_n(int L) {
 
  return (L-1)*(2*L-1) + 1;
 
}
 
 
double ssht_sampling_mw_ss_t2theta(int t, int L) {
 
  return 2.0 * t * SSHT_PI / (2.0 * L);
 
}
 
 
int ssht_sampling_mw_ss_ntheta(int L) {
 
  return L+1;
 
}
 
 
double ssht_sampling_mw_ss_p2phi(int p, int L) {
 
  return 2.0 * p * SSHT_PI / (2.0*L);
 
}
 
 
int ssht_sampling_mw_ss_nphi(int L) {
 
  return 2*L;
 
}
 
 
int ssht_sampling_mw_ss_n(int L) {
 
  return (L-1)*(2*L) + 2;
 
}
 
 
double ssht_sampling_dh_t2theta(int t, int L) {
 
  return (2.0*t + 1.0) * SSHT_PI / (4.0*L);
 
}
 
 
int ssht_sampling_dh_ntheta(int L) {
 
  return 2*L;
 
}
 
 
double ssht_sampling_dh_p2phi(int p, int L) {
 
  return 2.0 * p * SSHT_PI / (2.0*L - 1.0);
 
}
 
 
int ssht_sampling_dh_nphi(int L) {
 
  return 2*L-1;
 
}
 
 
int ssht_sampling_dh_n(int L) {
 
  return 2*L*(2*L-1);
 
}
 
 
int ssht_sampling_gl_ntheta(int L) {
 
  return L;
 
}
 
 
double ssht_sampling_gl_p2phi(int p, int L) {
 
  return 2.0 * p * SSHT_PI / (2.0*L - 1.0);
 
}
 
 
int ssht_sampling_gl_nphi(int L) {
 
  return 2*L-1;
 
}
 
 
int ssht_sampling_gl_n(int L) {
 
  return L*(2*L-1);
 
}