float BSplineInterpolation::evaluate(float pos) {
double y, yerr;
float dy = 0;
const float dstep = 0.01;
/* if x is out of spline definition, etrapolate */
if (pos > splineMaxX || pos < splineMinX) {
float steps, endpoint, dy;
/* get gradient at right end */
if (pos > splineMaxX) {
endpoint = evaluate(splineMaxX);
dy = endpoint - evaluate(splineMaxX - dstep);
steps = (pos - splineMaxX) / dstep;
y = endpoint + (dy*steps);
} else if (pos < splineMinX) {
endpoint = evaluate(splineMinX);
dy = evaluate(splineMinX + dstep) - endpoint;
steps = (splineMinX - pos) / dstep;
y = endpoint - (dy*steps);
}
} else {
gsl_bspline_eval(pos, bSpline, bSplineWorkspace);
gsl_multifit_linear_est(bSpline, cParameters, covMatrix, &y, &yerr);
}
return (float)y;
}
void TransformationModelBSpline::computeLinear_(
const double pos, double & slope, double & offset, double & sd_err)
{
gsl_bspline_deriv_workspace * deriv_workspace = gsl_bspline_deriv_alloc(4);
gsl_matrix * deriv = gsl_matrix_alloc(ncoeffs_, 2);
gsl_bspline_deriv_eval(pos, 1, deriv, workspace_, deriv_workspace);
gsl_bspline_deriv_free(deriv_workspace);
double results[2];
for (size_t j = 0; j < 2; ++j)
{
for (size_t i = 0; i < ncoeffs_; ++i)
{
gsl_vector_set(bsplines_, i, gsl_matrix_get(deriv, i, j));
}
gsl_multifit_linear_est(bsplines_, coeffs_, cov_, &results[j], &sd_err);
// TODO: find a good way to estimate the error
// e.g. by reducing "num_breakpoints" and comparing to current?!
if (sd_err >= 1)
{
// this SD seems on a much smaller scale than "yerr" in "evaluate"...
// see GSL's "multilinear.c::gsl_multifit_linear_est" for details
LOG_WARN << "Warning: B-spline extrapolation is unreliable. Consider reducing 'num_breakpoints' or using another model." << endl;
}
}
gsl_matrix_free(deriv);
offset = results[0];
slope = results[1];
}
/* Estimation of values for given x */
int
gsl_multifit_robust_est(const gsl_vector * x, const gsl_vector * c,
const gsl_matrix * cov, double *y, double *y_err)
{
int s = gsl_multifit_linear_est(x, c, cov, y, y_err);
return s;
}
CAMLprim value ml_gsl_multifit_linear_est (value x, value c, value cov)
{
double y, y_err;
_DECLARE_VECTOR2(x, c);
_DECLARE_MATRIX(cov);
_CONVERT_VECTOR2(x, c);
_CONVERT_MATRIX(cov);
gsl_multifit_linear_est (&v_x, &v_c, &m_cov, &y, &y_err);
return copy_two_double_arr (y, y_err);
}
/*=============================================================================
* MINIMIZING FUNCTION
*=============================================================================*/
double min_func(double x, void *params){
double y, yerr;
gsl_vector *B;
B = gsl_vector_alloc(ncoeffs);
gsl_bspline_eval(x, B, bw);
gsl_multifit_linear_est(B, c, cov, &y, &yerr);
return y;
}
DoubleReal TransformationModelBSpline::evaluate(const DoubleReal value) const
{
DoubleReal result;
if (value < xmin_) // extrapolate on left side
{
result = offset_min_ - slope_min_ * (xmin_ - value);
}
else if (value > xmax_) // extrapolate on right side
{
result = offset_max_ + slope_max_ * (value - xmax_);
}
else // evaluate B-splines
{
double yerr;
gsl_bspline_eval(value, bsplines_, workspace_);
gsl_multifit_linear_est(bsplines_, coeffs_, cov_, &result, &yerr);
}
return result;
}
void
test_estimator ()
{
gsl_vector_view c;
gsl_matrix_view cov;
gsl_vector_view x;
double y, y_err;
double cov_ij[25] = {
4.271520, -0.526675, 0.957930, 0.267750, -0.103610,
-0.526675, 5.701680, -0.098080, 0.641845, 0.429780,
0.957930, -0.098080, 4.584790, 0.375865, 1.510810,
0.267750, 0.641845, 0.375865, 4.422720, 0.392210,
-0.103610, 0.429780, 1.510810, 0.392210, 5.782750
};
double c_i[5] = {
-0.627020, 0.848674, 0.216877, -0.057883, 0.596668
};
double x_i[5] = {
0.99932, 0.23858, 0.19797, 1.44008, -0.15335
};
double y_expected = -5.56037032230000e-01;
double yerr_expected = 3.91891123349318e+00;
cov = gsl_matrix_view_array(cov_ij, 5, 5);
c = gsl_vector_view_array(c_i, 5);
x = gsl_vector_view_array(x_i, 5);
gsl_multifit_linear_est(&x.vector , &c.vector, &cov.matrix, &y, &y_err);
gsl_test_rel (y, y_expected, 256*GSL_DBL_EPSILON, "gsl_multifit_linear_est y");
gsl_test_rel (y_err, yerr_expected, 256*GSL_DBL_EPSILON, "gsl_multifit_linear_est yerr");
}
int
main (void)
{
const size_t n = N;
const size_t ncoeffs = NCOEFFS;
const size_t nbreak = NBREAK;
size_t i, j;
gsl_bspline_workspace *bw;
gsl_vector *B;
double dy;
gsl_rng *r;
gsl_vector *c, *w;
gsl_vector *x, *y;
gsl_matrix *X, *cov;
gsl_multifit_linear_workspace *mw;
double chisq;
double Rsq;
double dof;
gsl_rng_env_setup();
r = gsl_rng_alloc(gsl_rng_default);
/* allocate a cubic bspline workspace (k = 4) */
bw = gsl_bspline_alloc(4, nbreak);
B = gsl_vector_alloc(ncoeffs);
x = gsl_vector_alloc(n);
y = gsl_vector_alloc(n);
X = gsl_matrix_alloc(n, ncoeffs);
c = gsl_vector_alloc(ncoeffs);
w = gsl_vector_alloc(n);
cov = gsl_matrix_alloc(ncoeffs, ncoeffs);
mw = gsl_multifit_linear_alloc(n, ncoeffs);
printf("#m=0,S=0\n");
/* this is the data to be fitted */
for (i = 0; i < n; ++i)
{
double sigma;
double xi = (15.0 / (N - 1)) * i;
double yi = cos(xi) * exp(-0.1 * xi);
sigma = 0.1 * yi;
dy = gsl_ran_gaussian(r, sigma);
yi += dy;
gsl_vector_set(x, i, xi);
gsl_vector_set(y, i, yi);
gsl_vector_set(w, i, 1.0 / (sigma * sigma));
printf("%f %f\n", xi, yi);
}
/* use uniform breakpoints on [0, 15] */
gsl_bspline_knots_uniform(0.0, 15.0, bw);
/* construct the fit matrix X */
for (i = 0; i < n; ++i)
{
double xi = gsl_vector_get(x, i);
/* compute B_j(xi) for all j */
gsl_bspline_eval(xi, B, bw);
/* fill in row i of X */
for (j = 0; j < ncoeffs; ++j)
{
double Bj = gsl_vector_get(B, j);
gsl_matrix_set(X, i, j, Bj);
}
}
/* do the fit */
gsl_multifit_wlinear(X, w, y, c, cov, &chisq, mw);
dof = n - ncoeffs;
Rsq = 1.0 - chisq / gsl_stats_wtss(w->data, 1, y->data, 1, y->size);
fprintf(stderr, "chisq/dof = %e, Rsq = %f\n", chisq / dof, Rsq);
/* output the smoothed curve */
{
double xi, yi, yerr;
printf("#m=1,S=0\n");
for (xi = 0.0; xi < 15.0; xi += 0.1)
{
gsl_bspline_eval(xi, B, bw);
gsl_multifit_linear_est(B, c, cov, &yi, &yerr);
printf("%f %f\n", xi, yi);
}
}
gsl_rng_free(r);
gsl_bspline_free(bw);
gsl_vector_free(B);
gsl_vector_free(x);
gsl_vector_free(y);
gsl_matrix_free(X);
gsl_vector_free(c);
gsl_vector_free(w);
gsl_matrix_free(cov);
gsl_multifit_linear_free(mw);
return 0;
} /* main() */
void LowessSmoothing::smoothData(const DoubleVector & input_x, const DoubleVector & input_y, DoubleVector & smoothed_output)
{
if (input_x.size() != input_y.size())
{
throw Exception::InvalidValue(__FILE__, __LINE__, __PRETTY_FUNCTION__, "Sizes of x and y values not equal! Aborting... ", String(input_x.size()));
}
// unable to smooth over 2 or less data points (we need at least 3)
if (input_x.size() <= 2)
{
smoothed_output = input_y;
return;
}
Size input_size = input_y.size();
// alpha_ = 1 / ( input_size / window_size_ );
// const Size q = floor( input_size * alpha );
const Size q = (window_size_ < input_size) ? window_size_ : input_size - 1;
DoubleVector distances(input_size, 0.0);
DoubleVector sortedDistances(input_size, 0.0);
// DoubleVector smooth_yvals_Vec(input_size);
gsl_matrix * X = gsl_matrix_alloc(input_size, 3);
gsl_matrix * cov = gsl_matrix_alloc(3, 3);
gsl_vector * weights = gsl_vector_alloc(input_size);
gsl_vector * c = gsl_vector_alloc(3);
gsl_vector * x = gsl_vector_alloc(3);
gsl_vector * yvals_ = gsl_vector_alloc(input_size);
DoubleReal y, yErr, chisq;
// Setup the model matrix X for a quadratic fit.
// yvals_ = new double[input_size];
// Size idx = 0;
for (Size p_idx = 0; p_idx < input_y.size(); ++p_idx)
{
DoubleReal rt = input_x[p_idx];
gsl_matrix_set(X, p_idx, 0, 1.0);
gsl_matrix_set(X, p_idx, 1, rt);
gsl_matrix_set(X, p_idx, 2, rt * rt);
gsl_vector_set(yvals_, p_idx, input_y[p_idx]);
// ++idx;
}
//for(DoubleVector::const_iterator outer_peak_it = input_y.begin(); outer_peak_it != input_y.end(); ++outer_peak_it )
for (Size outer_idx = 0; outer_idx < input_y.size(); ++outer_idx)
{
// Compute distances.
// Size inner_idx = 0;
for (Size inner_idx = 0; inner_idx < input_y.size(); ++inner_idx)
{
distances[inner_idx] = std::fabs(input_x[outer_idx] - input_x[inner_idx]);
sortedDistances[inner_idx] = distances[inner_idx];
// ++inner_idx;
}
// Sort distances in order from smallest to largest.
// std::sort(sortedDistances, sortedDistances + input_size);
std::sort(sortedDistances.begin(), sortedDistances.end());
// Compute weights.
for (Size inner_idx = 0; inner_idx < input_size; ++inner_idx)
{
gsl_vector_set(weights, inner_idx, tricube_(distances[inner_idx], sortedDistances[q]));
}
gsl_multifit_linear_workspace * work = gsl_multifit_linear_alloc(input_size, 3);
gsl_multifit_wlinear(X, weights, yvals_, c, cov, &chisq, work);
gsl_multifit_linear_free(work);
DoubleReal rt = input_x[outer_idx];
gsl_vector_set(x, 0, 1.0);
gsl_vector_set(x, 1, rt);
gsl_vector_set(x, 2, rt * rt);
gsl_multifit_linear_est(x, c, cov, &y, &yErr);
smoothed_output.push_back(y);
}
gsl_matrix_free(X);
gsl_vector_free(weights);
gsl_vector_free(c);
gsl_matrix_free(cov);
return;
}
/** Executes the algorithm
*
*/
void SplineBackground::exec()
{
API::MatrixWorkspace_sptr inWS = getProperty("InputWorkspace");
int spec = getProperty("WorkspaceIndex");
if (spec > static_cast<int>(inWS->getNumberHistograms()))
throw std::out_of_range("WorkspaceIndex is out of range.");
const MantidVec& X = inWS->readX(spec);
const MantidVec& Y = inWS->readY(spec);
const MantidVec& E = inWS->readE(spec);
const bool isHistogram = inWS->isHistogramData();
const int ncoeffs = getProperty("NCoeff");
const int k = 4; // order of the spline + 1 (cubic)
const int nbreak = ncoeffs - (k - 2);
if (nbreak <= 0)
throw std::out_of_range("Too low NCoeff");
gsl_bspline_workspace *bw;
gsl_vector *B;
gsl_vector *c, *w, *x, *y;
gsl_matrix *Z, *cov;
gsl_multifit_linear_workspace *mw;
double chisq;
int n = static_cast<int>(Y.size());
bool isMasked = inWS->hasMaskedBins(spec);
std::vector<int> masked(Y.size());
if (isMasked)
{
for(API::MatrixWorkspace::MaskList::const_iterator it=inWS->maskedBins(spec).begin();it!=inWS->maskedBins(spec).end();++it)
masked[it->first] = 1;
n -= static_cast<int>(inWS->maskedBins(spec).size());
}
if (n < ncoeffs)
{
g_log.error("Too many basis functions (NCoeff)");
throw std::out_of_range("Too many basis functions (NCoeff)");
}
/* allocate a cubic bspline workspace (k = 4) */
bw = gsl_bspline_alloc(k, nbreak);
B = gsl_vector_alloc(ncoeffs);
x = gsl_vector_alloc(n);
y = gsl_vector_alloc(n);
Z = gsl_matrix_alloc(n, ncoeffs);
c = gsl_vector_alloc(ncoeffs);
w = gsl_vector_alloc(n);
cov = gsl_matrix_alloc(ncoeffs, ncoeffs);
mw = gsl_multifit_linear_alloc(n, ncoeffs);
/* this is the data to be fitted */
int j = 0;
for (MantidVec::size_type i = 0; i < Y.size(); ++i)
{
if (isMasked && masked[i]) continue;
gsl_vector_set(x, j, (isHistogram ? (0.5*(X[i]+X[i+1])) : X[i])); // Middle of the bins, if a histogram
gsl_vector_set(y, j, Y[i]);
gsl_vector_set(w, j, E[i]>0.?1./(E[i]*E[i]):0.);
++j;
}
if (n != j)
{
gsl_bspline_free(bw);
gsl_vector_free(B);
gsl_vector_free(x);
gsl_vector_free(y);
gsl_matrix_free(Z);
gsl_vector_free(c);
gsl_vector_free(w);
gsl_matrix_free(cov);
gsl_multifit_linear_free(mw);
throw std::runtime_error("Assertion failed: n != j");
}
double xStart = X.front();
double xEnd = X.back();
/* use uniform breakpoints */
gsl_bspline_knots_uniform(xStart, xEnd, bw);
/* construct the fit matrix X */
for (int i = 0; i < n; ++i)
{
double xi=gsl_vector_get(x, i);
/* compute B_j(xi) for all j */
gsl_bspline_eval(xi, B, bw);
/* fill in row i of X */
for (j = 0; j < ncoeffs; ++j)
{
double Bj = gsl_vector_get(B, j);
gsl_matrix_set(Z, i, j, Bj);
}
}
/* do the fit */
gsl_multifit_wlinear(Z, w, y, c, cov, &chisq, mw);
/* output the smoothed curve */
API::MatrixWorkspace_sptr outWS = WorkspaceFactory::Instance().create(inWS,1,X.size(),Y.size());
{
outWS->getAxis(1)->setValue(0, inWS->getAxis(1)->spectraNo(spec));
double xi, yi, yerr;
for (MantidVec::size_type i=0;i<Y.size();i++)
{
xi = X[i];
gsl_bspline_eval(xi, B, bw);
gsl_multifit_linear_est(B, c, cov, &yi, &yerr);
outWS->dataY(0)[i] = yi;
outWS->dataE(0)[i] = yerr;
}
outWS->dataX(0) = X;
}
gsl_bspline_free(bw);
gsl_vector_free(B);
gsl_vector_free(x);
gsl_vector_free(y);
gsl_matrix_free(Z);
gsl_vector_free(c);
gsl_vector_free(w);
gsl_matrix_free(cov);
gsl_multifit_linear_free(mw);
setProperty("OutputWorkspace",outWS);
}
// [[Rcpp::export]]
Rcpp::List fitData(Rcpp::DataFrame ds) {
const size_t ncoeffs = NCOEFFS;
const size_t nbreak = NBREAK;
const size_t n = N;
size_t i, j;
Rcpp::DataFrame D(ds); // construct the data.frame object
RcppGSL::vector<double> y = D["y"]; // access columns by name,
RcppGSL::vector<double> x = D["x"]; // assigning to GSL vectors
RcppGSL::vector<double> w = D["w"];
gsl_bspline_workspace *bw;
gsl_vector *B;
gsl_vector *c;
gsl_matrix *X, *cov;
gsl_multifit_linear_workspace *mw;
double chisq, Rsq, dof, tss;
bw = gsl_bspline_alloc(4, nbreak); // allocate a cubic bspline workspace (k = 4)
B = gsl_vector_alloc(ncoeffs);
X = gsl_matrix_alloc(n, ncoeffs);
c = gsl_vector_alloc(ncoeffs);
cov = gsl_matrix_alloc(ncoeffs, ncoeffs);
mw = gsl_multifit_linear_alloc(n, ncoeffs);
gsl_bspline_knots_uniform(0.0, 15.0, bw); // use uniform breakpoints on [0, 15]
for (i = 0; i < n; ++i) { // construct the fit matrix X
double xi = gsl_vector_get(x, i);
gsl_bspline_eval(xi, B, bw); // compute B_j(xi) for all j
for (j = 0; j < ncoeffs; ++j) { // fill in row i of X
double Bj = gsl_vector_get(B, j);
gsl_matrix_set(X, i, j, Bj);
}
}
gsl_multifit_wlinear(X, w, y, c, cov, &chisq, mw); // do the fit
dof = n - ncoeffs;
tss = gsl_stats_wtss(w->data, 1, y->data, 1, y->size);
Rsq = 1.0 - chisq / tss;
Rcpp::NumericVector FX(151), FY(151); // output the smoothed curve
double xi, yi, yerr;
for (xi = 0.0, i=0; xi < 15.0; xi += 0.1, i++) {
gsl_bspline_eval(xi, B, bw);
gsl_multifit_linear_est(B, c, cov, &yi, &yerr);
FX[i] = xi;
FY[i] = yi;
}
Rcpp::List res =
Rcpp::List::create(Rcpp::Named("X")=FX,
Rcpp::Named("Y")=FY,
Rcpp::Named("chisqdof")=Rcpp::wrap(chisq/dof),
Rcpp::Named("rsq")=Rcpp::wrap(Rsq));
gsl_bspline_free(bw);
gsl_vector_free(B);
gsl_matrix_free(X);
gsl_vector_free(c);
gsl_matrix_free(cov);
gsl_multifit_linear_free(mw);
y.free();
x.free();
w.free();
return(res);
}
void bSplineGSLOriginalDemo ()
{
const size_t n = N;
const size_t ncoeffs = NCOEFFS;
const size_t nbreak = NBREAK;
size_t i, j;
gsl_bspline_workspace *bw;
gsl_vector *B;
double dy;
gsl_rng *r;
gsl_vector *c, *w;
gsl_vector *x, *y;
gsl_matrix *X, *cov;
gsl_multifit_linear_workspace *mw;
double chisq, Rsq, dof, tss;
vector<double> xControl, yControl, xFit, yFit;
gsl_rng_env_setup();
r = gsl_rng_alloc(gsl_rng_default);
/* allocate a cubic bspline workspace (k = 4) */
bw = gsl_bspline_alloc(4, nbreak);
B = gsl_vector_alloc(ncoeffs);
x = gsl_vector_alloc(n);
y = gsl_vector_alloc(n);
X = gsl_matrix_alloc(n, ncoeffs);
c = gsl_vector_alloc(ncoeffs);
w = gsl_vector_alloc(n);
cov = gsl_matrix_alloc(ncoeffs, ncoeffs);
mw = gsl_multifit_linear_alloc(n, ncoeffs);
printf("#m=0,S=0\n");
/* this is the data to be fitted */
for (i = 0; i < n; ++i)
{
double sigma;
double xi = (15.0 / (N - 1)) * i;
double yi = cos(xi) * exp(-0.1 * xi);
sigma = 0.1 * yi;
dy = gsl_ran_gaussian(r, sigma);
yi += dy;
gsl_vector_set(x, i, xi);
xControl.push_back(xi);
gsl_vector_set(y, i, yi);
yControl.push_back(yi);
gsl_vector_set(w, i, 1.0 / (sigma * sigma));
printf("%f %f\n", xi, yi);
}
/* use uniform breakpoints on [0, 15] */
gsl_bspline_knots_uniform(0.0, 15.0, bw);
/* construct the fit matrix X */
for (i = 0; i < n; ++i)
{
double xi = gsl_vector_get(x, i);
/* compute B_j(xi) for all j */
gsl_bspline_eval(xi, B, bw);
/* fill in row i of X */
for (j = 0; j < ncoeffs; ++j)
{
double Bj = gsl_vector_get(B, j);
gsl_matrix_set(X, i, j, Bj);
}
}
/* do the fit */
gsl_multifit_wlinear(X, w, y, c, cov, &chisq, mw);
dof = n - ncoeffs;
tss = gsl_stats_wtss(w->data, 1, y->data, 1, y->size);
Rsq = 1.0 - chisq / tss;
fprintf(stderr, "chisq/dof = %e, Rsq = %f\n",
chisq / dof, Rsq);
/* output the smoothed curve */
{
double xi, yi, yerr;
printf("#m=1,S=0\n");
for (xi = 0.0; xi < 15.0; xi += 0.1)
{
gsl_bspline_eval(xi, B, bw);
gsl_multifit_linear_est(B, c, cov, &yi, &yerr);
xFit.push_back(xi);
yFit.push_back(yi);
printf("%f %f\n", xi, yi);
}
}
gsl_rng_free(r);
gsl_bspline_free(bw);
gsl_vector_free(B);
gsl_vector_free(x);
gsl_vector_free(y);
gsl_matrix_free(X);
gsl_vector_free(c);
gsl_vector_free(w);
gsl_matrix_free(cov);
gsl_multifit_linear_free(mw);
TGraph *gr = LoadGraphFromVectors(xControl, yControl);
TGraph *grFit = LoadGraphFromVectors(xFit, yFit);
gr->SetMarkerColor(kRed);
TCanvas *c1 = new TCanvas("c1", "Graph", 200, 10, 700, 500);
gr->Draw("apz");
grFit->Draw("SAME");
c1->Update();
}
/*=============================================================================
* FITTING CODE
*=============================================================================*/
int find_best_alpha(){
//double alpha_2pcf[num_alpha][nr], trials_2pcf[num_alpha][ntrials][total_nr], alpha_err[num_alpha][nr];
double **alpha_2pcf, ***trials_2pcf, **alpha_err;
double low, high, da;
long i,nend,k,j,ir,jk;
double chi2;
double yi,yerr,xi,minerr;
int nbreak, iii,ind,min_ind,max_ind;
long thisseed[Nalpha*num_alpha*ntrials];
#ifdef ALLOUT
char Output2PCF[LINELENGTH];
char ThisFile[15];
#endif
ncoeffs = num_alpha-1;
nbreak =ncoeffs-2;
// Allocate alphavec, which is our result
//alphavec = (double *) calloc(Nalpha,sizeof(double));
//betavec = (double *) calloc(Nalpha,sizeof(double));
alpha_2pcf = (double **) calloc(num_alpha,sizeof(double *));
alpha_err = (double **) calloc(num_alpha,sizeof(double *));
trials_2pcf = (double ***) calloc(num_alpha,sizeof(double **));
for (i=0;i<num_alpha;i++){
alpha_2pcf[i] = (double *) calloc(nr,sizeof(double));
alpha_err[i] = (double *) calloc(nr,sizeof(double));
trials_2pcf[i] = (double **) calloc(ntrials,sizeof(double*));
for (j=0;j<ntrials;j++)
trials_2pcf[i][j] = (double *) calloc(total_nr,sizeof(double));
}
// allocate a cubic bspline workspace (k = 4)
bw = gsl_bspline_alloc(4, nbreak);
B = gsl_vector_alloc(ncoeffs);
alpha_grid = gsl_vector_alloc(num_alpha);
chi2_alpha = gsl_vector_alloc(num_alpha);
X = gsl_matrix_alloc(num_alpha,ncoeffs);
c = gsl_vector_alloc(ncoeffs);
weights = gsl_vector_alloc(num_alpha);
cov = gsl_matrix_alloc(ncoeffs, ncoeffs);
mw = gsl_multifit_linear_alloc(num_alpha, ncoeffs);
// Loop through each mass bin
nend = 0;
iii = 0;
seed = time(NULL);
for (i=0;i<Nalpha;i++){
for(j=0;j<num_alpha;j++){
for(k=0;k<ntrials;k++){
thisseed[iii] = seed + iii;
iii++;
}
}
}
fprintf(stderr,"STARTING LOOPS...\n");
iii = 0;
for (i=0;i<Nalpha;i++){
// Get where to place halos to
nend += ncuts[i];
// Calculate a more optimum alpha_grid for this bin
if (i < 2)
low = alpha_ratio_1*best_alpha;
else{
low = alpha_ratio*best_alpha;
}
high = 1.05*best_alpha;
da = (high-low)/(num_alpha-1);
fprintf(stderr,"STARTING THREADS\n");
#ifndef NO_PAR_FIT
#pragma omp parallel for num_threads(nthreads) private(jk,j,k) \
shared(num_alpha,ntrials,i,alpha_grid,low,da,stderr,Nalpha,alphavec,iii,mcuts,ListOfParticles,\
NPartPerCell,x,y,z,Lbox,Npart,Nlin,HaloMass,nend,mpart,recalc_frac,betavec,thisseed,trials_2pcf,rho,maxr,\
total_nr,Nhalos) default(none)
#endif
for(jk=0;jk<num_alpha*ntrials;jk++){
fprintf(stderr,"Thread %d/%d\n",omp_get_thread_num(),omp_get_num_threads());
float *hx,*hy,*hz,*hR;
double *thisalphavec;
double *ercorr;
unsigned long long *DD;
hx = (float *) calloc(Nhalos,sizeof(float));
hy = (float *) calloc(Nhalos,sizeof(float));
hz = (float *) calloc(Nhalos,sizeof(float));
hR = (float *) calloc(Nhalos,sizeof(float));
thisalphavec = (double *) calloc(Nalpha,sizeof(double));
DD = (unsigned long long *) calloc(total_nr,sizeof(unsigned long long));
ercorr = (double *) calloc(total_nr,sizeof(double));
k=jk%ntrials;
j=jk/ntrials;
fprintf(stderr,"MOVED MEMORY\n");
fprintf(stderr,"GOT k,j: %ld, %ld\n",k,j);
fprintf(stderr,"sizeof M : %f MB\n",(Nlin*Nlin*Nlin*sizeof(double)/1024./1024.));
//define the alpha grid for this mass bin
gsl_vector_set(alpha_grid,j,low+j*da);
// create a local alphavec, to which we add the current gridded alpha
int itemp;
for (itemp=0;itemp<Nalpha;itemp++)
thisalphavec[itemp] = alphavec[itemp];
//fprintf(stderr,"mem copied\n");
thisalphavec[i] = gsl_vector_get(alpha_grid,j);
// Place the halos
#ifdef NO_PAR_FIT
place_halos(nend,HaloMass, Nlin, Npart, x, y, z, NULL,NULL,NULL,Lbox,
rho,thisseed[jk+i*num_alpha*ntrials],
mpart,nthreads,thisalphavec, betavec, mcuts, Nalpha, recalc_frac,hx, hy, hz,
NULL,NULL,NULL,hR,ListOfParticles,NPartPerCell);
#else
place_halos(nend,HaloMass, Nlin, Npart, x, y, z, NULL,NULL,NULL,Lbox,
rho,thisseed[jk+i*num_alpha*ntrials],
mpart,1,thisalphavec, betavec, mcuts, Nalpha, recalc_frac,hx, hy, hz,
NULL,NULL,NULL,hR,ListOfParticles,NPartPerCell);
#endif
fprintf(stderr,"correlating...\n");
//Get the 2PCF
correlate(nend, Lbox,hx,hy,hz,trials_2pcf[j][k], ercorr, DD,total_nr,maxr,1);
fprintf(stderr,"...correlated\n");
free(hx);
free(hy);
free(hz);
free(hR);
free(thisalphavec);
free(ercorr);
free(DD);
}
for (jk=0;jk<num_alpha*ntrials;jk++){
k=jk%ntrials;
j=jk/ntrials;
fprintf(stderr,"RAWCORR %ld, %ld: %e\n",j,k,trials_2pcf[j][k][0]);
}
// #pragma omp parallel for private(ir,j,chi2,k) shared(num_alpha,stderr,i,nr,alpha_2pcf) default(none)
fprintf(stderr,"GOT CORRELATIONS , GETTING CHI2...\n");
for(j=0;j<num_alpha;j++){
//Get mean and stdev of trials_2pcf
chi2 = 0.0;
for (ir=0;ir<nr;ir++){
alpha_2pcf[j][ir] = 0.0;
for(k=0;k<ntrials;k++){
alpha_2pcf[j][ir] += trials_2pcf[j][k][ir+total_nr-nr-2];
}
alpha_2pcf[j][ir] = alpha_2pcf[j][ir]/ntrials;
alpha_err[j][ir] = 0.0;
for(k=0;k<ntrials;k++){
alpha_err[j][ir] += pow((trials_2pcf[j][k][ir+total_nr-nr-2]-alpha_2pcf[j][ir]),2);
}
alpha_err[j][ir] = pow((alpha_err[j][ir]/(ntrials-1)),0.5);
// Now get chi^2 values
#ifdef REL_CHI2
chi2 += pow(((alpha_2pcf[j][ir]-nbody_2pcf[i][ir+total_nr-nr-2])/nbody_2pcf[i][ir+total_nr-nr-2]),2);
#else
chi2 += pow(((alpha_2pcf[j][ir]-nbody_2pcf[i][ir+total_nr-nr-2])/alpha_err[j][ir]),2);
#endif
fprintf(stderr,"%ld, %ld, %e, %e, %e, %e\n",j,ir,alpha_2pcf[j][ir],nbody_2pcf[i][ir+total_nr-nr-2],alpha_err[j][ir],chi2);
}
gsl_vector_set(chi2_alpha,j,chi2/nr);
gsl_vector_set(weights,j,nr/chi2);
}
// #endif //NO_PARALLEL_FIT
//*/
#ifdef ALLOUT
//OUTPUT SOME THINGS FOR CHECKING
sprintf(ThisFile,"/raw.2pcf.%ld",i);
strcpy(Output2PCF,OutputDir);
strcat(Output2PCF,ThisFile);
FILE* output_2pcf;
output_2pcf = fopen(Output2PCF,"w");
//header
fprintf(output_2pcf,"# r, ");
for (k=0;k<num_alpha;k++){
fprintf(output_2pcf,"%e\t",gsl_vector_get(alpha_grid,k));
}
fprintf(output_2pcf,"\n");
//table
for (ir=0;ir<nr;ir++){
fprintf(output_2pcf,"%e\t",(ir+total_nr-nr+0.5)*maxr/total_nr);
for(k=0;k<num_alpha-1;k++){
fprintf(output_2pcf,"%e\t",alpha_2pcf[k][ir]);
}
fprintf(output_2pcf,"%e\n",alpha_2pcf[num_alpha-1][ir]);
}
fclose(output_2pcf);
sprintf(ThisFile,"/raw.err.%ld",i);
strcpy(Output2PCF,OutputDir);
strcat(Output2PCF,ThisFile);
FILE* output_err;
output_err = fopen(Output2PCF,"w");
//header
fprintf(output_err,"# r, ");
for (k=0;k<num_alpha;k++){
fprintf(output_err,"%e\t",gsl_vector_get(alpha_grid,k));
}
fprintf(output_err,"\n");
//table
for (ir=0;ir<nr;ir++){
fprintf(output_err,"%e\t",(ir+total_nr-nr+0.5)*maxr/total_nr);
for(k=0;k<num_alpha-1;k++){
fprintf(output_err,"%e\t",alpha_err[k][ir]);
}
fprintf(output_err,"%e\n",alpha_err[num_alpha-1][ir]);
}
fclose(output_err);
sprintf(ThisFile,"/chi2.%ld",i);
strcpy(Output2PCF,OutputDir);
strcat(Output2PCF,ThisFile);
FILE* chifile;
chifile = fopen(Output2PCF,"w");
fprintf(chifile,"# alpha, chi2, weight\n");
for (k=0;k<num_alpha;k++){
fprintf(chifile,"%e\t%e\t%e\n",gsl_vector_get(alpha_grid,k),gsl_vector_get(chi2_alpha,k),
gsl_vector_get(weights,k));
}
fclose(chifile);
#endif
// Check if final value or initial value is the smallest
minerr = gsl_vector_get(chi2_alpha,0);
ind = 0;
for(k=1;k<num_alpha;k++){
if(minerr>gsl_vector_get(chi2_alpha,k)){
minerr = gsl_vector_get(chi2_alpha,k);
ind = k;
}
}
if(ind==0){
fprintf(stderr,"ERROR: alpha_grid doesn't extend low enough, set alpha_ratio lower");
}
if(ind==num_alpha-1){
fprintf(stderr,"ERROR: alpha_grid doesn't extend high enough, set best_alpha higher");
}
if (ind>=2){
min_ind = ind-2;
}else{
min_ind = 0;
}
if (ind<=num_alpha-3){
max_ind = ind+2;
}else{
max_ind = num_alpha-1;
}
/* use uniform breakpoints on interval */
gsl_bspline_knots_uniform(gsl_vector_get(alpha_grid,0), gsl_vector_get(alpha_grid,num_alpha-1), bw);
/* construct the fit matrix X */
for (k = 0; k < num_alpha; ++k){
double xi = gsl_vector_get(alpha_grid, k);
/* compute B_j(xi) for all j */
gsl_bspline_eval(xi, B, bw);
/* fill in row i of X */
for (j = 0; j < ncoeffs; ++j){
double Bj = gsl_vector_get(B, j);
gsl_matrix_set(X, k, j, Bj);
}
}
fprintf(stderr,"Got to the fit part\n");
/* do the fit */
gsl_multifit_wlinear(X, weights, chi2_alpha, c, cov, &chisq, mw);
// PRINT OUT EVERYTHING WE HAVE SO FAR
fprintf(stderr,"alpha\tchi2_alpha\t\n");
for (k=0;k<num_alpha;k++){
fprintf(stderr,"%e\t%e\t\n",gsl_vector_get(alpha_grid,k),
gsl_vector_get(chi2_alpha,k));
}
#ifdef VERB
dof = num_alpha - ncoeffs;
tss = gsl_stats_wtss(weights->data, 1, chi2_alpha->data, 1, chi2_alpha->size);
Rsq = 1.0 - chisq / tss;
fprintf(stderr, "chisq/dof = %e, Rsq = %f\n",chisq / dof, Rsq);
#endif
for (xi=gsl_vector_get(alpha_grid,0);xi<gsl_vector_get(alpha_grid,num_alpha-1);xi+=0.01){
gsl_bspline_eval(xi, B, bw);
gsl_multifit_linear_est(B, c, cov, &yi, &yerr);
fprintf(stderr,"%e\t%e\t%e\n",xi,yi,gsl_vector_get(B,0));
}
//DO THE MINIMIZATION
alphavec[i] = minimize(gsl_vector_get(alpha_grid,min_ind), gsl_vector_get(alpha_grid,max_ind),
gsl_vector_get(alpha_grid,ind));
best_alpha = alphavec[i];
fprintf(stderr,"\n Best alpha: %f\n\n",best_alpha);
}
return 0;
}
//spline locations held fixed in Mpc^-1; CMB basically fixed P(k) in these units
void dopksmoothbspline_(double *kvals, double *lnpklinear, double *lnpksmooth, int *npts) {
double kmaxsuppress = 0.01*0.7;
size_t n, ncoeffs, nbreak;
gsl_bspline_workspace *bw;
gsl_vector *B;
gsl_vector *c, *w, *x, *y;
gsl_matrix *X, *cov;
gsl_multifit_linear_workspace *mw;
double deltak,lastk;
int i,j,countkeep;
nbreak = 9;
gsl_vector *mybreaks = gsl_vector_alloc(nbreak);
gsl_vector_set(mybreaks,0,(0.001*0.7));
gsl_vector_set(mybreaks,1,(0.025*0.7));
gsl_vector_set(mybreaks,2,(0.075*0.7));
gsl_vector_set(mybreaks,3,(0.125*0.7));
gsl_vector_set(mybreaks,4,(0.175*0.7));
gsl_vector_set(mybreaks,5,(0.225*0.7));
gsl_vector_set(mybreaks,6,(0.275*0.7));
gsl_vector_set(mybreaks,7,(0.325*0.7));
gsl_vector_set(mybreaks,8,(0.375*0.7));
countkeep = 0;
for(i=0;i<(*npts);i++) {
if((kvals[i]) >= gsl_vector_get(mybreaks,0) && (kvals[i]) <= gsl_vector_get(mybreaks,nbreak-1)) {
countkeep += 1;
}
}
n = countkeep;
ncoeffs = nbreak + 2;
/* allocate a cubic bspline workspace (k = 4) */
bw = gsl_bspline_alloc(4, nbreak);
B = gsl_vector_alloc(ncoeffs);
x = gsl_vector_alloc(n);
y = gsl_vector_alloc(n);
X = gsl_matrix_alloc(n, ncoeffs);
c = gsl_vector_alloc(ncoeffs);
w = gsl_vector_alloc(n);
cov = gsl_matrix_alloc(ncoeffs, ncoeffs);
mw = gsl_multifit_linear_alloc(n, ncoeffs);
i=0;
for(j=0;j<(*npts);j++) {
if((kvals[j]) >= gsl_vector_get(mybreaks,0) && (kvals[j]) <= gsl_vector_get(mybreaks,nbreak-1)) {
gsl_vector_set(x,i,(kvals[j]));
gsl_vector_set(y,i,exp(lnpklinear[j])*pow(kvals[j],1.5));
if(j>0) {
deltak = kvals[j] - kvals[j-1];
}
else {
deltak = kvals[0];
if(kvals[1] - kvals[0] < deltak) {
deltak = kvals[1]-kvals[0];
}
}
gsl_vector_set(w,i,deltak);
i+=1;
}
}
gsl_bspline_knots(mybreaks,bw);
for(i=0;i<n;i++) {
double xi = gsl_vector_get(x,i);
gsl_bspline_eval(xi,B,bw);
for(j=0;j<ncoeffs;j++) {
double Bj = gsl_vector_get(B,j);
gsl_matrix_set(X,i,j,Bj);
}
}
//do fit
double yi,yierr,chisq;
gsl_multifit_wlinear(X,w,y,c,cov,&chisq,mw);
i = 0;
for(j=0;j<(*npts);j++) {
if((kvals[j]) >= gsl_vector_get(mybreaks,0) && (kvals[j]) <= gsl_vector_get(mybreaks,nbreak-1)) {
gsl_bspline_eval(gsl_vector_get(x,i),B,bw);
gsl_multifit_linear_est(B,c,cov,&yi,&yierr);
lnpksmooth[j] = log(yi*pow(kvals[j],-1.5));
i += 1;
}
else {
lnpksmooth[j] = lnpklinear[j];
}
//spline is wacky at small k -- suppress difference at k < 0.01
if(kvals[j] < kmaxsuppress) {
lnpksmooth[j] = lnpklinear[j];
}
}
assert(i==n);
gsl_bspline_free(bw);
gsl_vector_free(B);
gsl_vector_free(x);
gsl_vector_free(y);
gsl_vector_free(mybreaks);
gsl_matrix_free(X);
gsl_vector_free(c);
gsl_vector_free(w);
gsl_matrix_free(cov);
gsl_multifit_linear_free(mw);
}
