mirror of
https://bitbucket.org/cosmicvoids/vide_public.git
synced 2025-07-04 15:21:11 +00:00
Slight re-organization of C/C++ tools. Significant modifications to support observational data. Python and pipeline scripts added
This commit is contained in:
P.M. Sutter
parent
15496df4ff
commit
14abbc2018
42 changed files with 16252 additions and 557 deletions
|
|
@ -14,6 +14,8 @@ struct ZobovVoid
|
||||||
float proba;
|
float proba;
|
||||||
int numParticles, coreParticle;
|
int numParticles, coreParticle;
|
||||||
float volume;
|
float volume;
|
||||||
|
float barycenter[3];
|
||||||
|
float nearestBoundary;
|
||||||
};
|
};
|
||||||
|
|
||||||
struct ZobovRep
|
struct ZobovRep
|
||||||
|
|
@ -12,7 +12,7 @@ bool loadParticleInfo(ParticleInfo& info,
|
||||||
int numpart;
|
int numpart;
|
||||||
|
|
||||||
NcFile f_info(extra_info.c_str());
|
NcFile f_info(extra_info.c_str());
|
||||||
|
|
||||||
if (!f_info.is_valid())
|
if (!f_info.is_valid())
|
||||||
return false;
|
return false;
|
||||||
|
|
||||||
|
|
@ -22,6 +22,7 @@ bool loadParticleInfo(ParticleInfo& info,
|
||||||
info.ranges[1][1] = f_info.get_att("range_y_max")->as_double(0);
|
info.ranges[1][1] = f_info.get_att("range_y_max")->as_double(0);
|
||||||
info.ranges[2][0] = f_info.get_att("range_z_min")->as_double(0);
|
info.ranges[2][0] = f_info.get_att("range_z_min")->as_double(0);
|
||||||
info.ranges[2][1] = f_info.get_att("range_z_max")->as_double(0);
|
info.ranges[2][1] = f_info.get_att("range_z_max")->as_double(0);
|
||||||
|
info.mask_index = f_info.get_att("mask_index")->as_int(0); //PMS
|
||||||
|
|
||||||
for (int i = 0; i < 3; i++)
|
for (int i = 0; i < 3; i++)
|
||||||
info.length[i] = info.ranges[i][1] - info.ranges[i][0];
|
info.length[i] = info.ranges[i][1] - info.ranges[i][0];
|
||||||
|
|
@ -15,6 +15,7 @@ struct ParticleInfo
|
||||||
ParticleVector particles;
|
ParticleVector particles;
|
||||||
float ranges[3][2];
|
float ranges[3][2];
|
||||||
float length[3];
|
float length[3];
|
||||||
|
int mask_index; // PMS
|
||||||
};
|
};
|
||||||
|
|
||||||
bool loadParticleInfo(ParticleInfo& info,
|
bool loadParticleInfo(ParticleInfo& info,
|
||||||
531
c_tools/mock/generateFromCatalog.cpp
Normal file
531
c_tools/mock/generateFromCatalog.cpp
Normal file
|
|
@ -0,0 +1,531 @@
|
||||||
|
#include <healpix_map.h>
|
||||||
|
#include <healpix_map_fitsio.h>
|
||||||
|
#include <boost/format.hpp>
|
||||||
|
#include <iostream>
|
||||||
|
#include <fstream>
|
||||||
|
#include <vector>
|
||||||
|
#include <string>
|
||||||
|
#include "generateFromCatalog_conf.h"
|
||||||
|
#include "contour_pixels.hpp"
|
||||||
|
#include <netcdfcpp.h>
|
||||||
|
#include <CosmoTool/fortran.hpp>
|
||||||
|
#include <gsl/gsl_interp.h>
|
||||||
|
#include <gsl/gsl_integration.h>
|
||||||
|
|
||||||
|
#define LIGHT_SPEED 299792.458
|
||||||
|
|
||||||
|
using namespace std;
|
||||||
|
using boost::format;
|
||||||
|
using namespace CosmoTool;
|
||||||
|
|
||||||
|
struct NYU_Data
|
||||||
|
{
|
||||||
|
int index;
|
||||||
|
int sector;
|
||||||
|
int region;
|
||||||
|
double ra, dec;
|
||||||
|
double cz;
|
||||||
|
double fgotten;
|
||||||
|
double phi_z;
|
||||||
|
};
|
||||||
|
|
||||||
|
struct Position
|
||||||
|
{
|
||||||
|
double xyz[3];
|
||||||
|
};
|
||||||
|
|
||||||
|
struct ParticleData
|
||||||
|
{
|
||||||
|
vector<int> id_gal;
|
||||||
|
vector<double> ra;
|
||||||
|
vector<double> dec;
|
||||||
|
vector<double> redshift;
|
||||||
|
int id_mask;
|
||||||
|
// PMS
|
||||||
|
int mask_index;
|
||||||
|
// END PMS
|
||||||
|
vector<Position> pos;
|
||||||
|
double box[3][2];
|
||||||
|
double Lmax;
|
||||||
|
};
|
||||||
|
|
||||||
|
typedef vector<NYU_Data> NYU_VData;
|
||||||
|
|
||||||
|
// this defines the expansion function that we will integrate
|
||||||
|
// Laveaux & Wandelt (2012) Eq. 24
|
||||||
|
struct my_expan_params { double Om; double w0; double wa; };
|
||||||
|
double expanFun (double z, void * p) {
|
||||||
|
struct my_expan_params * params = (struct my_expan_params *)p;
|
||||||
|
double Om = (params->Om);
|
||||||
|
double w0 = (params->w0);
|
||||||
|
double wa = (params->wa);
|
||||||
|
|
||||||
|
//const double h0 = 1.0;
|
||||||
|
const double h0 = 0.71;
|
||||||
|
double ez;
|
||||||
|
|
||||||
|
double wz = w0 + wa*z/(1+z);
|
||||||
|
|
||||||
|
ez = Om*pow(1+z,3) + (1.-Om);
|
||||||
|
//ez = Om*pow(1+z,3) + pow(h0,2) * (1.-Om)*pow(1+z,3+3*wz);
|
||||||
|
|
||||||
|
ez = sqrt(ez);
|
||||||
|
//ez = sqrt(ez)/h0;
|
||||||
|
|
||||||
|
ez = 1./ez;
|
||||||
|
|
||||||
|
return ez;
|
||||||
|
}
|
||||||
|
|
||||||
|
void loadData(const string& fname, NYU_VData & data)
|
||||||
|
{
|
||||||
|
ifstream f(fname.c_str());
|
||||||
|
|
||||||
|
while (!f.eof())
|
||||||
|
{
|
||||||
|
NYU_Data d;
|
||||||
|
f >> d.index >> d.sector >> d.region >> d.ra >> d.dec >> d.cz >> d.fgotten >> d.phi_z;
|
||||||
|
data.push_back(d);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
void generateGalaxiesInCube(NYU_VData& data, ParticleData& output_data,
|
||||||
|
bool useLCDM)
|
||||||
|
{
|
||||||
|
double d2r = M_PI/180;
|
||||||
|
|
||||||
|
gsl_function expanF;
|
||||||
|
expanF.function = &expanFun;
|
||||||
|
struct my_expan_params expanParams;
|
||||||
|
double maxZ = 2.0, z, result, error, *dL, *redshifts;
|
||||||
|
int numZ = 1000, iZ;
|
||||||
|
size_t nEval;
|
||||||
|
|
||||||
|
expanParams.Om = 0.27;
|
||||||
|
expanParams.w0 = -1.0;
|
||||||
|
expanParams.wa = 0.0;
|
||||||
|
expanF.params = &expanParams;
|
||||||
|
|
||||||
|
dL = (double *) malloc(numZ * sizeof(double));
|
||||||
|
redshifts = (double *) malloc(numZ * sizeof(double));
|
||||||
|
|
||||||
|
for (iZ = 0; iZ < numZ; iZ++) {
|
||||||
|
z = iZ * maxZ/numZ;
|
||||||
|
//gsl_integration_qng(&expanF, 0.0, z, 1.e-6, 1.e-6, &result, &error, &nEval);
|
||||||
|
dL[iZ] = result;
|
||||||
|
redshifts[iZ] = z;
|
||||||
|
}
|
||||||
|
|
||||||
|
gsl_interp *interp = gsl_interp_alloc(gsl_interp_linear, numZ);
|
||||||
|
gsl_interp_init(interp, redshifts, dL, numZ);
|
||||||
|
gsl_interp_accel *acc = gsl_interp_accel_alloc();
|
||||||
|
|
||||||
|
output_data.pos.resize(data.size());
|
||||||
|
output_data.id_gal.resize(data.size());
|
||||||
|
output_data.ra.resize(data.size());
|
||||||
|
output_data.dec.resize(data.size());
|
||||||
|
output_data.redshift.resize(data.size());
|
||||||
|
|
||||||
|
for (int j = 0; j < 3; j++)
|
||||||
|
{
|
||||||
|
output_data.box[j][0] = -INFINITY;
|
||||||
|
output_data.box[j][1] = INFINITY;
|
||||||
|
}
|
||||||
|
|
||||||
|
for (int i = 0; i < data.size(); i++)
|
||||||
|
{
|
||||||
|
double ra = data[i].ra*d2r, dec = data[i].dec*d2r;
|
||||||
|
Position& p = output_data.pos[i];
|
||||||
|
|
||||||
|
if (useLCDM) {
|
||||||
|
//double pos = gsl_interp_eval(interp, redshifts, dL, data[i].cz, acc);
|
||||||
|
gsl_integration_qng(&expanF, 1.e-6, data[i].cz/LIGHT_SPEED,
|
||||||
|
1.e-6,
|
||||||
|
1.e-6, &result, &error, &nEval);
|
||||||
|
double Dc = result*LIGHT_SPEED;
|
||||||
|
cout << "HELLO " << data[i].cz << " " << Dc << endl;
|
||||||
|
p.xyz[0] = Dc*cos(ra)*cos(dec);
|
||||||
|
p.xyz[1] = Dc*sin(ra)*cos(dec);
|
||||||
|
p.xyz[2] = Dc*sin(dec);
|
||||||
|
} else {
|
||||||
|
p.xyz[0] = data[i].cz*cos(ra)*cos(dec);
|
||||||
|
p.xyz[1] = data[i].cz*sin(ra)*cos(dec);
|
||||||
|
p.xyz[2] = data[i].cz*sin(dec);
|
||||||
|
}
|
||||||
|
//printf("CREATE %e %e\n", data[i].cz, sqrt(p.xyz[0]*p.xyz[0] + p.xyz[1]*p.xyz[1] + p.xyz[2]*p.xyz[2]));
|
||||||
|
output_data.id_gal[i] = data[i].index;
|
||||||
|
output_data.ra[i] = ra;
|
||||||
|
output_data.dec[i] = dec;
|
||||||
|
output_data.redshift[i] = data[i].cz;
|
||||||
|
|
||||||
|
for (int j = 0; j < 3; j++)
|
||||||
|
{
|
||||||
|
if (p.xyz[j] > output_data.box[j][0])
|
||||||
|
output_data.box[j][0] = p.xyz[j];
|
||||||
|
if (p.xyz[j] < output_data.box[j][1])
|
||||||
|
output_data.box[j][1] = p.xyz[j];
|
||||||
|
}
|
||||||
|
//printf("INSERT GAL %d %e %e %e\n", output_data.id_gal[i], p.xyz[0], p.xyz[1], p.xyz[2]);
|
||||||
|
}
|
||||||
|
cout << format("Galaxy position generated: %d galaxies") % output_data.pos.size() << endl;
|
||||||
|
cout << format("box is %g < x < %g; %g < y < %g; %g < z < %g")
|
||||||
|
% (1e-2*output_data.box[0][1]) % (1e-2*output_data.box[0][0])
|
||||||
|
% (1e-2*output_data.box[1][1]) % (1e-2*output_data.box[1][0])
|
||||||
|
% (1e-2*output_data.box[2][1]) % (1e-2*output_data.box[2][0]) << endl;
|
||||||
|
|
||||||
|
gsl_interp_free(interp);
|
||||||
|
}
|
||||||
|
|
||||||
|
void generateSurfaceMask(generateFromCatalog_info& args ,
|
||||||
|
Healpix_Map<float>& mask,
|
||||||
|
vector<int>& pixel_list,
|
||||||
|
vector<int>& full_mask_list,
|
||||||
|
NYU_VData& data,
|
||||||
|
ParticleData& output_data)
|
||||||
|
{
|
||||||
|
// Find the first free index
|
||||||
|
int idx = -1;
|
||||||
|
int insertion = 0;
|
||||||
|
double volume = pixel_list.size()*1.0/mask.Npix()*4*M_PI;
|
||||||
|
int numToInsert;
|
||||||
|
|
||||||
|
for (int i = 0; i < output_data.id_gal.size(); i++)
|
||||||
|
{
|
||||||
|
if (idx < output_data.id_gal[i])
|
||||||
|
idx = output_data.id_gal[i]+1;
|
||||||
|
}
|
||||||
|
|
||||||
|
output_data.id_mask = idx;
|
||||||
|
|
||||||
|
// PMS
|
||||||
|
output_data.mask_index = output_data.id_gal.size();
|
||||||
|
// END PMS
|
||||||
|
cout << "Generate surface mask..." << endl;
|
||||||
|
|
||||||
|
double Rmax = -1;
|
||||||
|
for (int j = 0; j < 3; j++)
|
||||||
|
{
|
||||||
|
Rmax = max(Rmax, max(output_data.box[j][0], -output_data.box[j][1]));
|
||||||
|
}
|
||||||
|
|
||||||
|
output_data.Lmax = Rmax;
|
||||||
|
|
||||||
|
// PMS - write a small text file with galaxy position
|
||||||
|
FILE *fp;
|
||||||
|
fp = fopen("galaxies.txt", "w");
|
||||||
|
for (int i = 0; i < data.size(); i++) {
|
||||||
|
Position& p = output_data.pos[i];
|
||||||
|
fprintf(fp, "%e %e %e\n",
|
||||||
|
(p.xyz[0]),
|
||||||
|
(p.xyz[1]),
|
||||||
|
(p.xyz[2]));
|
||||||
|
}
|
||||||
|
fclose(fp);
|
||||||
|
// END PMS
|
||||||
|
|
||||||
|
cout << format("Rmax is %g, surface volume is %g") % (Rmax/100) % (volume/(4*M_PI)) << endl;
|
||||||
|
volume *= Rmax*Rmax*Rmax/3/1e6;
|
||||||
|
numToInsert = (int)floor(volume*args.density_fake_arg);
|
||||||
|
cout << format("3d volume to fill: %g (Mpc/h)^3") % volume << endl;
|
||||||
|
|
||||||
|
cout << format("Will insert %d particles") % numToInsert << endl;
|
||||||
|
|
||||||
|
fp = fopen("mock_galaxies.txt", "w");
|
||||||
|
|
||||||
|
double pct = 0;
|
||||||
|
for (int i = 0; i < numToInsert; i++) {
|
||||||
|
double new_pct = i*100./numToInsert;
|
||||||
|
|
||||||
|
if (new_pct-pct > 5.) {
|
||||||
|
pct = new_pct;
|
||||||
|
cout << format(" .. %3.0f %%") % pct << endl;
|
||||||
|
}
|
||||||
|
|
||||||
|
Position p;
|
||||||
|
bool stop_here;
|
||||||
|
|
||||||
|
do {
|
||||||
|
int p0 = (int)floor(drand48()*pixel_list.size());
|
||||||
|
vec3 v = mask.pix2vec(pixel_list[p0]);
|
||||||
|
double r = Rmax*pow(drand48(),1./3);
|
||||||
|
|
||||||
|
p.xyz[0] = v.x * r;
|
||||||
|
p.xyz[1] = v.y * r;
|
||||||
|
p.xyz[2] = v.z * r;
|
||||||
|
|
||||||
|
stop_here = true;
|
||||||
|
for (int j = 0; j < 3; j++) {
|
||||||
|
if (p.xyz[j] > output_data.box[j][0] ||
|
||||||
|
p.xyz[j] < output_data.box[j][1])
|
||||||
|
stop_here = false;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
while (!stop_here);
|
||||||
|
|
||||||
|
// PMS : write mock galaxies to a small file for plotting
|
||||||
|
fprintf(fp, "%e %e %e\n",
|
||||||
|
(p.xyz[0]),
|
||||||
|
(p.xyz[1]),
|
||||||
|
(p.xyz[2]));
|
||||||
|
// END PMS
|
||||||
|
output_data.pos.push_back(p);
|
||||||
|
output_data.id_gal.push_back(idx);
|
||||||
|
output_data.ra.push_back(-1);
|
||||||
|
output_data.dec.push_back(-1);
|
||||||
|
output_data.redshift.push_back(-1);
|
||||||
|
//printf("INSERT MOCK %d %e %e %e\n", idx, p.xyz[0], p.xyz[1], p.xyz[2]);
|
||||||
|
insertion++;
|
||||||
|
}
|
||||||
|
|
||||||
|
fclose(fp);
|
||||||
|
|
||||||
|
// PMS
|
||||||
|
// TEST - insert mock galaxies along box edge
|
||||||
|
fp = fopen("mock_boundary.txt", "w");
|
||||||
|
double dx[3];
|
||||||
|
dx[0] = output_data.box[0][1] - output_data.box[0][0];
|
||||||
|
dx[1] = output_data.box[1][1] - output_data.box[1][0];
|
||||||
|
dx[2] = output_data.box[2][1] - output_data.box[2][0];
|
||||||
|
|
||||||
|
int nPart = 100;
|
||||||
|
// TEST
|
||||||
|
for (int iDir = 0; iDir < 0; iDir++) {
|
||||||
|
for (int iFace = 0; iFace < 0; iFace++) {
|
||||||
|
//for (int iDir = 0; iDir < 3; iDir++) {
|
||||||
|
//for (int iFace = 0; iFace < 2; iFace++) {
|
||||||
|
|
||||||
|
int iy = (iDir + 1) % 3;
|
||||||
|
int iz = (iDir + 2) % 3;
|
||||||
|
|
||||||
|
for (int i = 0; i < nPart; i++) {
|
||||||
|
for (int j = 0; j < nPart; j++) {
|
||||||
|
Position p;
|
||||||
|
|
||||||
|
p.xyz[iDir] = output_data.box[iDir][iFace];
|
||||||
|
p.xyz[iy] = i * dx[iy]/nPart + output_data.box[iy][0];
|
||||||
|
p.xyz[iz] = j * dx[iz]/nPart + output_data.box[iz][0];
|
||||||
|
|
||||||
|
output_data.pos.push_back(p);
|
||||||
|
output_data.id_gal.push_back(idx);
|
||||||
|
output_data.ra.push_back(-1);
|
||||||
|
output_data.dec.push_back(-1);
|
||||||
|
output_data.redshift.push_back(-1);
|
||||||
|
insertion++;
|
||||||
|
|
||||||
|
fprintf(fp, "%e %e %e\n",
|
||||||
|
(p.xyz[0]),
|
||||||
|
(p.xyz[1]),
|
||||||
|
(p.xyz[2]));
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
fclose(fp);
|
||||||
|
// END PMS
|
||||||
|
|
||||||
|
// PMS
|
||||||
|
// TEST - insert mock galaxies along spheres of survey redshift boundaries
|
||||||
|
fp = fopen("mock_sphere.txt", "w");
|
||||||
|
|
||||||
|
for (int p = 0; p < full_mask_list.size(); p++) {
|
||||||
|
vec3 v = mask.pix2vec(full_mask_list[p]);
|
||||||
|
|
||||||
|
Position p;
|
||||||
|
double r = args.zMin_arg * LIGHT_SPEED;
|
||||||
|
if (r > 0.) {
|
||||||
|
p.xyz[0] = v.x * r;
|
||||||
|
p.xyz[1] = v.y * r;
|
||||||
|
p.xyz[2] = v.z * r;
|
||||||
|
output_data.pos.push_back(p);
|
||||||
|
output_data.id_gal.push_back(idx);
|
||||||
|
output_data.ra.push_back(-1);
|
||||||
|
output_data.dec.push_back(-1);
|
||||||
|
output_data.redshift.push_back(-1);
|
||||||
|
insertion++;
|
||||||
|
fprintf(fp, "%e %e %e\n",
|
||||||
|
(p.xyz[0]),
|
||||||
|
(p.xyz[1]),
|
||||||
|
(p.xyz[2]));
|
||||||
|
}
|
||||||
|
|
||||||
|
r = args.zMax_arg * LIGHT_SPEED;
|
||||||
|
p.xyz[0] = v.x * r;
|
||||||
|
p.xyz[1] = v.y * r;
|
||||||
|
p.xyz[2] = v.z * r;
|
||||||
|
output_data.pos.push_back(p);
|
||||||
|
output_data.id_gal.push_back(idx);
|
||||||
|
output_data.ra.push_back(-1);
|
||||||
|
output_data.dec.push_back(-1);
|
||||||
|
output_data.redshift.push_back(-1);
|
||||||
|
insertion++;
|
||||||
|
fprintf(fp, "%e %e %e\n",
|
||||||
|
(p.xyz[0]),
|
||||||
|
(p.xyz[1]),
|
||||||
|
(p.xyz[2]));
|
||||||
|
}
|
||||||
|
fclose(fp);
|
||||||
|
// END PMS
|
||||||
|
|
||||||
|
cout << format("Done. Inserted %d particles.") % insertion << endl;
|
||||||
|
}
|
||||||
|
|
||||||
|
void saveData(ParticleData& pdata)
|
||||||
|
{
|
||||||
|
NcFile f("particles.nc", NcFile::Replace);
|
||||||
|
|
||||||
|
assert(f.is_valid());
|
||||||
|
|
||||||
|
NcDim *d = f.add_dim("space", 3);
|
||||||
|
NcDim *p = f.add_dim("Np", pdata.pos.size());
|
||||||
|
NcVar *v = f.add_var("particles", ncDouble, d, p);
|
||||||
|
double *x = new double[pdata.pos.size()];
|
||||||
|
|
||||||
|
for (int j = 0; j < 3; j++)
|
||||||
|
{
|
||||||
|
|
||||||
|
for (int i = 0; i < pdata.pos.size(); i++)
|
||||||
|
x[i] = pdata.pos[i].xyz[j];
|
||||||
|
|
||||||
|
v->put_rec(d, x, j);
|
||||||
|
}
|
||||||
|
|
||||||
|
v = f.add_var("id_gal", ncInt, p);
|
||||||
|
v->put(&pdata.id_gal[0], pdata.id_gal.size());
|
||||||
|
|
||||||
|
delete[] x;
|
||||||
|
|
||||||
|
}
|
||||||
|
|
||||||
|
void saveForZobov(ParticleData& pdata, const string& fname, const string& paramname)
|
||||||
|
{
|
||||||
|
UnformattedWrite f(fname);
|
||||||
|
static const char axis[] = { 'X', 'Y', 'Z' };
|
||||||
|
double Lmax = pdata.Lmax;
|
||||||
|
|
||||||
|
f.beginCheckpoint();
|
||||||
|
f.writeInt32(pdata.pos.size());
|
||||||
|
f.endCheckpoint();
|
||||||
|
|
||||||
|
|
||||||
|
for (int j = 0; j < 3; j++)
|
||||||
|
{
|
||||||
|
cout << format("Writing %c components...") % axis[j] << endl;
|
||||||
|
f.beginCheckpoint();
|
||||||
|
for (uint32_t i = 0; i < pdata.pos.size(); i++)
|
||||||
|
{
|
||||||
|
f.writeReal32((pdata.pos[i].xyz[j]+Lmax)/(2*Lmax));
|
||||||
|
}
|
||||||
|
f.endCheckpoint();
|
||||||
|
}
|
||||||
|
|
||||||
|
NcFile fp(paramname.c_str(), NcFile::Replace);
|
||||||
|
|
||||||
|
fp.add_att("range_x_min", -Lmax/100.);
|
||||||
|
fp.add_att("range_x_max", Lmax/100.);
|
||||||
|
fp.add_att("range_y_min", -Lmax/100.);
|
||||||
|
fp.add_att("range_y_max", Lmax/100.);
|
||||||
|
fp.add_att("range_z_min", -Lmax/100.);
|
||||||
|
fp.add_att("range_z_max", Lmax/100.);
|
||||||
|
fp.add_att("mask_index", pdata.mask_index); // PMS
|
||||||
|
|
||||||
|
int nOutputPart = pdata.mask_index;
|
||||||
|
//int nOutputPart = pdata.pos.size();
|
||||||
|
|
||||||
|
NcDim *NumPart_dim = fp.add_dim("numpart_dim", nOutputPart);
|
||||||
|
NcVar *v = fp.add_var("particle_ids", ncInt, NumPart_dim);
|
||||||
|
NcVar *vra = fp.add_var("RA", ncInt, NumPart_dim);
|
||||||
|
NcVar *vdec = fp.add_var("DEC", ncInt, NumPart_dim);
|
||||||
|
NcVar *vredshift = fp.add_var("z", ncInt, NumPart_dim);
|
||||||
|
//NcVar *v2 = fp.add_var("expansion", ncDouble, NumPart_dim);
|
||||||
|
|
||||||
|
//double *expansion_fac = new double[pdata.pos.size()];
|
||||||
|
|
||||||
|
//for (int i = 0; i < pdata.pos.size(); i++)
|
||||||
|
// expansion_fac[i] = 1.0;
|
||||||
|
|
||||||
|
v->put(&pdata.id_gal[0], nOutputPart);
|
||||||
|
vra->put(&pdata.ra[0], nOutputPart);
|
||||||
|
vdec->put(&pdata.dec[0], nOutputPart);
|
||||||
|
vredshift->put(&pdata.redshift[0], nOutputPart);
|
||||||
|
//v2->put(expansion_fac, pdata.pos.size());
|
||||||
|
|
||||||
|
//delete[] expansion_fac;
|
||||||
|
}
|
||||||
|
|
||||||
|
int main(int argc, char **argv)
|
||||||
|
{
|
||||||
|
generateFromCatalog_info args_info;
|
||||||
|
generateFromCatalog_conf_params args_params;
|
||||||
|
|
||||||
|
generateFromCatalog_conf_init(&args_info);
|
||||||
|
generateFromCatalog_conf_params_init(&args_params);
|
||||||
|
|
||||||
|
args_params.check_required = 0;
|
||||||
|
if (generateFromCatalog_conf_ext (argc, argv, &args_info, &args_params))
|
||||||
|
return 1;
|
||||||
|
|
||||||
|
if (!args_info.configFile_given)
|
||||||
|
{
|
||||||
|
if (generateFromCatalog_conf_required (&args_info, GENERATEFROMCATALOG_CONF_PACKAGE))
|
||||||
|
return 1;
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
args_params.check_required = 1;
|
||||||
|
args_params.initialize = 0;
|
||||||
|
if (generateFromCatalog_conf_config_file (args_info.configFile_arg,
|
||||||
|
&args_info,
|
||||||
|
&args_params))
|
||||||
|
return 1;
|
||||||
|
}
|
||||||
|
|
||||||
|
generateFromCatalog_conf_print_version();
|
||||||
|
|
||||||
|
cout << "Loading NYU data..." << endl;
|
||||||
|
vector<NYU_Data> data;
|
||||||
|
Healpix_Map<float> o_mask;
|
||||||
|
vector<int> pixel_list;
|
||||||
|
vector<int> full_mask_list;
|
||||||
|
ParticleData output_data;
|
||||||
|
|
||||||
|
loadData(args_info.catalog_arg, data);
|
||||||
|
|
||||||
|
|
||||||
|
cout << "Loading mask..." << endl;
|
||||||
|
read_Healpix_map_from_fits(args_info.mask_arg, o_mask);
|
||||||
|
|
||||||
|
Healpix_Map<float> mask;
|
||||||
|
|
||||||
|
mask.SetNside(128, RING);
|
||||||
|
mask.Import(o_mask);
|
||||||
|
|
||||||
|
computeContourPixels(mask,pixel_list);
|
||||||
|
|
||||||
|
// We compute a cube holding all the galaxies + the survey surface mask
|
||||||
|
|
||||||
|
cout << "Placing galaxies..." << endl;
|
||||||
|
generateGalaxiesInCube(data, output_data, args_info.useLCDM_flag);
|
||||||
|
generateSurfaceMask(args_info, mask, pixel_list, full_mask_list,
|
||||||
|
data, output_data);
|
||||||
|
|
||||||
|
saveForZobov(output_data, args_info.output_arg, args_info.params_arg);
|
||||||
|
// saveData(output_data);
|
||||||
|
|
||||||
|
// PMS
|
||||||
|
FILE *fp = fopen("mask_index.txt", "w");
|
||||||
|
fprintf(fp, "%d", output_data.mask_index);
|
||||||
|
fclose(fp);
|
||||||
|
|
||||||
|
fp = fopen("sample_info.txt", "w");
|
||||||
|
fprintf(fp, "Lmax = %f\n", output_data.Lmax);
|
||||||
|
fprintf(fp, "mask_index = %d\n", output_data.mask_index);
|
||||||
|
fprintf(fp, "total_particles = %d\n", output_data.pos.size());
|
||||||
|
fclose(fp);
|
||||||
|
|
||||||
|
fp = fopen("total_particles.txt", "w");
|
||||||
|
fprintf(fp, "%d", output_data.pos.size());
|
||||||
|
fclose(fp);
|
||||||
|
printf("Done!\n");
|
||||||
|
// END PMS
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
|
@ -7,8 +7,11 @@ option "catalog" - "Input NYU-VAGC catalog" string required
|
||||||
option "mask" - "Healpix mask of unobserved data (in Equatorial coordinates)" string required
|
option "mask" - "Healpix mask of unobserved data (in Equatorial coordinates)" string required
|
||||||
option "density_fake" - "Number density of boundary fake tracers (1 h^3/ Mpc^3)" double optional default="1"
|
option "density_fake" - "Number density of boundary fake tracers (1 h^3/ Mpc^3)" double optional default="1"
|
||||||
|
|
||||||
|
option "zMin" - "Minimum redshift of data" double required
|
||||||
|
|
||||||
|
option "zMax" - "Maximum redshift of data" double required
|
||||||
|
|
||||||
option "output" - "Filename of particle datafile" string required
|
option "output" - "Filename of particle datafile" string required
|
||||||
option "params" - "Output parameters of the datacube" string required
|
option "params" - "Output parameters of the datacube" string required
|
||||||
|
|
||||||
option "box_thickness" - "Thickness of the limiting mask" double optional default="1"
|
option "useLCDM" - "Convert to real space using LCDM cosmology" flag off
|
||||||
option "box_density" - "Fake Galaxy density on the box" double optional default="1"
|
|
||||||
|
|
@ -18,65 +18,9 @@ using namespace CosmoTool;
|
||||||
|
|
||||||
#define LIGHT_SPEED 299792.458
|
#define LIGHT_SPEED 299792.458
|
||||||
|
|
||||||
static double gadgetUnit=1e-3;
|
|
||||||
|
|
||||||
SimuData *doLoadRamses(const char *basename, int baseid, int velAxis, bool goRedshift)
|
|
||||||
{
|
|
||||||
SimuData *d, *outd;
|
|
||||||
|
|
||||||
d = loadRamsesSimu(basename, baseid, -1, true, 0);
|
|
||||||
outd = new SimuData;
|
|
||||||
|
|
||||||
outd->NumPart = d->TotalNumPart;
|
|
||||||
outd->BoxSize = d->BoxSize;
|
|
||||||
outd->TotalNumPart = outd->NumPart;
|
|
||||||
outd->Hubble = d->Hubble;
|
|
||||||
outd->Omega_Lambda = d->Omega_Lambda;
|
|
||||||
outd->Omega_M = d->Omega_M;
|
|
||||||
outd->time = d->time;
|
|
||||||
|
|
||||||
for (int k = 0; k < 3; k++)
|
|
||||||
outd->Pos[k] = new float[outd->NumPart];
|
|
||||||
outd->Vel[2] = new float[outd->NumPart];
|
|
||||||
delete d;
|
|
||||||
|
|
||||||
int curCpu = 0;
|
|
||||||
cout << "loading cpu 0 " << endl;
|
|
||||||
while (d = loadRamsesSimu(basename, baseid, curCpu, true, NEED_POSITION|NEED_VELOCITY|NEED_GADGET_ID))
|
|
||||||
{
|
|
||||||
for (int k = 0; k < 3; k++)
|
|
||||||
for (int i = 0; i < d->NumPart; i++)
|
|
||||||
{
|
|
||||||
assert(d->Id[i] >= 1);
|
|
||||||
assert(d->Id[i] <= outd->TotalNumPart);
|
|
||||||
outd->Pos[k][d->Id[i]-1] = d->Pos[k][i];
|
|
||||||
outd->Vel[2][d->Id[i]-1] = d->Vel[velAxis][i];
|
|
||||||
}
|
|
||||||
|
|
||||||
if (goRedshift)
|
|
||||||
for (int i = 0; i < d->NumPart; i++)
|
|
||||||
outd->Pos[velAxis][d->Id[i]-1] += d->Vel[velAxis][i]/100.;
|
|
||||||
|
|
||||||
delete d;
|
|
||||||
curCpu++;
|
|
||||||
cout << "loading cpu " << curCpu << endl;
|
|
||||||
}
|
|
||||||
|
|
||||||
return outd;
|
|
||||||
}
|
|
||||||
|
|
||||||
SimuData *myLoadGadget(const char *fname, int id, int flags)
|
SimuData *myLoadGadget(const char *fname, int id, int flags)
|
||||||
{
|
{
|
||||||
SimuData *sim = loadGadgetMulti(fname, id, flags);
|
return loadGadgetMulti(fname, id, flags);
|
||||||
sim->BoxSize *= gadgetUnit*1000;
|
|
||||||
for (int j = 0; j < 3; j++)
|
|
||||||
{
|
|
||||||
if (sim->Pos[j] != 0) {
|
|
||||||
for (long i = 0; i < sim->NumPart; i++)
|
|
||||||
sim->Pos[j][i] *= gadgetUnit*1000;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
return sim;
|
|
||||||
}
|
}
|
||||||
|
|
||||||
SimuData *doLoadSimulation(const char *gadgetname, int velAxis, bool goRedshift, SimuData *(*loadFunction)(const char *fname, int id, int flags))
|
SimuData *doLoadSimulation(const char *gadgetname, int velAxis, bool goRedshift, SimuData *(*loadFunction)(const char *fname, int id, int flags))
|
||||||
|
|
@ -150,6 +94,53 @@ SimuData *doLoadSimulation(const char *gadgetname, int velAxis, bool goRedshift,
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
||||||
|
SimuData *doLoadMultidark(const char *multidarkname)
|
||||||
|
{
|
||||||
|
SimuData *outd;
|
||||||
|
FILE *fp;
|
||||||
|
int actualNumPart;
|
||||||
|
|
||||||
|
outd = new SimuData;
|
||||||
|
cout << "opening multidark file " << multidarkname << endl;
|
||||||
|
fp = fopen(multidarkname, "r");
|
||||||
|
if (fp == NULL) {
|
||||||
|
cout << "could not open file!" << endl;
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
fscanf(fp, "%f\n", &outd->BoxSize);
|
||||||
|
fscanf(fp, "%f\n", &outd->Omega_M);
|
||||||
|
fscanf(fp, "%f\n", &outd->Hubble);
|
||||||
|
fscanf(fp, "%f\n", &outd->time);
|
||||||
|
fscanf(fp, "%d\n", &outd->NumPart);
|
||||||
|
|
||||||
|
outd->time = 1./(1.+outd->time); // convert to scale factor
|
||||||
|
outd->TotalNumPart = outd->NumPart;
|
||||||
|
outd->Omega_Lambda = 1.0 - outd->Omega_M;
|
||||||
|
|
||||||
|
for (int k = 0; k < 3; k++)
|
||||||
|
outd->Pos[k] = new float[outd->NumPart];
|
||||||
|
outd->Vel[2] = new float[outd->NumPart];
|
||||||
|
|
||||||
|
cout << "loading multidark particles" << endl;
|
||||||
|
actualNumPart = 0;
|
||||||
|
for (int i = 0; i < outd->NumPart; i++) {
|
||||||
|
fscanf(fp, "%f %f %f %f\n", &outd->Pos[0][i], &outd->Pos[1][i],
|
||||||
|
&outd->Pos[2][i], &outd->Vel[2][i]);
|
||||||
|
|
||||||
|
if (outd->Pos[0][i] == -99 && outd->Pos[1][i] == -99 &&
|
||||||
|
outd->Pos[2][i] == -99 && outd->Vel[2][i] == -99) {
|
||||||
|
break;
|
||||||
|
} else {
|
||||||
|
actualNumPart++;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
fclose(fp);
|
||||||
|
|
||||||
|
outd->NumPart = actualNumPart;
|
||||||
|
outd->TotalNumPart = actualNumPart;
|
||||||
|
return outd;
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
static double cubic(double a)
|
static double cubic(double a)
|
||||||
{
|
{
|
||||||
|
|
@ -166,7 +157,7 @@ struct TotalExpansion
|
||||||
}
|
}
|
||||||
};
|
};
|
||||||
|
|
||||||
Interpolate make_cosmological_redshift(double OM, double OL, double z0, double z1, int N = 1000)
|
Interpolate make_cosmological_redshift(double OM, double OL, double z0, double z1, int N = 5000)
|
||||||
{
|
{
|
||||||
TotalExpansion e_computer;
|
TotalExpansion e_computer;
|
||||||
double D_tilde, Q, Qprime;
|
double D_tilde, Q, Qprime;
|
||||||
|
|
@ -190,7 +181,7 @@ Interpolate make_cosmological_redshift(double OM, double OL, double z0, double z
|
||||||
return buildFromVector(pairs);
|
return buildFromVector(pairs);
|
||||||
}
|
}
|
||||||
|
|
||||||
void metricTransform(SimuData *data, int axis, bool reshift, bool pecvel, double*& expfact, bool cosmo_flag)
|
void metricTransform(SimuData *data, int axis, bool reshift, bool pecvel, double*& expfact)
|
||||||
{
|
{
|
||||||
int x0, x1, x2;
|
int x0, x1, x2;
|
||||||
|
|
||||||
|
|
@ -208,25 +199,21 @@ void metricTransform(SimuData *data, int axis, bool reshift, bool pecvel, double
|
||||||
abort();
|
abort();
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
||||||
double z0 = 1/data->time - 1;
|
double z0 = 1/data->time - 1;
|
||||||
Interpolate z_vs_D = make_cosmological_redshift(data->Omega_M, data->Omega_Lambda, 0., z0+2*data->BoxSize*100/LIGHT_SPEED); // Redshift 2*z0 should be sufficient ?
|
Interpolate z_vs_D = make_cosmological_redshift(data->Omega_M, data->Omega_Lambda, 0., z0+8*data->BoxSize*100/LIGHT_SPEED); // Redshift 2*z0 should be sufficient ?
|
||||||
double z_base = reshift ? z0 : 0;
|
double z_base = reshift ? z0 : 0;
|
||||||
TotalExpansion e_computer;
|
TotalExpansion e_computer;
|
||||||
double baseComovingDistance;
|
double baseComovingDistance;
|
||||||
float vmax = 0;
|
|
||||||
|
|
||||||
expfact = new double[data->NumPart];
|
expfact = new double[data->NumPart];
|
||||||
|
|
||||||
cout << "Using base redshift z=" << z0 << endl;
|
cout << "Using base redshift z=" << z0 << " " << z0+8*data->BoxSize*100/LIGHT_SPEED << endl;
|
||||||
|
|
||||||
e_computer.Omega_M = data->Omega_M;
|
e_computer.Omega_M = data->Omega_M;
|
||||||
e_computer.Omega_L = data->Omega_Lambda;
|
e_computer.Omega_L = data->Omega_Lambda;
|
||||||
baseComovingDistance = LIGHT_SPEED/100.* gslIntegrate(e_computer, 0, z0, 1e-3);
|
baseComovingDistance = LIGHT_SPEED/100.* gslIntegrate(e_computer, 0, z0, 1e-3);
|
||||||
cout << "Comoving distance = " << baseComovingDistance << " Mpc/h" << endl;
|
cout << "Comoving distance = " << baseComovingDistance << " Mpc/h" << endl;
|
||||||
|
|
||||||
cout << "Add peculiar velocities ? -> " << (pecvel ? " yes " : " no ") << endl;
|
|
||||||
|
|
||||||
for (uint32_t i = 0; i < data->NumPart; i++)
|
for (uint32_t i = 0; i < data->NumPart; i++)
|
||||||
{
|
{
|
||||||
float& x = data->Pos[x0][i];
|
float& x = data->Pos[x0][i];
|
||||||
|
|
@ -234,7 +221,7 @@ void metricTransform(SimuData *data, int axis, bool reshift, bool pecvel, double
|
||||||
float& z = data->Pos[x2][i];
|
float& z = data->Pos[x2][i];
|
||||||
float& v = data->Vel[2][i];
|
float& v = data->Vel[2][i];
|
||||||
float z_old = z;
|
float z_old = z;
|
||||||
|
|
||||||
double reduced_red = (z + baseComovingDistance)*100./LIGHT_SPEED;
|
double reduced_red = (z + baseComovingDistance)*100./LIGHT_SPEED;
|
||||||
try
|
try
|
||||||
{
|
{
|
||||||
|
|
@ -242,17 +229,13 @@ void metricTransform(SimuData *data, int axis, bool reshift, bool pecvel, double
|
||||||
// Distorted redshift
|
// Distorted redshift
|
||||||
if (reduced_red == 0)
|
if (reduced_red == 0)
|
||||||
z = 0;
|
z = 0;
|
||||||
else if (cosmo_flag)
|
else {
|
||||||
z = (z_vs_D.compute(reduced_red)-z_base)*LIGHT_SPEED/100.;
|
z = (z_vs_D.compute(reduced_red)-z_base)*LIGHT_SPEED/100.;
|
||||||
else
|
}
|
||||||
z = reduced_red*LIGHT_SPEED/100.0;
|
|
||||||
|
|
||||||
expfact[i] = z / z_old;
|
expfact[i] = z / z_old;
|
||||||
// Add peculiar velocity
|
// Add peculiar velocity
|
||||||
if (pecvel) {
|
if (pecvel)
|
||||||
vmax = std::max(v,vmax);
|
|
||||||
z += v/100;
|
z += v/100;
|
||||||
}
|
|
||||||
}
|
}
|
||||||
catch(const InvalidRangeException& e) {
|
catch(const InvalidRangeException& e) {
|
||||||
cout << "Trying to interpolate out of the tabulated range." << endl;
|
cout << "Trying to interpolate out of the tabulated range." << endl;
|
||||||
|
|
@ -260,7 +243,7 @@ void metricTransform(SimuData *data, int axis, bool reshift, bool pecvel, double
|
||||||
abort();
|
abort();
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
cout << "vmax=" << vmax << endl;
|
|
||||||
}
|
}
|
||||||
|
|
||||||
void generateOutput(SimuData *data, int axis,
|
void generateOutput(SimuData *data, int axis,
|
||||||
|
|
@ -315,63 +298,6 @@ void generateOutput(SimuData *data, int axis,
|
||||||
f.endCheckpoint();
|
f.endCheckpoint();
|
||||||
}
|
}
|
||||||
|
|
||||||
void makeBoxFromParameter(SimuData *simu, double *efac, SimuData* &boxed, generateMock_info& args_info)
|
|
||||||
{
|
|
||||||
NcFile f(args_info.inputParameter_arg);
|
|
||||||
NcVar *v;
|
|
||||||
int *particle_id;
|
|
||||||
double *expansion_fac;
|
|
||||||
|
|
||||||
boxed = new SimuData;
|
|
||||||
boxed->Hubble = simu->Hubble;
|
|
||||||
boxed->Omega_M = simu->Omega_M;
|
|
||||||
boxed->Omega_Lambda = simu->Omega_Lambda;
|
|
||||||
boxed->time = simu->time;
|
|
||||||
boxed->BoxSize = simu->BoxSize;
|
|
||||||
|
|
||||||
NcVar *v_id = f.get_var("particle_ids");
|
|
||||||
long *edges1;
|
|
||||||
double ranges[3][2];
|
|
||||||
double mul[3];
|
|
||||||
|
|
||||||
edges1 = v_id->edges();
|
|
||||||
assert(v_id->num_dims()==1);
|
|
||||||
|
|
||||||
boxed->NumPart = edges1[0];
|
|
||||||
delete[] edges1;
|
|
||||||
|
|
||||||
particle_id = new int[boxed->NumPart];
|
|
||||||
|
|
||||||
v_id->get(particle_id, boxed->NumPart);
|
|
||||||
|
|
||||||
ranges[0][0] = f.get_att("range_x_min")->as_double(0);
|
|
||||||
ranges[0][1] = f.get_att("range_x_max")->as_double(0);
|
|
||||||
ranges[1][0] = f.get_att("range_y_min")->as_double(0);
|
|
||||||
ranges[1][1] = f.get_att("range_y_max")->as_double(0);
|
|
||||||
ranges[2][0] = f.get_att("range_z_min")->as_double(0);
|
|
||||||
ranges[2][1] = f.get_att("range_z_max")->as_double(0);
|
|
||||||
|
|
||||||
for (int j = 0; j < 3; j++)
|
|
||||||
{
|
|
||||||
boxed->Pos[j] = new float[boxed->NumPart];
|
|
||||||
boxed->Vel[j] = 0;
|
|
||||||
mul[j] = 1.0/(ranges[j][1] - ranges[j][0]);
|
|
||||||
}
|
|
||||||
|
|
||||||
uint32_t k = 0;
|
|
||||||
for (uint32_t i = 0; i < boxed->NumPart; i++)
|
|
||||||
{
|
|
||||||
int id = particle_id[i];
|
|
||||||
|
|
||||||
for (int j = 0; j < 3; j++)
|
|
||||||
{
|
|
||||||
boxed->Pos[j][i] = (simu->Pos[j][id]-ranges[j][0])*mul[j];
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
delete[] particle_id;
|
|
||||||
}
|
|
||||||
|
|
||||||
void makeBox(SimuData *simu, double *efac, SimuData *&boxed, generateMock_info& args_info)
|
void makeBox(SimuData *simu, double *efac, SimuData *&boxed, generateMock_info& args_info)
|
||||||
{
|
{
|
||||||
float subsample = args_info.subsample_given ? args_info.subsample_arg : 1.0;
|
float subsample = args_info.subsample_given ? args_info.subsample_arg : 1.0;
|
||||||
|
|
@ -409,15 +335,20 @@ void makeBox(SimuData *simu, double *efac, SimuData *&boxed, generateMock_info&
|
||||||
minmax[0][j] = min(simu->Pos[j][i], minmax[0][j]);
|
minmax[0][j] = min(simu->Pos[j][i], minmax[0][j]);
|
||||||
minmax[1][j] = max(simu->Pos[j][i], minmax[1][j]);
|
minmax[1][j] = max(simu->Pos[j][i], minmax[1][j]);
|
||||||
}
|
}
|
||||||
|
|
||||||
random_acceptance[i] = acceptance && (drand48() <= subsample);
|
random_acceptance[i] = acceptance && (drand48() <= subsample);
|
||||||
if (random_acceptance[i])
|
if (random_acceptance[i])
|
||||||
goodParticles++;
|
goodParticles++;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
cout << "Subsample fraction: " << subsample << endl;
|
||||||
|
cout << "Min range = " << ranges[0][0] << " " << ranges[1][0] << " " << ranges[2][0] << endl;
|
||||||
|
cout << "Max range = " << ranges[0][1] << " " << ranges[1][1] << " " << ranges[2][1] << endl;
|
||||||
|
|
||||||
cout << "Min position = " << minmax[0][0] << " " << minmax[0][1] << " " << minmax[0][2] << endl;
|
cout << "Min position = " << minmax[0][0] << " " << minmax[0][1] << " " << minmax[0][2] << endl;
|
||||||
cout << "Max position = " << minmax[1][0] << " " << minmax[1][1] << " " << minmax[1][2] << endl;
|
cout << "Max position = " << minmax[1][0] << " " << minmax[1][1] << " " << minmax[1][2] << endl;
|
||||||
|
|
||||||
|
cout << "Number of accepted particles: " << goodParticles << endl;
|
||||||
|
|
||||||
for (int j = 0; j < 3; j++)
|
for (int j = 0; j < 3; j++)
|
||||||
{
|
{
|
||||||
boxed->Pos[j] = new float[goodParticles];
|
boxed->Pos[j] = new float[goodParticles];
|
||||||
|
|
@ -425,6 +356,7 @@ void makeBox(SimuData *simu, double *efac, SimuData *&boxed, generateMock_info&
|
||||||
mul[j] = 1.0/(ranges[j][1] - ranges[j][0]);
|
mul[j] = 1.0/(ranges[j][1] - ranges[j][0]);
|
||||||
}
|
}
|
||||||
|
|
||||||
|
cout << "Rescaling factors = " << mul[0] << " " << mul[1] << " " << mul[2] << endl;
|
||||||
boxed->NumPart = goodParticles;
|
boxed->NumPart = goodParticles;
|
||||||
|
|
||||||
particle_id = new int[goodParticles];
|
particle_id = new int[goodParticles];
|
||||||
|
|
@ -501,14 +433,13 @@ int main(int argc, char **argv)
|
||||||
|
|
||||||
generateMock_conf_print_version();
|
generateMock_conf_print_version();
|
||||||
|
|
||||||
gadgetUnit=args_info.gadgetUnit_arg;
|
|
||||||
|
|
||||||
if (args_info.ramsesBase_given || args_info.ramsesId_given)
|
if (args_info.ramsesBase_given || args_info.ramsesId_given)
|
||||||
{
|
{
|
||||||
if (args_info.ramsesBase_given && args_info.ramsesId_given)
|
if (args_info.ramsesBase_given && args_info.ramsesId_given) {
|
||||||
simu = doLoadRamses(args_info.ramsesBase_arg,
|
//simu = doLoadRamses(args_info.ramsesBase_arg,
|
||||||
args_info.ramsesId_arg,
|
// args_info.ramsesId_arg,
|
||||||
args_info.axis_arg, false);
|
// args_info.axis_arg, false);
|
||||||
|
}
|
||||||
else
|
else
|
||||||
{
|
{
|
||||||
cerr << "Both ramsesBase and ramsesId are required to be able to load snapshots" << endl;
|
cerr << "Both ramsesBase and ramsesId are required to be able to load snapshots" << endl;
|
||||||
|
|
@ -521,7 +452,7 @@ int main(int argc, char **argv)
|
||||||
return 1;
|
return 1;
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
else if (args_info.gadget_given || args_info.flash_given)
|
else if (args_info.gadget_given || args_info.flash_given || args_info.multidark_given)
|
||||||
{
|
{
|
||||||
if (args_info.gadget_given && args_info.flash_given)
|
if (args_info.gadget_given && args_info.flash_given)
|
||||||
{
|
{
|
||||||
|
|
@ -529,10 +460,17 @@ int main(int argc, char **argv)
|
||||||
return 1;
|
return 1;
|
||||||
}
|
}
|
||||||
|
|
||||||
if (args_info.gadget_given)
|
if (args_info.multidark_given) {
|
||||||
|
simu = doLoadMultidark(args_info.multidark_arg);
|
||||||
|
}
|
||||||
|
|
||||||
|
if (args_info.gadget_given) {
|
||||||
simu = doLoadSimulation(args_info.gadget_arg, args_info.axis_arg, false, myLoadGadget);
|
simu = doLoadSimulation(args_info.gadget_arg, args_info.axis_arg, false, myLoadGadget);
|
||||||
else
|
}
|
||||||
|
if (args_info.flash_given) {
|
||||||
simu = doLoadSimulation(args_info.flash_arg, args_info.axis_arg, false, loadFlashMulti);
|
simu = doLoadSimulation(args_info.flash_arg, args_info.axis_arg, false, loadFlashMulti);
|
||||||
|
}
|
||||||
|
|
||||||
if (simu == 0)
|
if (simu == 0)
|
||||||
{
|
{
|
||||||
cerr << "Error while loading " << endl;
|
cerr << "Error while loading " << endl;
|
||||||
|
|
@ -551,18 +489,20 @@ int main(int argc, char **argv)
|
||||||
|
|
||||||
double *expfact;
|
double *expfact;
|
||||||
|
|
||||||
metricTransform(simu, args_info.axis_arg, args_info.preReShift_flag, args_info.peculiarVelocities_flag, expfact, args_info.cosmo_flag);
|
if (args_info.cosmo_flag){
|
||||||
|
metricTransform(simu, args_info.axis_arg, args_info.preReShift_flag, args_info.peculiarVelocities_flag, expfact);
|
||||||
|
} else {
|
||||||
|
expfact = new double[simu->NumPart];
|
||||||
|
for (int j = 0; j < simu->NumPart; j++) expfact[j] = 1.0;
|
||||||
|
}
|
||||||
|
|
||||||
if (args_info.inputParameter_given)
|
makeBox(simu, expfact, simuOut, args_info);
|
||||||
makeBoxFromParameter(simu, expfact, simuOut, args_info);
|
|
||||||
else
|
|
||||||
makeBox(simu, expfact, simuOut, args_info);
|
|
||||||
|
|
||||||
delete simu;
|
delete simu;
|
||||||
|
|
||||||
generateOutput(simuOut, args_info.axis_arg, args_info.output_arg);
|
generateOutput(simuOut, args_info.axis_arg, args_info.output_arg);
|
||||||
|
|
||||||
delete simuOut;
|
delete simuOut;
|
||||||
|
|
||||||
|
printf("Done!\n");
|
||||||
return 0;
|
return 0;
|
||||||
}
|
}
|
||||||
|
|
@ -9,6 +9,7 @@ option "ramsesId" - "Ramses snapshot id" int optional
|
||||||
|
|
||||||
option "gadget" - "Base name of gadget snapshot (without parallel writing extension)" string optional
|
option "gadget" - "Base name of gadget snapshot (without parallel writing extension)" string optional
|
||||||
option "flash" - "Base name for FLASH snapshot" string optional
|
option "flash" - "Base name for FLASH snapshot" string optional
|
||||||
|
option "multidark" - "Base name for multidark snapshot" string optional
|
||||||
|
|
||||||
option "axis" - "Redshift axis (X=0, Y=1, Z=2)" int optional default="2"
|
option "axis" - "Redshift axis (X=0, Y=1, Z=2)" int optional default="2"
|
||||||
|
|
||||||
|
|
@ -28,6 +29,3 @@ option "peculiarVelocities" - "Added peculiar velocities distortion" flag off
|
||||||
option "cosmo" - "Apply cosmological redshift" flag on
|
option "cosmo" - "Apply cosmological redshift" flag on
|
||||||
|
|
||||||
option "subsample" - "Subsample the input simulation by the specified amount" double optional
|
option "subsample" - "Subsample the input simulation by the specified amount" double optional
|
||||||
|
|
||||||
option "inputParameter" - "Input geometry (optional, warning!)" string optional
|
|
||||||
option "gadgetUnit" - "Unit of length in gadget file in Mpc/h" double optional default="0.001"
|
|
||||||
550
c_tools/stacking/pruneVoids.cpp
Normal file
550
c_tools/stacking/pruneVoids.cpp
Normal file
|
|
@ -0,0 +1,550 @@
|
||||||
|
// Reads in the void catalog and removes any void that could potentially
|
||||||
|
// be affected by a mock particle. It does this by computing the longest
|
||||||
|
// particle distance within each void and comparing it to the distance
|
||||||
|
// of the nearest mock particle. If the void could potentially by rotated
|
||||||
|
// to include this particle, we throw out the void.
|
||||||
|
|
||||||
|
// This is placed here instead of using the edgeAvoidance option in
|
||||||
|
// stackVoidsZero so that we can optionally filter the entire
|
||||||
|
// catalog at once before the stacking phase. This is useful
|
||||||
|
// for producing a "clean" void catalog for other purposes.
|
||||||
|
|
||||||
|
#include "gsl/gsl_math.h"
|
||||||
|
#include "string.h"
|
||||||
|
#include "ctype.h"
|
||||||
|
#include "stdlib.h"
|
||||||
|
#include <math.h>
|
||||||
|
#include <stdio.h>
|
||||||
|
#include <netcdfcpp.h>
|
||||||
|
#include "pruneVoids_conf.h"
|
||||||
|
|
||||||
|
#define LIGHT_SPEED 299792.458
|
||||||
|
#define MPC2Z 100./LIGHT_SPEED
|
||||||
|
#define Z2MPC LIGHT_SPEED/100.
|
||||||
|
|
||||||
|
typedef struct partStruct {
|
||||||
|
float x, y, z, vol;
|
||||||
|
} PART;
|
||||||
|
|
||||||
|
typedef struct zoneStruct {
|
||||||
|
int numPart;
|
||||||
|
int *partIDs;
|
||||||
|
} ZONE2PART;
|
||||||
|
|
||||||
|
typedef struct voidZoneStruct {
|
||||||
|
int numZones;
|
||||||
|
int *zoneIDs;
|
||||||
|
} VOID2ZONE;
|
||||||
|
|
||||||
|
typedef struct voidStruct {
|
||||||
|
float vol, coreDens, zoneVol, densCon, voidProb, radius;
|
||||||
|
int voidID, numPart, numZones, coreParticle, zoneNumPart;
|
||||||
|
float maxRadius, nearestMock, centralDen, redshift;
|
||||||
|
float center[3], barycenter[3];
|
||||||
|
int accepted;
|
||||||
|
} VOID;
|
||||||
|
|
||||||
|
int main(int argc, char **argv) {
|
||||||
|
|
||||||
|
// initialize arguments
|
||||||
|
pruneVoids_info args_info;
|
||||||
|
pruneVoids_conf_params args_params;
|
||||||
|
|
||||||
|
pruneVoids_conf_init(&args_info);
|
||||||
|
pruneVoids_conf_params_init(&args_params);
|
||||||
|
|
||||||
|
args_params.check_required = 0;
|
||||||
|
if (pruneVoids_conf_ext (argc, argv, &args_info, &args_params))
|
||||||
|
return 1;
|
||||||
|
|
||||||
|
if (!args_info.configFile_given) {
|
||||||
|
if (pruneVoids_conf_required (&args_info,
|
||||||
|
PRUNEVOIDS_CONF_PACKAGE))
|
||||||
|
return 1;
|
||||||
|
} else {
|
||||||
|
args_params.check_required = 1;
|
||||||
|
args_params.initialize = 0;
|
||||||
|
if (pruneVoids_conf_config_file (args_info.configFile_arg,
|
||||||
|
&args_info,
|
||||||
|
&args_params))
|
||||||
|
return 1;
|
||||||
|
}
|
||||||
|
|
||||||
|
int i, p, p2, numPartTot, numZonesTot, dummy, iVoid, iZ;
|
||||||
|
int numVoids, mockIndex, numKept;
|
||||||
|
double tolerance;
|
||||||
|
FILE *fp, *fpBarycenter, *fpDistances, *fpSkyPositions, *fpInfo;
|
||||||
|
PART *part, *voidPart;
|
||||||
|
ZONE2PART *zones2Parts;
|
||||||
|
VOID2ZONE *void2Zones;
|
||||||
|
VOID *voids;
|
||||||
|
float *temp, junk, voidVol;
|
||||||
|
int junkInt, voidID, numPart, numZones, zoneID, partID, maxNumPart;
|
||||||
|
int coreParticle, zoneNumPart;
|
||||||
|
float coreDens, zoneVol, densCon, voidProb, dist[3], dist2, minDist, maxDist;
|
||||||
|
float centralRad, centralDen;
|
||||||
|
double nearestEdge, redshift;
|
||||||
|
char line[500], junkStr[10];
|
||||||
|
int mask_index;
|
||||||
|
double ranges[2][3], boxLen[3], mul;
|
||||||
|
double volNorm, radius;
|
||||||
|
int clock1, clock2;
|
||||||
|
|
||||||
|
numVoids = args_info.numVoids_arg;
|
||||||
|
mockIndex = args_info.mockIndex_arg;
|
||||||
|
tolerance = args_info.tolerance_arg;
|
||||||
|
|
||||||
|
clock1 = clock();
|
||||||
|
printf("Pruning parameters: %f %f %f\n", args_info.zMin_arg,
|
||||||
|
args_info.zMax_arg,
|
||||||
|
args_info.rMin_arg);
|
||||||
|
|
||||||
|
// load box size
|
||||||
|
printf("\n Getting info...\n");
|
||||||
|
NcFile f_info(args_info.extraInfo_arg);
|
||||||
|
ranges[0][0] = f_info.get_att("range_x_min")->as_double(0);
|
||||||
|
ranges[0][1] = f_info.get_att("range_x_max")->as_double(0);
|
||||||
|
ranges[1][0] = f_info.get_att("range_y_min")->as_double(0);
|
||||||
|
ranges[1][1] = f_info.get_att("range_y_max")->as_double(0);
|
||||||
|
ranges[2][0] = f_info.get_att("range_z_min")->as_double(0);
|
||||||
|
ranges[2][1] = f_info.get_att("range_z_max")->as_double(0);
|
||||||
|
|
||||||
|
boxLen[0] = ranges[0][1] - ranges[0][0];
|
||||||
|
boxLen[1] = ranges[1][1] - ranges[1][0];
|
||||||
|
boxLen[2] = ranges[2][1] - ranges[2][0];
|
||||||
|
|
||||||
|
// read in all particle positions
|
||||||
|
printf("\n Loading particles...\n");
|
||||||
|
fp = fopen(args_info.partFile_arg, "r");
|
||||||
|
fread(&dummy, 1, 4, fp);
|
||||||
|
fread(&numPartTot, 1, 4, fp);
|
||||||
|
fread(&dummy, 1, 4, fp);
|
||||||
|
|
||||||
|
part = (PART *) malloc(numPartTot * sizeof(PART));
|
||||||
|
temp = (float *) malloc(numPartTot * sizeof(float));
|
||||||
|
|
||||||
|
volNorm = numPartTot/(boxLen[0]*boxLen[1]*boxLen[2]);
|
||||||
|
printf("VOL NORM = %f\n", volNorm);
|
||||||
|
|
||||||
|
printf("CENTRAL DEN = %f\n", args_info.maxCentralDen_arg);
|
||||||
|
|
||||||
|
fread(&dummy, 1, 4, fp);
|
||||||
|
fread(temp, numPartTot, 4, fp);
|
||||||
|
mul = ranges[0][1] - ranges[0][0];
|
||||||
|
for (p = 0; p < numPartTot; p++)
|
||||||
|
part[p].x = mul*temp[p];
|
||||||
|
fread(&dummy, 1, 4, fp);
|
||||||
|
fread(&dummy, 1, 4, fp);
|
||||||
|
fread(temp, numPartTot, 4, fp);
|
||||||
|
mul = ranges[1][1] - ranges[1][0];
|
||||||
|
for (p = 0; p < numPartTot; p++)
|
||||||
|
part[p].y = mul*temp[p];
|
||||||
|
fread(&dummy, 1, 4, fp);
|
||||||
|
fread(&dummy, 1, 4, fp);
|
||||||
|
fread(temp, numPartTot, 4, fp);
|
||||||
|
mul = ranges[2][1] - ranges[2][0];
|
||||||
|
for (p = 0; p < numPartTot; p++)
|
||||||
|
part[p].z = mul*temp[p];
|
||||||
|
|
||||||
|
if (!args_info.isObservation_flag) {
|
||||||
|
for (p = 0; p < numPartTot; p++) {
|
||||||
|
part[p].x += ranges[0][0];
|
||||||
|
part[p].y += ranges[1][0];
|
||||||
|
part[p].z += ranges[2][0];
|
||||||
|
}
|
||||||
|
}
|
||||||
|
fclose(fp);
|
||||||
|
|
||||||
|
printf(" Read %d particles...\n", numPartTot);
|
||||||
|
|
||||||
|
if (mockIndex == -1) mockIndex = numPartTot;
|
||||||
|
|
||||||
|
// read in desired voids
|
||||||
|
printf(" Loading voids...\n");
|
||||||
|
fp = fopen(args_info.voidDesc_arg ,"r");
|
||||||
|
fgets(line, sizeof(line), fp);
|
||||||
|
sscanf(line, "%d %s %d %s", &junkInt, junkStr, &junkInt, junkStr);
|
||||||
|
fgets(line, sizeof(line), fp);
|
||||||
|
|
||||||
|
voids = (VOID *) malloc(numVoids * sizeof(VOID));
|
||||||
|
i = 0;
|
||||||
|
while (fgets(line, sizeof(line), fp) != NULL) {
|
||||||
|
sscanf(line, "%d %d %d %f %f %d %d %f %d %f %f\n", &iVoid, &voidID,
|
||||||
|
&coreParticle, &coreDens, &zoneVol, &zoneNumPart, &numZones,
|
||||||
|
&voidVol, &numPart, &densCon, &voidProb);
|
||||||
|
|
||||||
|
i++;
|
||||||
|
voids[i-1].coreParticle = coreParticle;
|
||||||
|
voids[i-1].zoneNumPart = zoneNumPart;
|
||||||
|
voids[i-1].coreDens = coreDens;
|
||||||
|
voids[i-1].zoneVol = zoneVol;
|
||||||
|
voids[i-1].voidID = voidID;
|
||||||
|
voids[i-1].vol = voidVol;
|
||||||
|
voids[i-1].numPart = numPart;
|
||||||
|
voids[i-1].numZones = numZones;
|
||||||
|
voids[i-1].densCon = densCon;
|
||||||
|
voids[i-1].voidProb = voidProb;
|
||||||
|
|
||||||
|
voids[i-1].radius = pow(voidVol/volNorm*3./4./M_PI, 1./3.);
|
||||||
|
voids[i-1].accepted = 1;
|
||||||
|
}
|
||||||
|
fclose(fp);
|
||||||
|
|
||||||
|
// load up the zone membership for each void
|
||||||
|
printf(" Loading void-zone membership info...\n");
|
||||||
|
fp = fopen(args_info.void2Zone_arg, "r");
|
||||||
|
fread(&numZonesTot, 1, 4, fp);
|
||||||
|
void2Zones = (VOID2ZONE *) malloc(numZonesTot * sizeof(VOID2ZONE));
|
||||||
|
|
||||||
|
for (iZ = 0; iZ < numZonesTot; iZ++) {
|
||||||
|
fread(&numZones, 1, 4, fp);
|
||||||
|
|
||||||
|
void2Zones[iZ].numZones = numZones;
|
||||||
|
void2Zones[iZ].zoneIDs = (int *) malloc(numZones * sizeof(int));
|
||||||
|
|
||||||
|
for (p = 0; p < numZones; p++) {
|
||||||
|
fread(&void2Zones[iZ].zoneIDs[p], 1, 4, fp);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
fclose(fp);
|
||||||
|
|
||||||
|
// now the particles-zone
|
||||||
|
printf(" Loading particle-zone membership info...\n");
|
||||||
|
fp = fopen(args_info.zone2Part_arg, "r");
|
||||||
|
fread(&dummy, 1, 4, fp);
|
||||||
|
fread(&numZonesTot, 1, 4, fp);
|
||||||
|
|
||||||
|
zones2Parts = (ZONE2PART *) malloc(numZonesTot * sizeof(ZONE2PART));
|
||||||
|
for (iZ = 0; iZ < numZonesTot; iZ++) {
|
||||||
|
fread(&numPart, 1, 4, fp);
|
||||||
|
|
||||||
|
zones2Parts[iZ].numPart = numPart;
|
||||||
|
zones2Parts[iZ].partIDs = (int *) malloc(numPart * sizeof(int));
|
||||||
|
|
||||||
|
for (p = 0; p < numPart; p++) {
|
||||||
|
fread(&zones2Parts[iZ].partIDs[p], 1, 4, fp);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// and finally volumes
|
||||||
|
printf(" Loading particle volumes...\n");
|
||||||
|
fp = fopen(args_info.partVol_arg, "r");
|
||||||
|
fread(&mask_index, 1, 4, fp);
|
||||||
|
if (mask_index != mockIndex) {
|
||||||
|
printf("NON-MATCHING MOCK INDICES!? %d %d\n", mask_index, mockIndex);
|
||||||
|
exit(-1);
|
||||||
|
}
|
||||||
|
for (p = 0; p < mask_index; p++) {
|
||||||
|
fread(&temp[0], 1, 4, fp);
|
||||||
|
part[p].vol = temp[0];
|
||||||
|
}
|
||||||
|
fclose(fp);
|
||||||
|
free(temp);
|
||||||
|
|
||||||
|
// check boundaries
|
||||||
|
printf(" Computing void properties...\n");
|
||||||
|
|
||||||
|
maxNumPart = 0;
|
||||||
|
for (iVoid = 0; iVoid < numVoids; iVoid++) {
|
||||||
|
if (voids[iVoid].numPart > maxNumPart) maxNumPart = voids[iVoid].numPart;
|
||||||
|
}
|
||||||
|
|
||||||
|
voidPart = (PART *) malloc(maxNumPart * sizeof(PART));
|
||||||
|
|
||||||
|
for (iVoid = 0; iVoid < numVoids; iVoid++) {
|
||||||
|
|
||||||
|
voidID = voids[iVoid].voidID;
|
||||||
|
//printf(" DOING %d (of %d) %d %d\n", iVoid, numVoids, voidID,
|
||||||
|
// voids[iVoid].numPart);
|
||||||
|
|
||||||
|
voids[iVoid].center[0] = part[voids[iVoid].coreParticle].x;
|
||||||
|
voids[iVoid].center[1] = part[voids[iVoid].coreParticle].y;
|
||||||
|
voids[iVoid].center[2] = part[voids[iVoid].coreParticle].z;
|
||||||
|
|
||||||
|
// first load up particles into a buffer
|
||||||
|
i = 0;
|
||||||
|
for (iZ = 0; iZ < void2Zones[voidID].numZones; iZ++) {
|
||||||
|
zoneID = void2Zones[voidID].zoneIDs[iZ];
|
||||||
|
|
||||||
|
for (p = 0; p < zones2Parts[zoneID].numPart; p++) {
|
||||||
|
partID = zones2Parts[zoneID].partIDs[p];
|
||||||
|
|
||||||
|
if (partID > mask_index ||
|
||||||
|
(part[partID].vol < 1.e-27 && part[partID].vol > 0.)) {
|
||||||
|
printf("BAD PART!? %d %d %e", partID, mask_index, part[partID].vol);
|
||||||
|
exit(-1);
|
||||||
|
}
|
||||||
|
|
||||||
|
voidPart[i].x = part[partID].x;
|
||||||
|
voidPart[i].y = part[partID].y;
|
||||||
|
voidPart[i].z = part[partID].z;
|
||||||
|
voidPart[i].vol = part[partID].vol;
|
||||||
|
|
||||||
|
i++;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// compute barycenters
|
||||||
|
double weight = 0.;
|
||||||
|
voids[iVoid].barycenter[0] = 0.;
|
||||||
|
voids[iVoid].barycenter[1] = 0.;
|
||||||
|
voids[iVoid].barycenter[2] = 0.;
|
||||||
|
|
||||||
|
// TODO handle periodic boundaries?
|
||||||
|
for (p = 0; p < voids[iVoid].numPart; p++) {
|
||||||
|
dist[0] = voidPart[p].x - voids[iVoid].center[0];
|
||||||
|
dist[1] = voidPart[p].y - voids[iVoid].center[1];
|
||||||
|
dist[2] = voidPart[p].z - voids[iVoid].center[2];
|
||||||
|
|
||||||
|
//if (!args_info.isObservation_flag) {
|
||||||
|
// dist[0] = fmin(dist[0], abs(boxLen[0]-dist[0]));
|
||||||
|
// dist[1] = fmin(dist[1], abs(boxLen[1]-dist[1]));
|
||||||
|
// dist[2] = fmin(dist[2], abs(boxLen[2]-dist[2]));
|
||||||
|
//}
|
||||||
|
|
||||||
|
voids[iVoid].barycenter[0] += voidPart[p].vol*(dist[0]);
|
||||||
|
voids[iVoid].barycenter[1] += voidPart[p].vol*(dist[1]);
|
||||||
|
voids[iVoid].barycenter[2] += voidPart[p].vol*(dist[2]);
|
||||||
|
weight += voidPart[p].vol;
|
||||||
|
}
|
||||||
|
voids[iVoid].barycenter[0] /= weight;
|
||||||
|
voids[iVoid].barycenter[1] /= weight;
|
||||||
|
voids[iVoid].barycenter[2] /= weight;
|
||||||
|
voids[iVoid].barycenter[0] += voids[iVoid].center[0];
|
||||||
|
voids[iVoid].barycenter[1] += voids[iVoid].center[1];
|
||||||
|
voids[iVoid].barycenter[2] += voids[iVoid].center[2];
|
||||||
|
|
||||||
|
// compute central density
|
||||||
|
centralRad = voids[iVoid].radius/args_info.centralRadFrac_arg;
|
||||||
|
centralRad *= centralRad;
|
||||||
|
centralDen = 0.;
|
||||||
|
for (p = 0; p < voids[iVoid].numPart; p++) {
|
||||||
|
dist[0] = voidPart[p].x - voids[iVoid].barycenter[0];
|
||||||
|
dist[1] = voidPart[p].y - voids[iVoid].barycenter[1];
|
||||||
|
dist[2] = voidPart[p].z - voids[iVoid].barycenter[2];
|
||||||
|
|
||||||
|
//if (!args_info.isObservation_flag) {
|
||||||
|
// dist[0] = fmin(dist[0], abs(boxLen[0]-dist[0]));
|
||||||
|
// dist[1] = fmin(dist[1], abs(boxLen[1]-dist[1]));
|
||||||
|
// dist[2] = fmin(dist[2], abs(boxLen[2]-dist[2]));
|
||||||
|
//}
|
||||||
|
|
||||||
|
dist2 = pow(dist[0],2) + pow(dist[1],2) + pow(dist[2],2);
|
||||||
|
if (dist2 < centralRad) centralDen += 1;
|
||||||
|
}
|
||||||
|
voids[iVoid].centralDen = centralDen / (4./3. * M_PI * pow(centralRad, 3./2.));
|
||||||
|
|
||||||
|
// compute maximum extent
|
||||||
|
if (args_info.isObservation_flag) {
|
||||||
|
maxDist = 0.;
|
||||||
|
for (p = 0; p < voids[iVoid].numPart; p++) {
|
||||||
|
for (p2 = p; p2 < voids[iVoid].numPart; p2++) {
|
||||||
|
|
||||||
|
dist[0] = voidPart[p].x - voidPart[p2].x;
|
||||||
|
dist[1] = voidPart[p].y - voidPart[p2].y;
|
||||||
|
dist[2] = voidPart[p].z - voidPart[p2].z;
|
||||||
|
|
||||||
|
dist2 = pow(dist[0],2) + pow(dist[1],2) + pow(dist[2],2);
|
||||||
|
if (dist2 > maxDist) maxDist = dist2;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
voids[iVoid].maxRadius = sqrt(maxDist)/2.;
|
||||||
|
} else {
|
||||||
|
maxDist = 0.;
|
||||||
|
for (p = 0; p < voids[iVoid].numPart; p++) {
|
||||||
|
|
||||||
|
dist[0] = voidPart[p].x - voids[iVoid].barycenter[0];
|
||||||
|
dist[0] = voidPart[p].y - voids[iVoid].barycenter[1];
|
||||||
|
dist[0] = voidPart[p].z - voids[iVoid].barycenter[2];
|
||||||
|
|
||||||
|
dist2 = pow(dist[0],2) + pow(dist[1],2) + pow(dist[2],2);
|
||||||
|
if (dist2 > maxDist) maxDist = dist2;
|
||||||
|
}
|
||||||
|
voids[iVoid].maxRadius = sqrt(maxDist);
|
||||||
|
}
|
||||||
|
|
||||||
|
if (args_info.isObservation_flag) {
|
||||||
|
// compute distance from center to nearest mock
|
||||||
|
minDist = 1.e99;
|
||||||
|
for (p = mockIndex; p < numPartTot; p++) {
|
||||||
|
dist[0] = voids[iVoid].barycenter[0] - part[p].x;
|
||||||
|
dist[1] = voids[iVoid].barycenter[1] - part[p].y;
|
||||||
|
dist[2] = voids[iVoid].barycenter[2] - part[p].z;
|
||||||
|
|
||||||
|
dist2 = pow(dist[0],2) + pow(dist[1],2) + pow(dist[2],2);
|
||||||
|
if (dist2 < minDist) minDist = dist2;
|
||||||
|
}
|
||||||
|
voids[iVoid].nearestMock = sqrt(minDist);
|
||||||
|
|
||||||
|
} else {
|
||||||
|
voids[iVoid].nearestMock = 1.e99;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (args_info.isObservation_flag) {
|
||||||
|
voids[iVoid].redshift =
|
||||||
|
sqrt(pow(voids[iVoid].barycenter[0] - boxLen[0]/2.,2) +
|
||||||
|
pow(voids[iVoid].barycenter[1] - boxLen[1]/2.,2) +
|
||||||
|
pow(voids[iVoid].barycenter[2] - boxLen[2]/2.,2));
|
||||||
|
voids[iVoid].redshift = voids[iVoid].redshift;
|
||||||
|
redshift = voids[iVoid].redshift;
|
||||||
|
nearestEdge = fmin(fabs(redshift-args_info.zMin_arg*LIGHT_SPEED),
|
||||||
|
fabs(redshift-args_info.zMax_arg*LIGHT_SPEED));
|
||||||
|
} else {
|
||||||
|
voids[iVoid].redshift = voids[iVoid].barycenter[2]/LIGHT_SPEED*100.;
|
||||||
|
|
||||||
|
nearestEdge = fmin(
|
||||||
|
fabs(voids[iVoid].barycenter[0] - ranges[0][0]),
|
||||||
|
fabs(voids[iVoid].barycenter[0] - ranges[0][1]));
|
||||||
|
nearestEdge = fmin(nearestEdge,
|
||||||
|
fabs(voids[iVoid].barycenter[1] - ranges[1][0]));
|
||||||
|
nearestEdge = fmin(nearestEdge,
|
||||||
|
fabs(voids[iVoid].barycenter[1] - ranges[1][1]));
|
||||||
|
nearestEdge = fmin(nearestEdge,
|
||||||
|
fabs(voids[iVoid].barycenter[2] - ranges[2][0]));
|
||||||
|
nearestEdge = fmin(nearestEdge,
|
||||||
|
fabs(voids[iVoid].barycenter[2] - ranges[2][1]));
|
||||||
|
}
|
||||||
|
|
||||||
|
if (nearestEdge < voids[iVoid].nearestMock) {
|
||||||
|
voids[iVoid].nearestMock = nearestEdge;
|
||||||
|
}
|
||||||
|
} // iVoid
|
||||||
|
|
||||||
|
printf(" Picking winners and losers...\n");
|
||||||
|
numKept = numVoids;
|
||||||
|
for (iVoid = 0; iVoid < numVoids; iVoid++) {
|
||||||
|
if (strcmp(args_info.dataPortion_arg, "edge") == 0 &&
|
||||||
|
tolerance*voids[iVoid].maxRadius < voids[iVoid].nearestMock) {
|
||||||
|
numKept--;
|
||||||
|
voids[iVoid].accepted = 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (strcmp(args_info.dataPortion_arg, "central") == 0 &&
|
||||||
|
tolerance*voids[iVoid].maxRadius > voids[iVoid].nearestMock) {
|
||||||
|
numKept--;
|
||||||
|
voids[iVoid].accepted = 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (voids[iVoid].centralDen > args_info.maxCentralDen_arg) {
|
||||||
|
numKept--;
|
||||||
|
voids[iVoid].accepted = -1;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (voids[iVoid].radius < args_info.rMin_arg) {
|
||||||
|
numKept--;
|
||||||
|
voids[iVoid].accepted = 0;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
printf(" Number kept: %d (out of %d)\n", numKept, numVoids);
|
||||||
|
|
||||||
|
printf(" Output...\n");
|
||||||
|
fp = fopen(args_info.output_arg, "w");
|
||||||
|
fpBarycenter = fopen(args_info.outCenters_arg, "w");
|
||||||
|
fpInfo = fopen(args_info.outInfo_arg, "w");
|
||||||
|
fpDistances = fopen(args_info.outDistances_arg, "w");
|
||||||
|
fpSkyPositions = fopen(args_info.outSkyPositions_arg, "w");
|
||||||
|
fprintf(fp, "%d particles, %d voids.\n", mockIndex, numKept);
|
||||||
|
fprintf(fp, "see column in master void file\n");
|
||||||
|
fprintf(fpInfo, "# center x,y,z (Mpc/h), volume (normalized), radius (Mpc/h), redshift, volume (Mpc/h^3), void ID\n");
|
||||||
|
fprintf(fpSkyPositions, "# RA, dec, redshift, radius (Mpc/h), void ID\n");
|
||||||
|
for (iVoid = 0; iVoid < numVoids; iVoid++) {
|
||||||
|
|
||||||
|
if (voids[iVoid].accepted != 1) continue;
|
||||||
|
|
||||||
|
fprintf(fp, "%d %d %d %f %f %d %d %f %d %f %f\n",
|
||||||
|
i,
|
||||||
|
voids[iVoid].voidID,
|
||||||
|
voids[iVoid].coreParticle,
|
||||||
|
voids[iVoid].coreDens,
|
||||||
|
voids[iVoid].zoneVol,
|
||||||
|
voids[iVoid].zoneNumPart,
|
||||||
|
voids[iVoid].numZones,
|
||||||
|
voids[iVoid].vol,
|
||||||
|
voids[iVoid].numPart,
|
||||||
|
voids[iVoid].densCon,
|
||||||
|
voids[iVoid].voidProb);
|
||||||
|
|
||||||
|
fprintf(fpBarycenter, "%d %e %e %e\n",
|
||||||
|
voids[iVoid].voidID,
|
||||||
|
voids[iVoid].barycenter[0],
|
||||||
|
voids[iVoid].barycenter[1],
|
||||||
|
voids[iVoid].barycenter[2]);
|
||||||
|
|
||||||
|
fprintf(fpDistances, "%d %e\n",
|
||||||
|
voids[iVoid].voidID,
|
||||||
|
voids[iVoid].nearestMock);
|
||||||
|
|
||||||
|
double outCenter[3];
|
||||||
|
outCenter[0] = voids[iVoid].barycenter[0];
|
||||||
|
outCenter[1] = voids[iVoid].barycenter[1];
|
||||||
|
outCenter[2] = voids[iVoid].barycenter[2];
|
||||||
|
|
||||||
|
if (args_info.isObservation_flag) {
|
||||||
|
outCenter[0] = (voids[iVoid].barycenter[0]-boxLen[0]/2.)*100.;
|
||||||
|
outCenter[1] = (voids[iVoid].barycenter[1]-boxLen[1]/2.)*100.;
|
||||||
|
outCenter[2] = (voids[iVoid].barycenter[2]-boxLen[2]/2.)*100.;
|
||||||
|
}
|
||||||
|
|
||||||
|
fprintf(fpInfo, "%.2f %.2f %.2f %.2f %.2f %.5f %.2f %d\n",
|
||||||
|
outCenter[0],
|
||||||
|
outCenter[1],
|
||||||
|
outCenter[2],
|
||||||
|
voids[iVoid].vol,
|
||||||
|
voids[iVoid].radius,
|
||||||
|
voids[iVoid].redshift,
|
||||||
|
4./3.*M_PI*pow(voids[iVoid].radius, 3),
|
||||||
|
voids[iVoid].voidID
|
||||||
|
);
|
||||||
|
|
||||||
|
fprintf(fpSkyPositions, "%.2f %.2f %.5f %.2f %d\n",
|
||||||
|
atan((voids[iVoid].barycenter[1]-boxLen[1]/2.)/(voids[iVoid].barycenter[0]-boxLen[0]/2.)) * 180/M_PI + 180,
|
||||||
|
asin((voids[iVoid].barycenter[2]-boxLen[2]/2.)/voids[iVoid].redshift) * 180/M_PI,
|
||||||
|
voids[iVoid].redshift,
|
||||||
|
voids[iVoid].radius,
|
||||||
|
voids[iVoid].voidID);
|
||||||
|
|
||||||
|
}
|
||||||
|
fclose(fp);
|
||||||
|
fclose(fpInfo);
|
||||||
|
fclose(fpBarycenter);
|
||||||
|
fclose(fpDistances);
|
||||||
|
|
||||||
|
// print the centers catalog again but without central density cuts
|
||||||
|
fpInfo = fopen(args_info.outNoCutInfo_arg, "w");
|
||||||
|
fprintf(fpInfo, "# center x,y,z (km/s), volume (normalized), radius (Mpc/h), redshift, volume (Mpc/h^3), void ID\n");
|
||||||
|
for (iVoid = 0; iVoid < numVoids; iVoid++) {
|
||||||
|
|
||||||
|
if (voids[iVoid].accepted == 0) continue;
|
||||||
|
|
||||||
|
double outCenter[3];
|
||||||
|
outCenter[0] = voids[iVoid].barycenter[0];
|
||||||
|
outCenter[1] = voids[iVoid].barycenter[1];
|
||||||
|
outCenter[2] = voids[iVoid].barycenter[2];
|
||||||
|
|
||||||
|
if (args_info.isObservation_flag) {
|
||||||
|
outCenter[0] = (voids[iVoid].barycenter[0]-boxLen[0]/2.)*100.;
|
||||||
|
outCenter[1] = (voids[iVoid].barycenter[1]-boxLen[1]/2.)*100.;
|
||||||
|
outCenter[2] = (voids[iVoid].barycenter[2]-boxLen[2]/2.)*100.;
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
fprintf(fpInfo, "%.2f %.2f %.2f %.2f %.2f %.5f %.2f %d\n",
|
||||||
|
outCenter[0],
|
||||||
|
outCenter[1],
|
||||||
|
outCenter[2],
|
||||||
|
voids[iVoid].vol,
|
||||||
|
voids[iVoid].radius,
|
||||||
|
voids[iVoid].redshift,
|
||||||
|
4./3.*M_PI*pow(voids[iVoid].radius, 3),
|
||||||
|
voids[iVoid].voidID);
|
||||||
|
}
|
||||||
|
fclose(fpInfo);
|
||||||
|
|
||||||
|
clock2 = clock();
|
||||||
|
printf(" Time: %f sec (for %d voids)\n", (1.*clock2-clock1)/CLOCKS_PER_SEC, numVoids);
|
||||||
|
clock1 = clock();
|
||||||
|
|
||||||
|
|
||||||
|
printf("Done!\n");
|
||||||
|
return 0;
|
||||||
|
} // end main
|
||||||
47
c_tools/stacking/pruneVoids.ggo
Normal file
47
c_tools/stacking/pruneVoids.ggo
Normal file
|
|
@ -0,0 +1,47 @@
|
||||||
|
package "removeEdgeVoids"
|
||||||
|
version "alpha"
|
||||||
|
|
||||||
|
|
||||||
|
option "configFile" - "Configuration filename" string optional
|
||||||
|
|
||||||
|
option "partFile" - "Particle file from generateFromCatalog" string required
|
||||||
|
|
||||||
|
option "extraInfo" - "Extra particle file from generateFromCatalog" string required
|
||||||
|
|
||||||
|
option "voidDesc" - "Void list from ZOBOV" string required
|
||||||
|
|
||||||
|
option "void2Zone" - "Zone file from ZOBOV" string required
|
||||||
|
|
||||||
|
option "partVol" - "Particle volume file from ZOBOV" string required
|
||||||
|
|
||||||
|
option "zone2Part" - "Particle file from ZOBOV" string required
|
||||||
|
option "mockIndex" - "Beginning index of mock particles" int required
|
||||||
|
|
||||||
|
option "numVoids" - "Number of voids" int required
|
||||||
|
|
||||||
|
option "isObservation" - "We are working with observational data" flag off
|
||||||
|
|
||||||
|
option "zMin" - "Minimum redshift of sample" double optional default="0.0"
|
||||||
|
option "zMax" - "Maximum redshift of sample" double optional default="10.0"
|
||||||
|
|
||||||
|
option "rMin" - "Minimum allowable void radius" double optional default="0.0"
|
||||||
|
|
||||||
|
|
||||||
|
option "output" - "Output void file" string required
|
||||||
|
option "outDistances" - "output of distances from centers to nearest mock particle" string required
|
||||||
|
|
||||||
|
option "outCenters" - "output barycenters of voids" string required
|
||||||
|
|
||||||
|
option "outInfo" - "output info of voids" string required
|
||||||
|
|
||||||
|
option "outNoCutInfo" - "output info of voids" string required
|
||||||
|
|
||||||
|
option "outSkyPositions" - "output sky positions of voids" string required
|
||||||
|
|
||||||
|
option "dataPortion" - "all, central, or edge" string required
|
||||||
|
|
||||||
|
option "tolerance" - "Fraction of void width to consider edge" double optional default="1.0"
|
||||||
|
|
||||||
|
option "centralRadFrac" - "Fraction of void radii to consider central region" double optional default="4"
|
||||||
|
|
||||||
|
option "maxCentralDen" - "Maximum central density to accept as a void" double optional default="0.2"
|
||||||
113
pipeline/generateCatalog.py
Executable file
113
pipeline/generateCatalog.py
Executable file
|
|
@ -0,0 +1,113 @@
|
||||||
|
#!/usr/bin/env python
|
||||||
|
|
||||||
|
# does full void analysis. Also generates 2d/1d stacked plots and hubble diagram
|
||||||
|
|
||||||
|
from void_python_tools.backend import *
|
||||||
|
from void_python_tools.plotting import *
|
||||||
|
import imp
|
||||||
|
|
||||||
|
# ------------------------------------------------------------------------------
|
||||||
|
|
||||||
|
def my_import(name):
|
||||||
|
mod = __import__(name)
|
||||||
|
components = name.split('.')
|
||||||
|
for comp in components[1:]:
|
||||||
|
mod = getattr(mod, comp)
|
||||||
|
return mod
|
||||||
|
|
||||||
|
if (len(sys.argv) == 0):
|
||||||
|
print "Usage: ./anylyzeVoids.py parameter_file.py"
|
||||||
|
exit(-1)
|
||||||
|
|
||||||
|
if (len(sys.argv) > 1):
|
||||||
|
filename = sys.argv[1]
|
||||||
|
print " Loading parameters from", filename
|
||||||
|
if not os.access(filename, os.F_OK):
|
||||||
|
print " Cannot find parameter file!"
|
||||||
|
exit(-1)
|
||||||
|
#parms = __import__(filename[:-3], globals(), locals(), ['*'])
|
||||||
|
parms = imp.load_source("name", filename)
|
||||||
|
globals().update(vars(parms))
|
||||||
|
else:
|
||||||
|
print " Using default parameters"
|
||||||
|
|
||||||
|
# ------------------------------------------------------------------------------
|
||||||
|
# ------------------------------------------------------------------------------
|
||||||
|
|
||||||
|
if not os.access(logDir, os.F_OK):
|
||||||
|
os.makedirs(logDir)
|
||||||
|
|
||||||
|
if not os.access(figDir, os.F_OK):
|
||||||
|
os.makedirs(figDir)
|
||||||
|
|
||||||
|
if not continueRun:
|
||||||
|
print " Cleaning out log files..."
|
||||||
|
|
||||||
|
if startCatalogStage <= 1 and glob.glob(logDir+"/generate*") != []:
|
||||||
|
os.system("rm %s/generate*" % logDir)
|
||||||
|
if startCatalogStage <= 2 and glob.glob(logDir+"/zobov*") != []:
|
||||||
|
os.system("rm %s/zobov*" % logDir)
|
||||||
|
if startCatalogStage <= 3 and glob.glob(logDir+"/prune*") != []:
|
||||||
|
os.system("rm %s/prune*" % logDir)
|
||||||
|
|
||||||
|
for sample in dataSampleList:
|
||||||
|
|
||||||
|
sampleName = sample.fullName
|
||||||
|
|
||||||
|
print " Working with data set", sampleName, "..."
|
||||||
|
zobovDir = workDir+"/sample_"+sampleName+"/"
|
||||||
|
sample.zobovDir = zobovDir
|
||||||
|
|
||||||
|
if not os.access(zobovDir, os.F_OK):
|
||||||
|
os.makedirs(zobovDir)
|
||||||
|
|
||||||
|
# ---------------------------------------------------------------------------
|
||||||
|
if (startCatalogStage <= 1) and (endCatalogStage >= 1) and not sample.isCombo:
|
||||||
|
print " Extracting tracers from catalog...",
|
||||||
|
sys.stdout.flush()
|
||||||
|
|
||||||
|
logFile = logDir+"/generate_"+sampleName+".out"
|
||||||
|
|
||||||
|
if sample.dataType == "observation":
|
||||||
|
GENERATE_PATH = CTOOLS_PATH+"/mock/generateFromCatalog"
|
||||||
|
else:
|
||||||
|
GENERATE_PATH = CTOOLS_PATH+"/mock/generateMock"
|
||||||
|
|
||||||
|
launchGenerate(sample, GENERATE_PATH, workDir=workDir,
|
||||||
|
inputDataDir=inputDataDir, zobovDir=zobovDir,
|
||||||
|
figDir=figDir, logFile=logFile, useLCDM=useLCDM,
|
||||||
|
continueRun=continueRun)
|
||||||
|
|
||||||
|
# --------------------------------------------------------------------------
|
||||||
|
if (startCatalogStage <= 2) and (endCatalogStage >= 2) and not sample.isCombo:
|
||||||
|
print " Extracting voids with ZOBOV...",
|
||||||
|
sys.stdout.flush()
|
||||||
|
|
||||||
|
launchZobov(sample, ZOBOV_PATH, zobovDir=zobovDir, logDir=logDir,
|
||||||
|
continueRun=continueRun)
|
||||||
|
|
||||||
|
# -------------------------------------------------------------------------
|
||||||
|
if (startCatalogStage <= 3) and (endCatalogStage >= 3) and not sample.isCombo:
|
||||||
|
|
||||||
|
for thisDataPortion in dataPortions:
|
||||||
|
print " Taking data portion:", thisDataPortion, "...",
|
||||||
|
sys.stdout.flush()
|
||||||
|
|
||||||
|
logFile = logDir+"/pruneVoids_"+sampleName+"_"+\
|
||||||
|
thisDataPortion+".out"
|
||||||
|
|
||||||
|
PRUNE_PATH = CTOOLS_PATH+"/stacking/pruneVoids"
|
||||||
|
|
||||||
|
launchPrune(sample, PRUNE_PATH, thisDataPortion=thisDataPortion,
|
||||||
|
logFile=logFile, zobovDir=zobovDir, continueRun=continueRun)
|
||||||
|
|
||||||
|
# -------------------------------------------------------------------------
|
||||||
|
if (startCatalogStage <= 4) and (endCatalogStage >= 4):
|
||||||
|
|
||||||
|
print " Plotting...",
|
||||||
|
sys.stdout.flush()
|
||||||
|
|
||||||
|
for thisDataPortion in dataPortions:
|
||||||
|
plotNumberCounts(workDir, dataSampleList, figDir, showPlot=True, dataPortion=thisDataPortion, setName=setName)
|
||||||
|
|
||||||
|
print "\n Done!"
|
||||||
466
pipeline/prepareCatalogs.py
Executable file
466
pipeline/prepareCatalogs.py
Executable file
|
|
@ -0,0 +1,466 @@
|
||||||
|
#!/usr/bin/env python
|
||||||
|
|
||||||
|
# prepares input catalogs based on multidark simulations
|
||||||
|
# (borrows heavily from generateMock, but doesn't hold much in memory)
|
||||||
|
# also creates necessary analyzeVoids input files
|
||||||
|
|
||||||
|
import numpy as np
|
||||||
|
import os
|
||||||
|
import sys
|
||||||
|
from Scientific.IO.NetCDF import NetCDFFile
|
||||||
|
import void_python_tools as vp
|
||||||
|
import argparse
|
||||||
|
|
||||||
|
catalogDir = os.getenv("HOME")+"/workspace/Voids/catalogs/multidark/"
|
||||||
|
scriptDir = os.getenv("PWD")+"/multidark/"
|
||||||
|
hodPath = os.getenv("HOME")+"/projects/Voids/hod/HOD.x"
|
||||||
|
|
||||||
|
outputDir = os.getenv("HOME")+"/workspace/Voids/multidark/"
|
||||||
|
figDir = os.getenv("PWD")+"/../figs/multidark/"
|
||||||
|
logDir = os.getenv("PWD")+"/../logs/multidark/"
|
||||||
|
|
||||||
|
dataFormat = "multidark"
|
||||||
|
dataType = "simulation"
|
||||||
|
useLightCone = True
|
||||||
|
|
||||||
|
redshifts = (("0.0", "0.53", "1.0"))
|
||||||
|
redshiftFileBase = "mdr1_particles_z"
|
||||||
|
numSlices = 4
|
||||||
|
numSubvolumes = 1
|
||||||
|
|
||||||
|
prefix = "md_"
|
||||||
|
subSamples = ((0.1, 0.05, 0.01, 0.002, 0.001, 0.0004, 0.0002))
|
||||||
|
|
||||||
|
numPart = 1024*1024*1024 # number of particles in base catalog
|
||||||
|
lbox = 1000
|
||||||
|
omegaM = 0.27
|
||||||
|
hubble = 0.70
|
||||||
|
|
||||||
|
# -----------------------------------------------------------------------------
|
||||||
|
LIGHT_SPEED = 299792.458
|
||||||
|
|
||||||
|
parser = argparse.ArgumentParser(description='options')
|
||||||
|
parser.add_argument('--scripts', dest='script', action='store_const',
|
||||||
|
const=True, default=False,
|
||||||
|
help='write scripts')
|
||||||
|
parser.add_argument('--subsamples', dest='subsample', action='store_const',
|
||||||
|
const=True, default=False,
|
||||||
|
help='write subsamples')
|
||||||
|
parser.add_argument('--halos', dest='halos', action='store_const',
|
||||||
|
const=True, default=False,
|
||||||
|
help='write halos')
|
||||||
|
parser.add_argument('--hod', dest='hod', action='store_const',
|
||||||
|
const=True, default=False,
|
||||||
|
help='write hos')
|
||||||
|
parser.add_argument('--all', dest='all', action='store_const',
|
||||||
|
const=True, default=False,
|
||||||
|
help='write everything')
|
||||||
|
args = parser.parse_args()
|
||||||
|
|
||||||
|
#------------------------------------------------------------------------------
|
||||||
|
def getSampleName(prefix, base, redshift, useVel, iSlice=-1, iVol=-1):
|
||||||
|
useVelString = ""
|
||||||
|
if useVel: useVelString = "_pv"
|
||||||
|
|
||||||
|
sampleName = prefix + base + useVelString + "_z" + redshift
|
||||||
|
|
||||||
|
if iSlice != -1:
|
||||||
|
sampleName += "_s" + str(iSlice)
|
||||||
|
|
||||||
|
if iVol != -1:
|
||||||
|
sampleName += "_d" + iVol
|
||||||
|
|
||||||
|
return sampleName
|
||||||
|
|
||||||
|
#------------------------------------------------------------------------------
|
||||||
|
# for given dataset parameters, outputs a script for use with analyzeVoids
|
||||||
|
def writeScript(prefix, base, scriptDir, catalogDir, redshifts, numSubvolumes,
|
||||||
|
numSlices, useVel, lbox, minRadius, omegaM, subsample=1.0,
|
||||||
|
suffix=".dat"):
|
||||||
|
|
||||||
|
setName = prefix + base
|
||||||
|
|
||||||
|
dataFileNameBase = setName #+ ".dat"
|
||||||
|
|
||||||
|
if useVel: setName += "_pv"
|
||||||
|
|
||||||
|
scriptFileName = scriptDir + "/" + "md_" + base
|
||||||
|
if useVel: scriptFileName += "_pv"
|
||||||
|
scriptFileName += ".py"
|
||||||
|
scriptFile = open(scriptFileName, 'w')
|
||||||
|
|
||||||
|
scriptFile.write("""#!/usr/bin/env/python
|
||||||
|
import os
|
||||||
|
from void_python_tools.backend.classes import *
|
||||||
|
|
||||||
|
continueRun = False
|
||||||
|
startCatalogStage = 1
|
||||||
|
endCatalogStage = 3
|
||||||
|
|
||||||
|
startAPStage = 1
|
||||||
|
endAPStage = 6
|
||||||
|
|
||||||
|
ZOBOV_PATH = os.getenv("PWD")+"/../zobov/"
|
||||||
|
CTOOLS_PATH = os.getenv("PWD")+"/../c_tools/"
|
||||||
|
freshStack = True
|
||||||
|
errorBars = "CALCULATED"
|
||||||
|
numIncoherentRuns = 100
|
||||||
|
ranSeed = 101010
|
||||||
|
useLCDM = False
|
||||||
|
bias = 1.16
|
||||||
|
|
||||||
|
dataPortions = ["central"]
|
||||||
|
dataSampleList = []
|
||||||
|
""")
|
||||||
|
|
||||||
|
dataInfo = """
|
||||||
|
catalogName = "{sampleName}"
|
||||||
|
|
||||||
|
workDir = "{outputDir}/{sampleName}/"
|
||||||
|
inputDataDir = "{catalogDir}"
|
||||||
|
figDir = "{figDir}/{sampleName}/"
|
||||||
|
logDir = "{logDir}/{sampleName}/"
|
||||||
|
"""
|
||||||
|
scriptFile.write(dataInfo.format(sampleName=setName, figDir=figDir,
|
||||||
|
logDir=logDir, outputDir=outputDir,
|
||||||
|
catalogDir=catalogDir,
|
||||||
|
inputDataDir=catalogDir))
|
||||||
|
|
||||||
|
sampleInfo = """
|
||||||
|
newSample = Sample(dataFile = "{dataFile}",
|
||||||
|
dataFormat = "{dataFormat}",
|
||||||
|
fullName = "{sampleName}",
|
||||||
|
nickName = "{sampleName}",
|
||||||
|
dataType = "simulation",
|
||||||
|
zBoundary = ({zMin}, {zMax}),
|
||||||
|
zRange = ({zMin}, {zMax}),
|
||||||
|
zBoundaryMpc = ({zMinMpc}, {zMaxMpc}),
|
||||||
|
omegaM = {omegaM},
|
||||||
|
minVoidRadius = {minRadius},
|
||||||
|
includeInHubble = True,
|
||||||
|
partOfCombo = False,
|
||||||
|
isCombo = False,
|
||||||
|
boxLen = {boxLen},
|
||||||
|
usePecVel = {usePecVel},
|
||||||
|
numSubvolumes = {numSubvolumes},
|
||||||
|
mySubvolume = "{mySubvolume}",
|
||||||
|
numSubDivisions = 4,
|
||||||
|
useLightCone = {useLightCone},
|
||||||
|
subsample = {subsample})
|
||||||
|
dataSampleList.append(newSample)
|
||||||
|
newSample.addStack({zMin}, {zMax}, {minRadius} , {minRadius}+2, True, False)
|
||||||
|
newSample.addStack({zMin}, {zMax}, {minRadius} , {minRadius}+4, True, False)
|
||||||
|
newSample.addStack({zMin}, {zMax}, {minRadius}+2, {minRadius}+6, True, False)
|
||||||
|
newSample.addStack({zMin}, {zMax}, {minRadius}+6, {minRadius}+10, True, False)
|
||||||
|
newSample.addStack({zMin}, {zMax}, {minRadius}+10, {minRadius}+18, True, False)
|
||||||
|
newSample.addStack({zMin}, {zMax}, {minRadius}+18, {minRadius}+24, True, False)
|
||||||
|
"""
|
||||||
|
|
||||||
|
for redshift in redshifts:
|
||||||
|
zBox = float(redshift)
|
||||||
|
Om = float(omegaM)
|
||||||
|
zBoxMpc = LIGHT_SPEED/100.*vp.angularDiameter(zBox, Om=Om)
|
||||||
|
boxMaxMpc = zBoxMpc + lbox
|
||||||
|
|
||||||
|
# converter from redshift to comoving distance
|
||||||
|
zVsDY = np.linspace(0., zBox+8*lbox*100./LIGHT_SPEED, 10000)
|
||||||
|
zVsDX = np.zeros(len(zVsDY))
|
||||||
|
for i in xrange(len(zVsDY)):
|
||||||
|
zVsDX[i] = vp.angularDiameter(zVsDY[i], Om=Om)
|
||||||
|
|
||||||
|
if useLightCone:
|
||||||
|
boxWidthZ = np.interp(vp.angularDiameter(zBox,Om=Om)+100. / \
|
||||||
|
LIGHT_SPEED*lbox, zVsDX, zVsDY)-zBox
|
||||||
|
dzSafe = 0.03
|
||||||
|
else:
|
||||||
|
boxWidthZ = lbox*100./LIGHT_SPEED
|
||||||
|
dzSafe = 0.0
|
||||||
|
|
||||||
|
for iSlice in xrange(numSlices):
|
||||||
|
# trim off the first and last 10,000 km/s
|
||||||
|
sliceMin = zBox + dzSafe + iSlice*(boxWidthZ-dzSafe)/numSlices
|
||||||
|
sliceMax = zBox + dzSafe + (iSlice+1)*(boxWidthZ-dzSafe)/numSlices
|
||||||
|
|
||||||
|
sliceMinMpc = sliceMin*LIGHT_SPEED/100.
|
||||||
|
sliceMaxMpc = sliceMax*LIGHT_SPEED/100.
|
||||||
|
|
||||||
|
sliceMin = "%0.2f" % sliceMin
|
||||||
|
sliceMax = "%0.2f" % sliceMax
|
||||||
|
sliceMinMpc = "%0.1f" % sliceMinMpc
|
||||||
|
sliceMaxMpc = "%0.1f" % sliceMaxMpc
|
||||||
|
|
||||||
|
dataFileName = dataFileNameBase + "_z" + redshift + suffix
|
||||||
|
|
||||||
|
for iX in xrange(numSubvolumes):
|
||||||
|
for iY in xrange(numSubvolumes):
|
||||||
|
|
||||||
|
mySubvolume = "%d%d" % (iX, iY)
|
||||||
|
|
||||||
|
sampleName = getSampleName(prefix, base, redshift, useVel,
|
||||||
|
iSlice=iSlice, iVol=mySubvolume)
|
||||||
|
|
||||||
|
scriptFile.write(sampleInfo.format(dataFile=dataFileName,
|
||||||
|
dataFormat=dataFormat,
|
||||||
|
sampleName=sampleName,
|
||||||
|
zMin=sliceMin,
|
||||||
|
zMax=sliceMax,
|
||||||
|
zMinMpc=sliceMinMpc,
|
||||||
|
zMaxMpc=sliceMaxMpc,
|
||||||
|
omegaM=Om,
|
||||||
|
boxLen=lbox,
|
||||||
|
usePecVel=useVel,
|
||||||
|
minRadius=minRadius,
|
||||||
|
numSubvolumes=numSubvolumes,
|
||||||
|
mySubvolume=mySubvolume,
|
||||||
|
useLightCone=useLightCone,
|
||||||
|
subsample=subsample))
|
||||||
|
|
||||||
|
scriptFile.close()
|
||||||
|
return
|
||||||
|
|
||||||
|
|
||||||
|
#------------------------------------------------------------------------------
|
||||||
|
#------------------------------------------------------------------------------
|
||||||
|
if not os.access(scriptDir, os.F_OK): os.mkdir(scriptDir)
|
||||||
|
|
||||||
|
#------------------------------------------------------------------------------
|
||||||
|
# first the directly downsampled runs
|
||||||
|
# Note: ss0.002 ~ SDSS DR7 dim2
|
||||||
|
# ss0.0004 ~ SDSS DR9 mid
|
||||||
|
baseResolution = numPart/lbox/lbox/lbox # particles/Mpc^3
|
||||||
|
for thisSubSample in subSamples:
|
||||||
|
|
||||||
|
keepFraction = float(thisSubSample) / baseResolution
|
||||||
|
maxKeep = keepFraction * numPart
|
||||||
|
minRadius = int(np.ceil(lbox/maxKeep**(1./3)))
|
||||||
|
|
||||||
|
if args.script or args.all:
|
||||||
|
print " Doing subsample", thisSubSample, " scripts"
|
||||||
|
if dataFormat == "multidark":
|
||||||
|
writeScript(prefix,
|
||||||
|
"ss"+str(thisSubSample), scriptDir, catalogDir, redshifts,
|
||||||
|
numSubvolumes, numSlices, False, lbox, minRadius, omegaM,
|
||||||
|
subsample=1.0)
|
||||||
|
writeScript(prefix, "ss"+str(thisSubSample), scriptDir, catalogDir,
|
||||||
|
redshifts, numSubvolumes, numSlices, True, lbox, minRadius,
|
||||||
|
omegaM, subsample=1.0)
|
||||||
|
elif dataFormat == "gadget":
|
||||||
|
writeScript("", redshiftFileBase, scriptDir, catalogDir, redshifts,
|
||||||
|
numSubvolumes, numSlices, True, lbox, minRadius, omegaM,
|
||||||
|
subsample=thisSubSample, suffix="")
|
||||||
|
|
||||||
|
if args.subsample or args.all:
|
||||||
|
print " Doing subsample", thisSubSample
|
||||||
|
|
||||||
|
for redshift in redshifts:
|
||||||
|
print " redshift", redshift
|
||||||
|
dataFile = catalogDir+"/"+redshiftFileBase+redshift
|
||||||
|
inFile = open(dataFile, 'r')
|
||||||
|
|
||||||
|
sampleName = getSampleName("ss"+str(thisSubSample), redshift, False)
|
||||||
|
outFile = open(catalogDir+"/"+sampleName+".dat", 'w')
|
||||||
|
|
||||||
|
outFile.write("%f\n" %(lbox))
|
||||||
|
outFile.write("%s" %(omegaM))
|
||||||
|
outFile.write("%s" %(hubble))
|
||||||
|
outFile.write("%s\n" %(redshift))
|
||||||
|
outFile.write("%d\n" %(maxKeep))
|
||||||
|
|
||||||
|
numKept = 0
|
||||||
|
for line in inFile:
|
||||||
|
if np.random.uniform() > keepFraction: continue
|
||||||
|
numKept += 1
|
||||||
|
if numKept > maxKeep: break
|
||||||
|
line = line.split(',')
|
||||||
|
x = float(line[0])
|
||||||
|
y = float(line[1])
|
||||||
|
z = float(line[2])
|
||||||
|
vz = float(line[3])
|
||||||
|
|
||||||
|
outFile.write("%e %e %e %e\n" %(x,y,z,vz))
|
||||||
|
|
||||||
|
outFile.write("-99 -99 -99 -99\n")
|
||||||
|
print "KEEPING:", numKept, "...predicted:", maxKeep
|
||||||
|
inFile.close()
|
||||||
|
outFile.close()
|
||||||
|
|
||||||
|
# -----------------------------------------------------------------------------
|
||||||
|
# now halos
|
||||||
|
if args.script or args.all:
|
||||||
|
print " Doing halo scripts"
|
||||||
|
|
||||||
|
dataFile = catalogDir+"/mdr1_halos_z"+redshifts[0]
|
||||||
|
inFile = open(dataFile, 'r')
|
||||||
|
numPart = 0
|
||||||
|
for line in inFile: numPart += 1
|
||||||
|
inFile.close()
|
||||||
|
|
||||||
|
minRadius = int(np.ceil(lbox/numPart**(1./3.)))
|
||||||
|
|
||||||
|
if dataFormat == "multidark":
|
||||||
|
writeScript(prefix, "halos", scriptDir, catalogDir, redshifts,
|
||||||
|
numSubvolumes, numSlices, False, lbox, minRadius, omegaM)
|
||||||
|
writeScript(prefix, "halos", scriptDir, catalogDir, redshifts, numSubvolumes,
|
||||||
|
numSlices, True, lbox, minRadius, omegaM)
|
||||||
|
|
||||||
|
if args.halos or args.all:
|
||||||
|
print " Doing halos"
|
||||||
|
|
||||||
|
for redshift in redshifts:
|
||||||
|
print " z = ", redshift
|
||||||
|
|
||||||
|
dataFile = catalogDir+"/mdr1_halos_z"+redshift
|
||||||
|
inFile = open(dataFile, 'r')
|
||||||
|
numPart = 0
|
||||||
|
for line in inFile: numPart += 1
|
||||||
|
inFile.close()
|
||||||
|
|
||||||
|
sampleName = getSampleName("halos", redshift, False)
|
||||||
|
|
||||||
|
outFile = open(catalogDir+"/"+sampleName+".dat", 'w')
|
||||||
|
|
||||||
|
outFile.write("%f\n" %(lbox))
|
||||||
|
outFile.write("%s" %(omegaM))
|
||||||
|
outFile.write("%s" %(hubble))
|
||||||
|
outFile.write("%s\n" %(redshift))
|
||||||
|
outFile.write("%d\n" %(numPart))
|
||||||
|
|
||||||
|
inFile = open(dataFile, 'r')
|
||||||
|
numKept = 0
|
||||||
|
for line in inFile:
|
||||||
|
numKept += 1
|
||||||
|
line = line.split(',')
|
||||||
|
x = float(line[0])
|
||||||
|
y = float(line[1])
|
||||||
|
z = float(line[2])
|
||||||
|
vz = float(line[5])
|
||||||
|
|
||||||
|
# write to output file
|
||||||
|
outFile.write("%e %e %e %e\n" %(x,y,z,vz))
|
||||||
|
|
||||||
|
inFile.close()
|
||||||
|
outFile.close()
|
||||||
|
|
||||||
|
# -----------------------------------------------------------------------------
|
||||||
|
# now the SDSS HOD
|
||||||
|
parFileText = """
|
||||||
|
% cosmology
|
||||||
|
OMEGA_M {omegaM}
|
||||||
|
HUBBLE {hubble}
|
||||||
|
OMEGA_B 0.0469
|
||||||
|
SIGMA_8 0.82
|
||||||
|
SPECTRAL_INDX 0.95
|
||||||
|
ITRANS 5
|
||||||
|
REDSHIFT {redshift}
|
||||||
|
|
||||||
|
% halo definition
|
||||||
|
%DELTA_HALO 200
|
||||||
|
DELTA_HALO 740.74 % 200/Om_m
|
||||||
|
M_max 1.00E+16
|
||||||
|
|
||||||
|
% fit function types
|
||||||
|
pdfs 11
|
||||||
|
pdfc 2
|
||||||
|
EXCLUSION 4
|
||||||
|
|
||||||
|
% hod parameters
|
||||||
|
M_min {Mmin}
|
||||||
|
GALAXY_DENSITY 0.0111134 % computed automatically if M_min set, use for sanity
|
||||||
|
M1 {M1}
|
||||||
|
sigma_logM {sigma_logM}
|
||||||
|
alpha {alpha}
|
||||||
|
M_cut {Mcut}
|
||||||
|
|
||||||
|
% simulation info
|
||||||
|
real_space_xi 1
|
||||||
|
HOD 1
|
||||||
|
populate_sim 1
|
||||||
|
HaloFile {haloFile}
|
||||||
|
RESOLUTION {numPartPerSide}
|
||||||
|
BOX_SIZE {boxSize}
|
||||||
|
|
||||||
|
% output
|
||||||
|
root_filename hod
|
||||||
|
"""
|
||||||
|
|
||||||
|
if args.script or args.all:
|
||||||
|
print " Doing DR7 HOD scripts"
|
||||||
|
if dataFormat == "multidark":
|
||||||
|
writeScript(prefix,
|
||||||
|
"hod_dr72dim2", scriptDir, catalogDir, redshifts,
|
||||||
|
numSubvolumes, numSlices, False, lbox, 5, omegaM)
|
||||||
|
writeScript(prefix,
|
||||||
|
"hod_dr72dim2", scriptDir, catalogDir, redshifts,
|
||||||
|
numSubvolumes, numSlices, True, lbox, 5, omegaM)
|
||||||
|
|
||||||
|
if args.hod or args.all:
|
||||||
|
print " Doing DR7 HOD"
|
||||||
|
for redshift in redshifts:
|
||||||
|
print " z = ", redshift
|
||||||
|
|
||||||
|
parFileName = "./hod.par"
|
||||||
|
parFile = open(parFileName, 'w')
|
||||||
|
haloFile = catalogDir+"/mdr1_halos_z"+redshift
|
||||||
|
parFile.write(parFileText.format(omegaM=omegaM,
|
||||||
|
hubble=hubble,
|
||||||
|
redshift=redshift,
|
||||||
|
Mmin=1.99526e12,
|
||||||
|
M1=3.80189e13,
|
||||||
|
sigma_logM=0.21,
|
||||||
|
alpha=1.12,
|
||||||
|
Mcut=6.91831e11,
|
||||||
|
haloFile=haloFile,
|
||||||
|
numPartPerSide=numPart**(1/3.),
|
||||||
|
boxSize=lbox))
|
||||||
|
parFile.close()
|
||||||
|
|
||||||
|
os.system(hodPath+" "+parFileName+">& /dev/null")
|
||||||
|
|
||||||
|
sampleName = getSampleName("hod_dr72dim2", redshift, False)
|
||||||
|
outFileName = catalogDir+"/"+sampleName+".dat"
|
||||||
|
os.system("mv hod.mock" + " " + outFileName)
|
||||||
|
|
||||||
|
os.system("rm ./hod.*")
|
||||||
|
|
||||||
|
# -----------------------------------------------------------------------------
|
||||||
|
# now the BOSS HOD
|
||||||
|
if args.script or args.all:
|
||||||
|
print " Doing DR9 HOD scripts"
|
||||||
|
if dataFormat == "multidark":
|
||||||
|
writeScript(prefix,
|
||||||
|
"hod_dr9mid", scriptDir, catalogDir, redshifts,
|
||||||
|
numSubvolumes, numSlices, False, lbox, 5, omegaM)
|
||||||
|
writeScript(prefix,
|
||||||
|
"hod_dr9mid", scriptDir, catalogDir, redshifts,
|
||||||
|
numSubvolumes, numSlices, True, lbox, 5, omegaM)
|
||||||
|
|
||||||
|
if args.hod or args.all:
|
||||||
|
print " Doing DR9 HOD"
|
||||||
|
for redshift in redshifts:
|
||||||
|
print " z = ", redshift
|
||||||
|
|
||||||
|
parFileName = "./hod.par"
|
||||||
|
parFile = open(parFileName, 'w')
|
||||||
|
haloFile = catalogDir+"/mdr1_halos_z"+redshift
|
||||||
|
parFile.write(parFileText.format(omegaM=omegaM,
|
||||||
|
hubble=hubble,
|
||||||
|
redshift=redshift,
|
||||||
|
Mmin=1.23e13,
|
||||||
|
M1=1.e14,
|
||||||
|
sigma_logM=0.596,
|
||||||
|
alpha=1.0127,
|
||||||
|
Mcut=1.19399e13,
|
||||||
|
haloFile=haloFile,
|
||||||
|
numPartPerSide=numPart**(1/3.),
|
||||||
|
boxSize=lbox))
|
||||||
|
parFile.close()
|
||||||
|
|
||||||
|
os.system(hodPath+" "+parFileName+">& /dev/null")
|
||||||
|
|
||||||
|
sampleName = getSampleName("hod_dr9mid", redshift, False)
|
||||||
|
outFileName = catalogDir+"/"+sampleName+".dat"
|
||||||
|
os.system("mv hod.mock" + " " + outFileName)
|
||||||
|
|
||||||
|
os.system("rm ./hod.*")
|
||||||
|
|
||||||
|
|
||||||
213
pipeline/prepareGadgetCatalog.py
Executable file
213
pipeline/prepareGadgetCatalog.py
Executable file
|
|
@ -0,0 +1,213 @@
|
||||||
|
#!/usr/bin/env python
|
||||||
|
|
||||||
|
# prepares input catalogs based on multidark simulations
|
||||||
|
# (borrows heavily from generateMock, but doesn't hold much in memory)
|
||||||
|
# also creates necessary analyzeVoids input files
|
||||||
|
|
||||||
|
import numpy as np
|
||||||
|
import os
|
||||||
|
import sys
|
||||||
|
from Scientific.IO.NetCDF import NetCDFFile
|
||||||
|
import void_python_tools as vp
|
||||||
|
import argparse
|
||||||
|
|
||||||
|
catalogDir = os.getenv("HOME")+"/workspace/Voids/catalogs/multidark/"
|
||||||
|
hodPath = os.getenv("HOME")+"/projects/Voids/hod/HOD.x"
|
||||||
|
|
||||||
|
voidOutputDir = os.getenv("HOME")+"/workspace/Voids/multidark/"
|
||||||
|
scriptDir = os.getenv("HOME")+"/projects/Voids/scripts/multidark/"
|
||||||
|
figDir = os.getenv("HOME")+"/projects/Voids/figs/multidark/"
|
||||||
|
logDir = os.getenv("HOME")+"/projects/Voids/logs/multidark/"
|
||||||
|
|
||||||
|
dataType = "simulation"
|
||||||
|
dataFormat = "gadget"
|
||||||
|
useLightCone = False # place particles on a light cone?
|
||||||
|
|
||||||
|
redshiftFileBase = "mdr1_particles_z" # common filename of particle files
|
||||||
|
redshifts = (("0.0", "0.53", "1.0")) # list of redshift particle files
|
||||||
|
|
||||||
|
numSlices = 4 # how many slices along the z-axis?
|
||||||
|
numSubvolumes = 1 # how many subdivisions along the x- and y-axes?
|
||||||
|
|
||||||
|
prefix = "testrun_" # prefix to give all outputs
|
||||||
|
subSamples = [ 0.01 ] # list of desired subsamples
|
||||||
|
|
||||||
|
numPart = 1024*1024*1024 # number of particles in base catalog
|
||||||
|
lbox = 1000 # Mpc/h
|
||||||
|
omegaM = 0.27
|
||||||
|
hubble = 0.70
|
||||||
|
|
||||||
|
# -----------------------------------------------------------------------------
|
||||||
|
LIGHT_SPEED = 299792.458
|
||||||
|
|
||||||
|
#------------------------------------------------------------------------------
|
||||||
|
def getSampleName(setName, redshift, useVel, iSlice=-1, iVol=-1):
|
||||||
|
|
||||||
|
sampleName = setName
|
||||||
|
|
||||||
|
if useVel: setName += "_pv"
|
||||||
|
|
||||||
|
if iSlice != -1: sampleName += "_s" + str(iSlice)
|
||||||
|
|
||||||
|
if iVol != -1: sampleName += "_d" + iVol
|
||||||
|
|
||||||
|
return sampleName
|
||||||
|
|
||||||
|
#------------------------------------------------------------------------------
|
||||||
|
# for given dataset parameters, outputs a script for use with analyzeVoids
|
||||||
|
def writeScript(setName, dataFileNameBase,
|
||||||
|
scriptDir, catalogDir, redshifts, numSubvolumes,
|
||||||
|
numSlices, useVel, lbox, minRadius, omegaM, subsample=1.0,
|
||||||
|
suffix=".dat"):
|
||||||
|
|
||||||
|
if useVel: setName += "_pv"
|
||||||
|
|
||||||
|
scriptFileName = scriptDir + "/" + setName + ".py"
|
||||||
|
scriptFile = open(scriptFileName, 'w')
|
||||||
|
|
||||||
|
scriptFile.write("""#!/usr/bin/env/python
|
||||||
|
import os
|
||||||
|
from void_python_tools.backend.classes import *
|
||||||
|
|
||||||
|
continueRun = False
|
||||||
|
startCatalogStage = 1
|
||||||
|
endCatalogStage = 3
|
||||||
|
|
||||||
|
startAPStage = 1
|
||||||
|
endAPStage = 6
|
||||||
|
|
||||||
|
ZOBOV_PATH = os.getenv("PWD")+"/../zobov/"
|
||||||
|
CTOOLS_PATH = os.getenv("PWD")+"/../c_tools/"
|
||||||
|
freshStack = True
|
||||||
|
errorBars = "CALCULATED"
|
||||||
|
numIncoherentRuns = 100
|
||||||
|
ranSeed = 101010
|
||||||
|
useLCDM = False
|
||||||
|
bias = 1.16
|
||||||
|
|
||||||
|
dataPortions = ["central"]
|
||||||
|
dataSampleList = []
|
||||||
|
""")
|
||||||
|
|
||||||
|
dataInfo = """
|
||||||
|
setName = "{setName}"
|
||||||
|
|
||||||
|
workDir = "{voidOutputDir}/{setName}/"
|
||||||
|
inputDataDir = "{inputDataDir}"
|
||||||
|
figDir = "{figDir}/{setName}/"
|
||||||
|
logDir = "{logDir}/{setName}/"
|
||||||
|
"""
|
||||||
|
scriptFile.write(dataInfo.format(setName=setName, figDir=figDir,
|
||||||
|
logDir=logDir, voidOutputDir=voidOutputDir,
|
||||||
|
inputDataDir=catalogDir))
|
||||||
|
|
||||||
|
sampleInfo = """
|
||||||
|
newSample = Sample(dataFile = "{dataFile}",
|
||||||
|
dataFormat = "{dataFormat}",
|
||||||
|
fullName = "{sampleName}",
|
||||||
|
nickName = "{sampleName}",
|
||||||
|
dataType = "simulation",
|
||||||
|
zBoundary = ({zMin}, {zMax}),
|
||||||
|
zRange = ({zMin}, {zMax}),
|
||||||
|
zBoundaryMpc = ({zMinMpc}, {zMaxMpc}),
|
||||||
|
omegaM = {omegaM},
|
||||||
|
minVoidRadius = {minRadius},
|
||||||
|
includeInHubble = True,
|
||||||
|
partOfCombo = False,
|
||||||
|
isCombo = False,
|
||||||
|
boxLen = {boxLen},
|
||||||
|
usePecVel = {usePecVel},
|
||||||
|
numSubvolumes = {numSubvolumes},
|
||||||
|
mySubvolume = "{mySubvolume}",
|
||||||
|
numSubDivisions = 4,
|
||||||
|
useLightCone = {useLightCone},
|
||||||
|
subsample = {subsample})
|
||||||
|
dataSampleList.append(newSample)
|
||||||
|
"""
|
||||||
|
|
||||||
|
for redshift in redshifts:
|
||||||
|
zBox = float(redshift)
|
||||||
|
Om = float(omegaM)
|
||||||
|
zBoxMpc = LIGHT_SPEED/100.*vp.angularDiameter(zBox, Om=Om)
|
||||||
|
boxMaxMpc = zBoxMpc + lbox
|
||||||
|
|
||||||
|
# converter from redshift to comoving distance
|
||||||
|
zVsDY = np.linspace(0., zBox+8*lbox*100./LIGHT_SPEED, 10000)
|
||||||
|
zVsDX = np.zeros(len(zVsDY))
|
||||||
|
for i in xrange(len(zVsDY)):
|
||||||
|
zVsDX[i] = vp.angularDiameter(zVsDY[i], Om=Om)
|
||||||
|
|
||||||
|
if useLightCone:
|
||||||
|
boxWidthZ = np.interp(vp.angularDiameter(zBox,Om=Om)+100. / \
|
||||||
|
LIGHT_SPEED*lbox, zVsDX, zVsDY)-zBox
|
||||||
|
dzSafe = 0.03
|
||||||
|
else:
|
||||||
|
boxWidthZ = lbox*100./LIGHT_SPEED
|
||||||
|
dzSafe = 0.0
|
||||||
|
|
||||||
|
for iSlice in xrange(numSlices):
|
||||||
|
sliceMin = zBox + dzSafe + iSlice*(boxWidthZ-dzSafe)/numSlices
|
||||||
|
sliceMax = zBox + dzSafe + (iSlice+1)*(boxWidthZ-dzSafe)/numSlices
|
||||||
|
|
||||||
|
sliceMinMpc = sliceMin*LIGHT_SPEED/100.
|
||||||
|
sliceMaxMpc = sliceMax*LIGHT_SPEED/100.
|
||||||
|
|
||||||
|
sliceMin = "%0.2f" % sliceMin
|
||||||
|
sliceMax = "%0.2f" % sliceMax
|
||||||
|
sliceMinMpc = "%0.1f" % sliceMinMpc
|
||||||
|
sliceMaxMpc = "%0.1f" % sliceMaxMpc
|
||||||
|
|
||||||
|
dataFileName = dataFileNameBase + redshift + suffix
|
||||||
|
|
||||||
|
for iX in xrange(numSubvolumes):
|
||||||
|
for iY in xrange(numSubvolumes):
|
||||||
|
|
||||||
|
mySubvolume = "%d%d" % (iX, iY)
|
||||||
|
|
||||||
|
sampleName = getSampleName(setName, redshift, useVel,
|
||||||
|
iSlice=iSlice, iVol=mySubvolume)
|
||||||
|
|
||||||
|
scriptFile.write(sampleInfo.format(dataFile=dataFileName,
|
||||||
|
dataFormat=dataFormat,
|
||||||
|
sampleName=sampleName,
|
||||||
|
zMin=sliceMin,
|
||||||
|
zMax=sliceMax,
|
||||||
|
zMinMpc=sliceMinMpc,
|
||||||
|
zMaxMpc=sliceMaxMpc,
|
||||||
|
omegaM=Om,
|
||||||
|
boxLen=lbox,
|
||||||
|
usePecVel=useVel,
|
||||||
|
minRadius=minRadius,
|
||||||
|
numSubvolumes=numSubvolumes,
|
||||||
|
mySubvolume=mySubvolume,
|
||||||
|
useLightCone=useLightCone,
|
||||||
|
subsample=subsample))
|
||||||
|
|
||||||
|
scriptFile.close()
|
||||||
|
return
|
||||||
|
|
||||||
|
|
||||||
|
#------------------------------------------------------------------------------
|
||||||
|
#------------------------------------------------------------------------------
|
||||||
|
if not os.access(scriptDir, os.F_OK): os.mkdir(scriptDir)
|
||||||
|
|
||||||
|
#------------------------------------------------------------------------------
|
||||||
|
# first the directly downsampled runs
|
||||||
|
# Note: ss0.002 ~ SDSS DR7 dim2
|
||||||
|
# ss0.0004 ~ SDSS DR9 mid
|
||||||
|
baseResolution = numPart/lbox/lbox/lbox # particles/Mpc^3
|
||||||
|
for thisSubSample in subSamples:
|
||||||
|
|
||||||
|
keepFraction = float(thisSubSample) / baseResolution
|
||||||
|
maxKeep = keepFraction * numPart
|
||||||
|
minRadius = int(np.ceil(lbox/maxKeep**(1./3)))
|
||||||
|
|
||||||
|
print " Doing subsample", thisSubSample, " scripts"
|
||||||
|
setName = prefix+"ss"+str(thisSubSample)
|
||||||
|
writeScript(setName, redshiftFileBase, scriptDir, catalogDir, redshifts,
|
||||||
|
numSubvolumes, numSlices, True, lbox, minRadius, omegaM,
|
||||||
|
subsample=thisSubSample, suffix="")
|
||||||
|
writeScript(setName, redshiftFileBase, scriptDir, catalogDir, redshifts,
|
||||||
|
numSubvolumes, numSlices, False, lbox, minRadius, omegaM,
|
||||||
|
subsample=thisSubSample, suffix="")
|
||||||
|
|
||||||
|
|
@ -1,365 +0,0 @@
|
||||||
#include <healpix_map.h>
|
|
||||||
#include <healpix_map_fitsio.h>
|
|
||||||
#include <boost/format.hpp>
|
|
||||||
#include <iostream>
|
|
||||||
#include <fstream>
|
|
||||||
#include <vector>
|
|
||||||
#include <string>
|
|
||||||
#include "generateFromCatalog_conf.h"
|
|
||||||
#include "contour_pixels.hpp"
|
|
||||||
#include <netcdfcpp.h>
|
|
||||||
#include <CosmoTool/fortran.hpp>
|
|
||||||
|
|
||||||
using namespace std;
|
|
||||||
using boost::format;
|
|
||||||
using namespace CosmoTool;
|
|
||||||
|
|
||||||
struct NYU_Data
|
|
||||||
{
|
|
||||||
int index;
|
|
||||||
int sector;
|
|
||||||
int region;
|
|
||||||
double ra, dec;
|
|
||||||
double cz;
|
|
||||||
double fgotten;
|
|
||||||
double phi_z;
|
|
||||||
};
|
|
||||||
|
|
||||||
struct Position
|
|
||||||
{
|
|
||||||
double xyz[3];
|
|
||||||
};
|
|
||||||
|
|
||||||
struct ParticleData
|
|
||||||
{
|
|
||||||
vector<int> id_gal;
|
|
||||||
int id_mask;
|
|
||||||
vector<Position> pos;
|
|
||||||
double box[3][2];
|
|
||||||
double Lmax;
|
|
||||||
};
|
|
||||||
|
|
||||||
typedef vector<NYU_Data> NYU_VData;
|
|
||||||
|
|
||||||
void loadData(const string& fname, NYU_VData & data)
|
|
||||||
{
|
|
||||||
ifstream f(fname.c_str());
|
|
||||||
|
|
||||||
while (!f.eof())
|
|
||||||
{
|
|
||||||
NYU_Data d;
|
|
||||||
f >> d.index >> d.sector >> d.region >> d.ra >> d.dec >> d.cz >> d.fgotten >> d.phi_z;
|
|
||||||
data.push_back(d);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
void generateGalaxiesInCube(NYU_VData& data, ParticleData& output_data)
|
|
||||||
{
|
|
||||||
double d2r = M_PI/180;
|
|
||||||
|
|
||||||
output_data.pos.resize(data.size());
|
|
||||||
output_data.id_gal.resize(data.size());
|
|
||||||
|
|
||||||
for (int j = 0; j < 3; j++)
|
|
||||||
{
|
|
||||||
output_data.box[j][0] = -INFINITY;
|
|
||||||
output_data.box[j][1] = INFINITY;
|
|
||||||
}
|
|
||||||
|
|
||||||
for (int i = 0; i < data.size(); i++)
|
|
||||||
{
|
|
||||||
double ra = data[i].ra*d2r, dec = data[i].dec*d2r;
|
|
||||||
Position& p = output_data.pos[i];
|
|
||||||
|
|
||||||
p.xyz[0] = data[i].cz*cos(ra)*cos(dec);
|
|
||||||
p.xyz[1] = data[i].cz*sin(ra)*cos(dec);
|
|
||||||
p.xyz[2] = data[i].cz*sin(dec);
|
|
||||||
output_data.id_gal[i] = data[i].index;
|
|
||||||
|
|
||||||
for (int j = 0; j < 3; j++)
|
|
||||||
{
|
|
||||||
if (p.xyz[j] > output_data.box[j][0])
|
|
||||||
output_data.box[j][0] = p.xyz[j];
|
|
||||||
if (p.xyz[j] < output_data.box[j][1])
|
|
||||||
output_data.box[j][1] = p.xyz[j];
|
|
||||||
}
|
|
||||||
}
|
|
||||||
cout << format("Galaxy position generated: %d galaxies") % output_data.pos.size() << endl;
|
|
||||||
cout << format("box is %g < x < %g; %g < y < %g; %g < z < %g")
|
|
||||||
% (1e-2*output_data.box[0][1]) % (1e-2*output_data.box[0][0])
|
|
||||||
% (1e-2*output_data.box[1][1]) % (1e-2*output_data.box[1][0])
|
|
||||||
% (1e-2*output_data.box[2][1]) % (1e-2*output_data.box[2][0]) << endl;
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
static double cube(double x)
|
|
||||||
{
|
|
||||||
return x*x*x;
|
|
||||||
}
|
|
||||||
|
|
||||||
void generateBoxMask(generateFromCatalog_info& args ,
|
|
||||||
Healpix_Map<float>& mask,
|
|
||||||
vector<int>& pixel_list,
|
|
||||||
NYU_VData& data,
|
|
||||||
ParticleData& output_data)
|
|
||||||
{
|
|
||||||
int idx = -1;
|
|
||||||
int insertion = 0;
|
|
||||||
double volume = pixel_list.size()*1.0/mask.Npix()*4*M_PI;
|
|
||||||
int numToInsert;
|
|
||||||
|
|
||||||
idx = output_data.id_mask;
|
|
||||||
|
|
||||||
cout << "Generate box mask..." << endl;
|
|
||||||
|
|
||||||
double Rmax = output_data.Lmax, t = args.box_thickness_arg;
|
|
||||||
output_data.Lmax += args.box_thickness_arg;
|
|
||||||
|
|
||||||
|
|
||||||
volume *= Rmax*Rmax/1e6 * args.box_thickness_arg;
|
|
||||||
numToInsert = (int)floor(volume*args.box_density_arg);
|
|
||||||
|
|
||||||
for (int i = 0; i < numToInsert; i++)
|
|
||||||
{
|
|
||||||
Position p;
|
|
||||||
bool stop_here;
|
|
||||||
|
|
||||||
do
|
|
||||||
{
|
|
||||||
|
|
||||||
int p0 = (int)floor(drand48()*pixel_list.size());
|
|
||||||
vec3 v = mask.pix2vec(pixel_list[p0]);
|
|
||||||
double r = Rmax*pow(drand48()*(cube(1+t/Rmax)-1) + 1,1./3);
|
|
||||||
|
|
||||||
p.xyz[0] = v.x * r;
|
|
||||||
p.xyz[1] = v.y * r;
|
|
||||||
p.xyz[2] = v.z * r;
|
|
||||||
|
|
||||||
stop_here = true;
|
|
||||||
for (int j = 0; j < 3; j++)
|
|
||||||
{
|
|
||||||
if (p.xyz[j] > output_data.box[j][0] ||
|
|
||||||
p.xyz[j] < output_data.box[j][1])
|
|
||||||
stop_here = false;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
while (!stop_here);
|
|
||||||
|
|
||||||
output_data.pos.push_back(p);
|
|
||||||
output_data.id_gal.push_back(idx);
|
|
||||||
insertion++;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
void generateSurfaceMask(generateFromCatalog_info& args ,
|
|
||||||
Healpix_Map<float>& mask,
|
|
||||||
vector<int>& pixel_list,
|
|
||||||
NYU_VData& data,
|
|
||||||
ParticleData& output_data)
|
|
||||||
{
|
|
||||||
// Find the first free index
|
|
||||||
int idx = -1;
|
|
||||||
int insertion = 0;
|
|
||||||
double volume = pixel_list.size()*1.0/mask.Npix()*4*M_PI;
|
|
||||||
int numToInsert;
|
|
||||||
|
|
||||||
for (int i = 0; i < output_data.id_gal.size(); i++)
|
|
||||||
{
|
|
||||||
if (idx < output_data.id_gal[i])
|
|
||||||
idx = output_data.id_gal[i]+1;
|
|
||||||
}
|
|
||||||
|
|
||||||
output_data.id_mask = idx;
|
|
||||||
|
|
||||||
cout << "Generate surface mask..." << endl;
|
|
||||||
|
|
||||||
double Rmax = -1;
|
|
||||||
for (int j = 0; j < 3; j++)
|
|
||||||
{
|
|
||||||
Rmax = max(Rmax, max(output_data.box[j][0], -output_data.box[j][1]));
|
|
||||||
}
|
|
||||||
|
|
||||||
output_data.Lmax = Rmax;
|
|
||||||
|
|
||||||
|
|
||||||
cout << format("Rmax is %g, surface volume is %g") % (Rmax/100) % (volume/(4*M_PI)) << endl;
|
|
||||||
volume *= Rmax*Rmax*Rmax/3/1e6;
|
|
||||||
numToInsert = (int)floor(volume*args.density_fake_arg);
|
|
||||||
cout << format("3d volume to fill: %g (Mpc/h)^3") % volume << endl;
|
|
||||||
|
|
||||||
cout << format("Will insert %d particles") % numToInsert << endl;
|
|
||||||
|
|
||||||
double pct = 0;
|
|
||||||
for (int i = 0; i < numToInsert; i++)
|
|
||||||
{
|
|
||||||
double new_pct = i*100./numToInsert;
|
|
||||||
|
|
||||||
if (new_pct-pct > 5.)
|
|
||||||
{
|
|
||||||
pct = new_pct;
|
|
||||||
cout << format(" .. %3.0f %%") % pct << endl;
|
|
||||||
}
|
|
||||||
|
|
||||||
Position p;
|
|
||||||
bool stop_here;
|
|
||||||
|
|
||||||
do
|
|
||||||
{
|
|
||||||
|
|
||||||
int p0 = (int)floor(drand48()*pixel_list.size());
|
|
||||||
vec3 v = mask.pix2vec(pixel_list[p0]);
|
|
||||||
double r = Rmax*pow(drand48(),1./3);
|
|
||||||
|
|
||||||
p.xyz[0] = v.x * r;
|
|
||||||
p.xyz[1] = v.y * r;
|
|
||||||
p.xyz[2] = v.z * r;
|
|
||||||
|
|
||||||
stop_here = true;
|
|
||||||
for (int j = 0; j < 3; j++)
|
|
||||||
{
|
|
||||||
if (p.xyz[j] > output_data.box[j][0] ||
|
|
||||||
p.xyz[j] < output_data.box[j][1])
|
|
||||||
stop_here = false;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
while (!stop_here);
|
|
||||||
|
|
||||||
output_data.pos.push_back(p);
|
|
||||||
output_data.id_gal.push_back(idx);
|
|
||||||
insertion++;
|
|
||||||
}
|
|
||||||
cout << format("Done. Inserted %d particles.") % insertion << endl;
|
|
||||||
}
|
|
||||||
|
|
||||||
void saveData(ParticleData& pdata)
|
|
||||||
{
|
|
||||||
NcFile f("particles.nc", NcFile::Replace);
|
|
||||||
|
|
||||||
assert(f.is_valid());
|
|
||||||
|
|
||||||
NcDim *d = f.add_dim("space", 3);
|
|
||||||
NcDim *p = f.add_dim("Np", pdata.pos.size());
|
|
||||||
NcVar *v = f.add_var("particles", ncDouble, d, p);
|
|
||||||
double *x = new double[pdata.pos.size()];
|
|
||||||
|
|
||||||
for (int j = 0; j < 3; j++)
|
|
||||||
{
|
|
||||||
|
|
||||||
for (int i = 0; i < pdata.pos.size(); i++)
|
|
||||||
x[i] = pdata.pos[i].xyz[j];
|
|
||||||
|
|
||||||
v->put_rec(d, x, j);
|
|
||||||
}
|
|
||||||
|
|
||||||
v = f.add_var("id_gal", ncInt, p);
|
|
||||||
v->put(&pdata.id_gal[0], pdata.id_gal.size());
|
|
||||||
|
|
||||||
delete[] x;
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
void saveForZobov(ParticleData& pdata, const string& fname, const string& paramname)
|
|
||||||
{
|
|
||||||
UnformattedWrite f(fname);
|
|
||||||
static const char axis[] = { 'X', 'Y', 'Z' };
|
|
||||||
double Lmax = pdata.Lmax;
|
|
||||||
|
|
||||||
f.beginCheckpoint();
|
|
||||||
f.writeInt32(pdata.pos.size());
|
|
||||||
f.endCheckpoint();
|
|
||||||
|
|
||||||
for (int j = 0; j < 3; j++)
|
|
||||||
{
|
|
||||||
cout << format("Writing %c components...") % axis[j] << endl;
|
|
||||||
f.beginCheckpoint();
|
|
||||||
for (uint32_t i = 0; i < pdata.pos.size(); i++)
|
|
||||||
{
|
|
||||||
f.writeReal32((pdata.pos[i].xyz[j]+Lmax)/(2*Lmax));
|
|
||||||
}
|
|
||||||
f.endCheckpoint();
|
|
||||||
}
|
|
||||||
|
|
||||||
NcFile fp(paramname.c_str(), NcFile::Replace);
|
|
||||||
|
|
||||||
fp.add_att("range_x_min", -Lmax);
|
|
||||||
fp.add_att("range_x_max", Lmax);
|
|
||||||
fp.add_att("range_y_min", -Lmax);
|
|
||||||
fp.add_att("range_y_max", Lmax);
|
|
||||||
fp.add_att("range_z_min", -Lmax);
|
|
||||||
fp.add_att("range_z_max", Lmax);
|
|
||||||
|
|
||||||
NcDim *NumPart_dim = fp.add_dim("numpart_dim", pdata.pos.size());
|
|
||||||
NcVar *v = fp.add_var("particle_ids", ncInt, NumPart_dim);
|
|
||||||
NcVar *v2 = fp.add_var("expansion", ncDouble, NumPart_dim);
|
|
||||||
|
|
||||||
double *expansion_fac = new double[pdata.pos.size()];
|
|
||||||
|
|
||||||
for (int i = 0; i < pdata.pos.size(); i++)
|
|
||||||
expansion_fac[i] = 1.0;
|
|
||||||
|
|
||||||
v->put(&pdata.id_gal[0], pdata.id_gal.size());
|
|
||||||
v2->put(expansion_fac, pdata.pos.size());
|
|
||||||
|
|
||||||
delete[] expansion_fac;
|
|
||||||
}
|
|
||||||
|
|
||||||
int main(int argc, char **argv)
|
|
||||||
{
|
|
||||||
generateFromCatalog_info args_info;
|
|
||||||
generateFromCatalog_conf_params args_params;
|
|
||||||
|
|
||||||
generateFromCatalog_conf_init(&args_info);
|
|
||||||
generateFromCatalog_conf_params_init(&args_params);
|
|
||||||
|
|
||||||
args_params.check_required = 0;
|
|
||||||
if (generateFromCatalog_conf_ext (argc, argv, &args_info, &args_params))
|
|
||||||
return 1;
|
|
||||||
|
|
||||||
if (!args_info.configFile_given)
|
|
||||||
{
|
|
||||||
if (generateFromCatalog_conf_required (&args_info, GENERATEFROMCATALOG_CONF_PACKAGE))
|
|
||||||
return 1;
|
|
||||||
}
|
|
||||||
else
|
|
||||||
{
|
|
||||||
args_params.check_required = 1;
|
|
||||||
args_params.initialize = 0;
|
|
||||||
if (generateFromCatalog_conf_config_file (args_info.configFile_arg,
|
|
||||||
&args_info,
|
|
||||||
&args_params))
|
|
||||||
return 1;
|
|
||||||
}
|
|
||||||
|
|
||||||
generateFromCatalog_conf_print_version();
|
|
||||||
|
|
||||||
cout << "Loading NYU data..." << endl;
|
|
||||||
vector<NYU_Data> data;
|
|
||||||
Healpix_Map<float> o_mask;
|
|
||||||
vector<int> pixel_list;
|
|
||||||
ParticleData output_data;
|
|
||||||
|
|
||||||
loadData(args_info.catalog_arg, data);
|
|
||||||
|
|
||||||
|
|
||||||
cout << "Loading mask..." << endl;
|
|
||||||
read_Healpix_map_from_fits(args_info.mask_arg, o_mask);
|
|
||||||
|
|
||||||
Healpix_Map<float> mask;
|
|
||||||
|
|
||||||
mask.SetNside(128, RING);
|
|
||||||
mask.Import(o_mask);
|
|
||||||
|
|
||||||
computeContourPixels(mask,pixel_list);
|
|
||||||
|
|
||||||
// We compute a cube holding all the galaxies + the survey surface mask
|
|
||||||
|
|
||||||
generateGalaxiesInCube(data, output_data);
|
|
||||||
generateSurfaceMask(args_info, mask, pixel_list, data, output_data);
|
|
||||||
computeFilledPixels(mask,pixel_list);
|
|
||||||
generateBoxMask(args_info, mask, pixel_list, data, output_data);
|
|
||||||
|
|
||||||
saveForZobov(output_data, args_info.output_arg, args_info.params_arg);
|
|
||||||
// saveData(output_data);
|
|
||||||
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
10
python_tools/PKG-INFO
Normal file
10
python_tools/PKG-INFO
Normal file
|
|
@ -0,0 +1,10 @@
|
||||||
|
Metadata-Version: 1.0
|
||||||
|
Name: voidProject
|
||||||
|
Version: 1.0
|
||||||
|
Summary: UNKNOWN
|
||||||
|
Home-page: UNKNOWN
|
||||||
|
Author: UNKNOWN
|
||||||
|
Author-email: UNKNOWN
|
||||||
|
License: UNKNOWN
|
||||||
|
Description: UNKNOWN
|
||||||
|
Platform: UNKNOWN
|
||||||
14
python_tools/setup.py
Normal file
14
python_tools/setup.py
Normal file
|
|
@ -0,0 +1,14 @@
|
||||||
|
from distutils.core import setup
|
||||||
|
from distutils.extension import Extension
|
||||||
|
from Cython.Distutils import build_ext
|
||||||
|
import numpy as np
|
||||||
|
|
||||||
|
setup(
|
||||||
|
name='void_python_tools',
|
||||||
|
version='1.0',
|
||||||
|
cmdclass = {'build_ext': build_ext},
|
||||||
|
include_dirs = [np.get_include()],
|
||||||
|
packages=['void_python_tools','void_python_tools.backend','void_python_tools.apTools','void_python_tools.apTools.profiles','void_python_tools.apTools.chi2', 'void_python_tools.plotting'],
|
||||||
|
#ext_modules = [Extension("void_python_tools.chi2.velocityProfileFitNative", ["void_python_tools/chi2/velocityProfileFitNative.pyx"], libraries=["gsl", "gslcblas"]), Extension("void_python_tools.chi2.likelihoo", ["void_python_tools/chi2/likelihood.pyx"], libraries=["gsl", "gslcblas"])]
|
||||||
|
ext_modules = [Extension("void_python_tools.apTools.chi2.velocityProfileFitNative", ["void_python_tools/apTools/chi2/velocityProfileFitNative.pyx"], libraries=["gsl", "gslcblas"])]
|
||||||
|
)
|
||||||
3
python_tools/void_python_tools/__init__.py
Normal file
3
python_tools/void_python_tools/__init__.py
Normal file
|
|
@ -0,0 +1,3 @@
|
||||||
|
from void_python_tools.backend import *
|
||||||
|
from void_python_tools.apTools import *
|
||||||
|
from void_python_tools.plotting import *
|
||||||
BIN
python_tools/void_python_tools/__init__.pyc
Normal file
BIN
python_tools/void_python_tools/__init__.pyc
Normal file
Binary file not shown.
2
python_tools/void_python_tools/apTools/__init__.py
Normal file
2
python_tools/void_python_tools/apTools/__init__.py
Normal file
|
|
@ -0,0 +1,2 @@
|
||||||
|
from chi2 import *
|
||||||
|
from profiles import *
|
||||||
3
python_tools/void_python_tools/apTools/chi2/__init__.py
Normal file
3
python_tools/void_python_tools/apTools/chi2/__init__.py
Normal file
|
|
@ -0,0 +1,3 @@
|
||||||
|
from velocityProfileFitNative import *
|
||||||
|
from likelihood import *
|
||||||
|
from cosmologyTools import *
|
||||||
BIN
python_tools/void_python_tools/apTools/chi2/__init__.pyc
Normal file
BIN
python_tools/void_python_tools/apTools/chi2/__init__.pyc
Normal file
Binary file not shown.
|
|
@ -0,0 +1,94 @@
|
||||||
|
# a suite of functions to compute expansion rates, angular diameter
|
||||||
|
# distances, and expected void stretching
|
||||||
|
|
||||||
|
import numpy as np
|
||||||
|
import scipy.integrate as integrate
|
||||||
|
|
||||||
|
__all__=['expansion', 'angularDiameter', 'expectedStretch', 'aveStretch', 'aveExpansion', 'aveStretchCone', 'aveWeightedStretch']
|
||||||
|
|
||||||
|
# returns 1/E(z) for the given cosmology
|
||||||
|
def expansion(z, Om = 0.27, Ot = 1.0, w0 = -1.0, wa = 0.0):
|
||||||
|
wz = w0 + wa*z/(1+z)
|
||||||
|
ez = Om * (1+z)**3 + (Ot-Om)# * (1+z)**(3.+3*wz)
|
||||||
|
ez = 1./np.sqrt(ez)
|
||||||
|
return ez
|
||||||
|
|
||||||
|
|
||||||
|
# returns D_A(z) for the given cosmology
|
||||||
|
def angularDiameter(z, Om = 0.27, Ot = 1.0, w0 = -1.0, wa = 0.0):
|
||||||
|
da = integrate.quad(expansion, 0.0, z, args=(Om, Ot, w0, wa))[0]
|
||||||
|
return da
|
||||||
|
|
||||||
|
|
||||||
|
# returns expected void stretch for the given cosmology
|
||||||
|
def expectedStretch(z, Om = 0.27, Ot = 1.0, w0 = -1.0, wa = 0.0):
|
||||||
|
ez = 1./expansion(z, Om=Om, Ot=Ot, w0=w0, wa=wa)
|
||||||
|
da = angularDiameter(z, Om=Om, Ot=Ot, w0=w0, wa=wa)
|
||||||
|
return ez*da/z
|
||||||
|
|
||||||
|
|
||||||
|
# returns average expected void stretch for a given redshift range
|
||||||
|
def aveStretch(zStart, zEnd, Om = 0.27, Ot = 1.0, w0 = -1.0, wa = 0.0):
|
||||||
|
if zStart == 0.0: zStart = 1.e-6
|
||||||
|
ave = integrate.quad(expectedStretch, zStart, zEnd, args=(Om, Ot, w0, wa))[0]
|
||||||
|
ave /= (zEnd-zStart)
|
||||||
|
return ave
|
||||||
|
|
||||||
|
# -----------------------------------------------------------------------------
|
||||||
|
# returns average expected void stretch for a given redshift range
|
||||||
|
# assuming a cone
|
||||||
|
def aveStretchCone(zStart, zEnd, skyFrac = 0.19, Om = 0.27, Ot = 1.0,
|
||||||
|
w0 = -1.0, wa = 0.0):
|
||||||
|
if zStart == 0.0: zStart = 1.e-6
|
||||||
|
|
||||||
|
h1 = zStart
|
||||||
|
h2 = zEnd
|
||||||
|
|
||||||
|
r1 = skyFrac * 4* np.pi * zStart**2
|
||||||
|
r2 = skyFrac * 4 * np.pi * zEnd**2
|
||||||
|
|
||||||
|
# surface area of a slice within a cone
|
||||||
|
def coneSlice(x, h, r):
|
||||||
|
return np.pi * (r/h*x)**2
|
||||||
|
|
||||||
|
def coneFunc(z, h, r, Om = 0.27, Ot = 1.0, w0 = -1.0, wa = 0.0):
|
||||||
|
return coneSlice(z, h, r) * expectedStretch(z, Om, Ot, w0, wa)
|
||||||
|
|
||||||
|
aveHigh = integrate.quad(coneFunc, 0.0, zEnd, args=(h2, r2, Om, Ot, w0, wa), full_output=1)[0]
|
||||||
|
aveLow = integrate.quad(coneFunc, 0.0, zStart, args=(h1, r1, Om, Ot, w0, wa), full_output=1)[0]
|
||||||
|
volumeHigh = integrate.quad(coneSlice, 0.0, zEnd, args=(h2, r2))[0]
|
||||||
|
volumeLow = integrate.quad(coneSlice, 0.0, zStart, args=(h1, r1))[0]
|
||||||
|
|
||||||
|
return (aveHigh-aveLow)/(volumeHigh-volumeLow)
|
||||||
|
|
||||||
|
# -----------------------------------------------------------------------------
|
||||||
|
# returns average expected void stretch for a given redshift range
|
||||||
|
# weighted by an actual void distribution
|
||||||
|
def aveWeightedStretch(zStart, zEnd, skyFrac = 0.19, Om = 0.27, Ot = 1.0,
|
||||||
|
w0 = -1.0, wa = 0.0, dist=None, bins=None):
|
||||||
|
if zStart == 0.0: zStart = 1.e-6
|
||||||
|
|
||||||
|
def weightedSlice(x):
|
||||||
|
return np.interp(x, bins[:-1], dist)
|
||||||
|
|
||||||
|
def weightedFunc(z, Om = 0.27, Ot = 1.0, w0 = -1.0, wa = 0.0):
|
||||||
|
return expectedStretch(z, Om, Ot, w0, wa) *\
|
||||||
|
weightedSlice(z)
|
||||||
|
|
||||||
|
ave = integrate.quad(weightedFunc, zStart, zEnd, args=(Om, Ot, w0, wa),
|
||||||
|
full_output=1)[0]
|
||||||
|
|
||||||
|
volume = integrate.quad(weightedSlice, zStart, zEnd, full_output=1)[0]
|
||||||
|
|
||||||
|
return ave/volume
|
||||||
|
|
||||||
|
|
||||||
|
# -----------------------------------------------------------------------------
|
||||||
|
# returns average expected expansion for a given redshift range
|
||||||
|
def aveExpansion(zStart, zEnd, Om = 0.27, Ot = 1.0, w0 = -1.0, wa = 0.0):
|
||||||
|
if zStart == 0.0: zStart = 1.e-6
|
||||||
|
ave = integrate.quad(expansion, zStart, zEnd, args=(Om, Ot, w0, wa))[0]
|
||||||
|
ave = (zEnd-zStart)/ave
|
||||||
|
return ave
|
||||||
|
|
||||||
|
|
||||||
10841
python_tools/void_python_tools/apTools/chi2/velocityProfileFitNative.c
Normal file
10841
python_tools/void_python_tools/apTools/chi2/velocityProfileFitNative.c
Normal file
File diff suppressed because it is too large
Load diff
|
|
@ -0,0 +1,6 @@
|
||||||
|
from build import *
|
||||||
|
from draw import *
|
||||||
|
from fit import *
|
||||||
|
from mcmc import *
|
||||||
|
from generateExpFigure import *
|
||||||
|
from getSurveyProps import *
|
||||||
|
|
@ -0,0 +1,53 @@
|
||||||
|
import numpy as np
|
||||||
|
import healpy as healpy
|
||||||
|
import scipy.integrate
|
||||||
|
|
||||||
|
__all__=['getSurveyProps']
|
||||||
|
|
||||||
|
# returns the volume and galaxy density for a given redshit slice
|
||||||
|
def getSurveyProps(maskFile, zmin, zmax, selFunMin, selFunMax, portion, selectionFuncFile=None):
|
||||||
|
|
||||||
|
mask = healpy.read_map(maskFile)
|
||||||
|
area = (1.*np.size(np.where(mask > 0)) / np.size(mask)) * 4.*np.pi
|
||||||
|
zmin = zmin * 3000
|
||||||
|
zmax = zmax * 3000
|
||||||
|
volume = area * (zmax**3 - zmin**3) / 3
|
||||||
|
|
||||||
|
if selectionFuncFile != None:
|
||||||
|
selfunc = np.genfromtxt(selectionFuncFile)
|
||||||
|
selfunc = np.array(selfunc)
|
||||||
|
selfunc[:,0] = selfunc[:,0]/100.
|
||||||
|
selfuncUnity = selfunc
|
||||||
|
selfuncUnity[:,1] = 1.0
|
||||||
|
selfuncMin = selfunc[0,0]
|
||||||
|
selfuncMax = selfunc[-1,0]
|
||||||
|
selfuncDx = selfunc[1,0] - selfunc[0,0]
|
||||||
|
selfuncN = np.size(selfunc[:,0])
|
||||||
|
|
||||||
|
selFunMin *= 3000
|
||||||
|
selFunMax *= 3000
|
||||||
|
|
||||||
|
selFunMin = max(selFunMin, selfuncMin)
|
||||||
|
selFunMax = min(selFunMax, selfuncMax)
|
||||||
|
|
||||||
|
|
||||||
|
def f(z): return selfunc[np.ceil((z-selfuncMin)/selfuncDx), 1]*z**2
|
||||||
|
def fTotal(z): return selfuncUnity[np.ceil((z-selfuncMin)/selfuncDx), 1]*z**2
|
||||||
|
|
||||||
|
zrange = np.linspace(selFunMin, selFunMax)
|
||||||
|
|
||||||
|
nbar = scipy.integrate.quad(f, selFunMin, selFunMax)
|
||||||
|
nbar = nbar[0]
|
||||||
|
|
||||||
|
ntotal = scipy.integrate.quad(fTotal, 0.0, max(selfuncUnity[:,0]))
|
||||||
|
#ntotal = scipy.integrate.quad(f, 0.0, max(selfunc[:,0]))
|
||||||
|
ntotal = ntotal[0]
|
||||||
|
|
||||||
|
nbar = ntotal / area / nbar
|
||||||
|
|
||||||
|
else:
|
||||||
|
nbar = 1.0
|
||||||
|
|
||||||
|
#print "PROPERTIES: ", volume, nbar
|
||||||
|
|
||||||
|
return (volume, nbar)
|
||||||
2
python_tools/void_python_tools/backend/__init__.py
Normal file
2
python_tools/void_python_tools/backend/__init__.py
Normal file
|
|
@ -0,0 +1,2 @@
|
||||||
|
from classes import *
|
||||||
|
from launchers import *
|
||||||
1451
python_tools/void_python_tools/backend/backend.py
Executable file
1451
python_tools/void_python_tools/backend/backend.py
Executable file
File diff suppressed because it is too large
Load diff
169
python_tools/void_python_tools/backend/classes.py
Executable file
169
python_tools/void_python_tools/backend/classes.py
Executable file
|
|
@ -0,0 +1,169 @@
|
||||||
|
# classes and routines used to support scripts
|
||||||
|
|
||||||
|
import os
|
||||||
|
|
||||||
|
LIGHT_SPEED = 299792.458
|
||||||
|
|
||||||
|
class Stack:
|
||||||
|
zMin = 0.0
|
||||||
|
zMax = 0.1
|
||||||
|
rMin = 5
|
||||||
|
rMax = 15
|
||||||
|
zMinPlot = 0.0
|
||||||
|
zMaxPlot = 0.1
|
||||||
|
includeInHubble = True
|
||||||
|
partOfCombo = False
|
||||||
|
needProfile = True
|
||||||
|
rescaleMode = "rmax" # options: "rmax" to scale to largest void in stack
|
||||||
|
# "rv" normalize each void
|
||||||
|
|
||||||
|
def __init__(self, zMin, zMax, rMin, rMax, includeInHubble, partOfCombo,
|
||||||
|
zMinPlot=None, needProfile=True, rescaleMode="rmax"):
|
||||||
|
self.zMin = zMin
|
||||||
|
self.zMax = zMax
|
||||||
|
self.rMin = rMin
|
||||||
|
self.rMax = rMax
|
||||||
|
self.zMaxPlot = zMax
|
||||||
|
self.includeInHubble = includeInHubble
|
||||||
|
self.partOfCombo = partOfCombo
|
||||||
|
self.needProfile = needProfile
|
||||||
|
self.rescaleMode = rescaleMode
|
||||||
|
|
||||||
|
if zMinPlot == None:
|
||||||
|
self.zMinPlot = self.zMin
|
||||||
|
else:
|
||||||
|
self.zMinPlot = zMinPlot
|
||||||
|
|
||||||
|
class Sample:
|
||||||
|
dataType = "observation"
|
||||||
|
dataFormat = "sdss"
|
||||||
|
dataFile = "lss.dr72dim.dat"
|
||||||
|
fullName = "lss.dr72dim.dat"
|
||||||
|
nickName = "dim"
|
||||||
|
zobovDir = ""
|
||||||
|
maskFile = "rast_window_512.fits"
|
||||||
|
selFunFile = "czselfunc.all.dr72dim.dat"
|
||||||
|
skyFraction = 0.19
|
||||||
|
zBoundary = (0.0, 0.1)
|
||||||
|
zBoundaryMpc = (0., 300)
|
||||||
|
zRange = (0.0, 0.1)
|
||||||
|
omegaM = 0.27
|
||||||
|
minVoidRadius = 5
|
||||||
|
fakeDensity = 0.01
|
||||||
|
profileBinSize = 2 # Mpc
|
||||||
|
volumeLimited = True
|
||||||
|
includeInHubble = True
|
||||||
|
partOfCombo = False
|
||||||
|
isCombo = False
|
||||||
|
comboList = []
|
||||||
|
|
||||||
|
# applies to simulations only
|
||||||
|
boxLen = 1024 # Mpc/h
|
||||||
|
usePecVel = False
|
||||||
|
subsample = 1.0
|
||||||
|
useLightCone = True
|
||||||
|
numSubDivisions = 1
|
||||||
|
numSubvolumes = 1
|
||||||
|
mySubvolume = 1
|
||||||
|
|
||||||
|
stacks = []
|
||||||
|
|
||||||
|
def __init__(self, dataFile="", fullName="",
|
||||||
|
nickName="", maskFile="", selFunFile="",
|
||||||
|
zBoundary=(), zRange=(), zBoundaryMpc=(),
|
||||||
|
minVoidRadius=0, fakeDensity=0.01, volumeLimited=True,
|
||||||
|
includeInHubble=True, partOfCombo=False, isCombo=False,
|
||||||
|
comboList=(), profileBinSize=2.0, skyFraction=0.19,
|
||||||
|
dataType="observation", numSubDivisions=2,
|
||||||
|
boxLen=1024, usePecVel=False, omegaM=0.27,
|
||||||
|
numSubvolumes=1, mySubvolume=1, dataFormat="sdss",
|
||||||
|
subsample="1.0", useLightCone=True):
|
||||||
|
self.dataFile = dataFile
|
||||||
|
self.fullName = fullName
|
||||||
|
self.nickName = nickName
|
||||||
|
self.maskFile = maskFile
|
||||||
|
self.selFunFile = selFunFile
|
||||||
|
self.zBoundary = zBoundary
|
||||||
|
self.zBoundaryMpc = zBoundaryMpc
|
||||||
|
self.zRange = zRange
|
||||||
|
self.minVoidRadius = minVoidRadius
|
||||||
|
self.fakeDensity = fakeDensity
|
||||||
|
self.volumeLimited = volumeLimited
|
||||||
|
self.includeInHubble = includeInHubble
|
||||||
|
self.partOfCombo = partOfCombo
|
||||||
|
self.isCombo = isCombo
|
||||||
|
self.comboList = comboList
|
||||||
|
self.zobovDir = None
|
||||||
|
self.profileBinSize = profileBinSize
|
||||||
|
self.skyFraction = skyFraction
|
||||||
|
self.dataType = dataType
|
||||||
|
self.numSubDivisions = numSubDivisions
|
||||||
|
self.boxLen = boxLen
|
||||||
|
self.usePecVel = usePecVel
|
||||||
|
self.omegaM = omegaM
|
||||||
|
self.numSubvolumes = numSubvolumes
|
||||||
|
self.mySubvolume = mySubvolume
|
||||||
|
self.dataFormat = dataFormat
|
||||||
|
self.subsample = subsample
|
||||||
|
self.useLightCone = useLightCone
|
||||||
|
|
||||||
|
self.stacks = []
|
||||||
|
|
||||||
|
def addStack(self, zMin, zMax, rMin, rMax,
|
||||||
|
includeInHubble, partOfCombo,zMinPlot=None,
|
||||||
|
needProfile=True, rescaleMode="rmax"):
|
||||||
|
self.stacks.append(Stack(zMin, zMax, rMin, rMax,
|
||||||
|
includeInHubble, partOfCombo,
|
||||||
|
zMinPlot=zMinPlot, needProfile=needProfile,
|
||||||
|
rescaleMode=rescaleMode))
|
||||||
|
|
||||||
|
def getHubbleStacks(self):
|
||||||
|
stacksForHubble = []
|
||||||
|
for stack in self.stacks:
|
||||||
|
if stack.includeInHubble:
|
||||||
|
stacksForHubble.append(stack)
|
||||||
|
return stacksForHubble
|
||||||
|
|
||||||
|
def getUniqueRBins(self):
|
||||||
|
uniqueRStacks = []
|
||||||
|
for stack in self.stacks:
|
||||||
|
if not stack.includeInHubble:
|
||||||
|
continue
|
||||||
|
alreadyHere = False
|
||||||
|
for stackCheck in uniqueRStacks:
|
||||||
|
if stack.rMin == stackCheck.rMin and stack.rMax == stackCheck.rMax:
|
||||||
|
alreadyHere = True
|
||||||
|
break
|
||||||
|
if not alreadyHere:
|
||||||
|
uniqueRStacks.append(stack)
|
||||||
|
return uniqueRStacks
|
||||||
|
|
||||||
|
def getUniqueZBins(self):
|
||||||
|
uniqueZStacks = []
|
||||||
|
for stack in self.stacks:
|
||||||
|
if not stack.includeInHubble:
|
||||||
|
continue
|
||||||
|
alreadyHere = False
|
||||||
|
for stackCheck in uniqueZStacks:
|
||||||
|
if stack.zMin == stackCheck.zMin and stack.zMax == stackCheck.zMax:
|
||||||
|
alreadyHere = True
|
||||||
|
break
|
||||||
|
if not alreadyHere:
|
||||||
|
uniqueZStacks.append(stack)
|
||||||
|
return uniqueZStacks
|
||||||
|
|
||||||
|
# -----------------------------------------------------------------------------
|
||||||
|
# -----------------------------------------------------------------------------
|
||||||
|
def jobSuccessful(logFile, doneString):
|
||||||
|
jobDone = False
|
||||||
|
checkLine = ""
|
||||||
|
if os.access(logFile, os.F_OK):
|
||||||
|
filelines = file(logFile, "r").readlines()
|
||||||
|
if len(filelines) >= 1:
|
||||||
|
checkLine = filelines[-1]
|
||||||
|
jobDone = (checkLine == doneString)
|
||||||
|
return jobDone
|
||||||
|
|
||||||
|
def getStackSuffix(zMin, zMax, rMin, rMax, dataPortion):
|
||||||
|
return "z"+str(zMin)+"-"+str(zMax)+"_"+str(rMin)+"-"+str(rMax)+\
|
||||||
|
"Mpc"+"_"+dataPortion
|
||||||
1317
python_tools/void_python_tools/backend/launchers.py
Executable file
1317
python_tools/void_python_tools/backend/launchers.py
Executable file
File diff suppressed because it is too large
Load diff
2
python_tools/void_python_tools/plotting/__init__.py
Normal file
2
python_tools/void_python_tools/plotting/__init__.py
Normal file
|
|
@ -0,0 +1,2 @@
|
||||||
|
from plotTools import *
|
||||||
|
from plotDefs import *
|
||||||
13
python_tools/void_python_tools/plotting/plotDefs.py
Normal file
13
python_tools/void_python_tools/plotting/plotDefs.py
Normal file
|
|
@ -0,0 +1,13 @@
|
||||||
|
colorList = ['r', 'b', 'g', 'y', 'c', 'm', 'y',
|
||||||
|
'brown', 'grey',
|
||||||
|
'darkred', 'orange', 'pink', 'darkblue',
|
||||||
|
'lightblue', 'chocolate',
|
||||||
|
'indigo', 'lightseagreen', 'maroon', 'olive',
|
||||||
|
'royalblue', 'palevioletred', 'seagreen', 'tomato',
|
||||||
|
'aquamarine', 'darkslateblue',
|
||||||
|
'khaki', 'lawngreen', 'mediumorchid',
|
||||||
|
'orangered', 'thistle'
|
||||||
|
'yellowgreen']
|
||||||
|
|
||||||
|
linewidth = 4
|
||||||
|
fontsize = 12
|
||||||
69
python_tools/void_python_tools/plotting/plotTools.py
Normal file
69
python_tools/void_python_tools/plotting/plotTools.py
Normal file
|
|
@ -0,0 +1,69 @@
|
||||||
|
__all__=['plotNumberCounts']
|
||||||
|
|
||||||
|
from void_python_tools.backend.classes import *
|
||||||
|
from plotDefs import *
|
||||||
|
import numpy as np
|
||||||
|
import os
|
||||||
|
import pylab as plt
|
||||||
|
|
||||||
|
# -----------------------------------------------------------------------------
|
||||||
|
def plotNumberCounts(workDir=None, sampleList=None, figDir=None, plotNameBase="numbercount",
|
||||||
|
showPlot=False, dataPortion=None, setName=None):
|
||||||
|
|
||||||
|
plt.clf()
|
||||||
|
plt.xlabel("Comoving Distance (Mpc/h)")
|
||||||
|
plt.ylabel("Number of Voids")
|
||||||
|
|
||||||
|
plotTitle = setName
|
||||||
|
|
||||||
|
plotName = plotNameBase
|
||||||
|
|
||||||
|
xMin = 1.e00
|
||||||
|
xMax = 0
|
||||||
|
|
||||||
|
for (iSample,sample) in enumerate(sampleList):
|
||||||
|
|
||||||
|
sampleName = sample.fullName
|
||||||
|
lineTitle = sampleName
|
||||||
|
|
||||||
|
filename = workDir+"/sample_"+sampleName+"/centers_"+dataPortion+"_"+\
|
||||||
|
sampleName+".out"
|
||||||
|
if not os.access(filename, os.F_OK):
|
||||||
|
print "File not found: ", filename
|
||||||
|
continue
|
||||||
|
|
||||||
|
data = np.loadtxt(filename, comments="#")
|
||||||
|
if data.ndim == 1:
|
||||||
|
print " Too few!"
|
||||||
|
continue
|
||||||
|
|
||||||
|
zMin = sample.zRange[0]
|
||||||
|
zMax = sample.zRange[1]
|
||||||
|
|
||||||
|
range = (zMin, zMax)
|
||||||
|
nbins = np.ceil((zMax-zMin)/0.1)
|
||||||
|
|
||||||
|
thisMax = np.max(data[:,5])
|
||||||
|
thisMin = np.min(data[:,5])
|
||||||
|
if thisMax > xMax: xMax = thisMax
|
||||||
|
if thisMin < xMin: xMin = thisMin
|
||||||
|
|
||||||
|
plt.hist(data[:,5], bins=nbins,
|
||||||
|
label=lineTitle, color=colorList[iSample],
|
||||||
|
histtype = "step", range=range,
|
||||||
|
linewidth=linewidth)
|
||||||
|
|
||||||
|
#plt.legend(title = "Samples", loc = "upper right")
|
||||||
|
plt.title(plotTitle)
|
||||||
|
|
||||||
|
plt.xlim(xMin, xMax)
|
||||||
|
#plt.xlim(xMin, xMax*1.4) # make room for legend
|
||||||
|
|
||||||
|
plt.savefig(figDir+"/fig_"+plotName+".pdf", bbox_inches="tight")
|
||||||
|
plt.savefig(figDir+"/fig_"+plotName+".eps", bbox_inches="tight")
|
||||||
|
plt.savefig(figDir+"/fig_"+plotName+".png", bbox_inches="tight")
|
||||||
|
|
||||||
|
if showPlot:
|
||||||
|
os.system("display %s" % figDir+"/fig_"+plotName+".png")
|
||||||
|
|
||||||
|
|
||||||
|
|
@ -5,7 +5,7 @@
|
||||||
#include <math.h>
|
#include <math.h>
|
||||||
|
|
||||||
#define BIGFLT 1e30 /* Biggest possible floating-point number */
|
#define BIGFLT 1e30 /* Biggest possible floating-point number */
|
||||||
#define NLINKS 100 /* Number of possible links with the same rho_sl */
|
#define NLINKS 1000 /* Number of possible links with the same rho_sl */
|
||||||
#define FF fflush(stdout)
|
#define FF fflush(stdout)
|
||||||
|
|
||||||
typedef struct Particle {
|
typedef struct Particle {
|
||||||
|
|
@ -61,16 +61,19 @@ int main(int argc,char **argv) {
|
||||||
double *sorter, e1,maxdenscontrast;
|
double *sorter, e1,maxdenscontrast;
|
||||||
int *iord;
|
int *iord;
|
||||||
|
|
||||||
|
int mockIndex;
|
||||||
|
|
||||||
e1 = exp(1.)-1.;
|
e1 = exp(1.)-1.;
|
||||||
|
|
||||||
if (argc != 7) {
|
if (argc != 8) {
|
||||||
printf("Wrong number of arguments.\n");
|
printf("Wrong number of arguments.\n");
|
||||||
printf("arg1: adjacency file\n");
|
printf("arg1: adjacency file\n");
|
||||||
printf("arg2: volume file\n");
|
printf("arg2: volume file\n");
|
||||||
printf("arg3: output file containing particles in each zone\n");
|
printf("arg3: output file containing particles in each zone\n");
|
||||||
printf("arg4: output file containing zones in each void\n");
|
printf("arg4: output file containing zones in each void\n");
|
||||||
printf("arg5: output text file\n");
|
printf("arg5: output text file\n");
|
||||||
printf("arg6: Density threshold (0 for no threshold)\n\n");
|
printf("arg6: Density threshold (0 for no threshold)\n");
|
||||||
|
printf("arg7: Beginning index of mock galaxies\n\n");
|
||||||
exit(0);
|
exit(0);
|
||||||
}
|
}
|
||||||
adjfile = argv[1];
|
adjfile = argv[1];
|
||||||
|
|
@ -82,6 +85,11 @@ int main(int argc,char **argv) {
|
||||||
printf("Bad density threshold.\n");
|
printf("Bad density threshold.\n");
|
||||||
exit(0);
|
exit(0);
|
||||||
}
|
}
|
||||||
|
if (sscanf(argv[7],"%f",&mockIndex) == 0) {
|
||||||
|
printf("Bad mock galaxy index.\n");
|
||||||
|
exit(0);
|
||||||
|
}
|
||||||
|
printf("TOLERANCE: %f\n", voltol);
|
||||||
if (voltol <= 0.) {
|
if (voltol <= 0.) {
|
||||||
printf("Proceeding without a density threshold.\n");
|
printf("Proceeding without a density threshold.\n");
|
||||||
voltol = 1e30;
|
voltol = 1e30;
|
||||||
|
|
@ -140,7 +148,10 @@ int main(int argc,char **argv) {
|
||||||
// fread(&np,1, sizeof(int),adj);
|
// fread(&np,1, sizeof(int),adj);
|
||||||
for (i=0;i<np;i++) {
|
for (i=0;i<np;i++) {
|
||||||
// fread(&nin,1,sizeof(int),adj); /* actually nadj */
|
// fread(&nin,1,sizeof(int),adj); /* actually nadj */
|
||||||
if (p[i].ncnt != p[i].nadj) {
|
// PMS
|
||||||
|
if (p[i].ncnt != p[i].nadj && i < mockIndex) {
|
||||||
|
//if (p[i].ncnt != p[i].nadj) {
|
||||||
|
// END PMS
|
||||||
p[i].nadj = p[i].ncnt;
|
p[i].nadj = p[i].ncnt;
|
||||||
printf("We didn't get all of %d's adj's; %d != %d.\n",i,nin,p[i].nadj);
|
printf("We didn't get all of %d's adj's; %d != %d.\n",i,nin,p[i].nadj);
|
||||||
/*exit(0);*/
|
/*exit(0);*/
|
||||||
|
|
@ -163,7 +174,10 @@ int main(int argc,char **argv) {
|
||||||
FF;
|
FF;
|
||||||
for (i=0;i<np;i++) {
|
for (i=0;i<np;i++) {
|
||||||
fread(&p[i].dens,1,sizeof(float),vol);
|
fread(&p[i].dens,1,sizeof(float),vol);
|
||||||
if ((p[i].dens < 1e-30) || (p[i].dens > 1e30)) {
|
// PMS
|
||||||
|
if ((p[i].dens < 1e-30) || (p[i].dens > 1e30) && i < mockIndex) {
|
||||||
|
//if ((p[i].dens < 1e-30) || (p[i].dens > 1e30)) {
|
||||||
|
// END PMS
|
||||||
printf("Whacked-out volume found, of particle %d: %f\n",i,p[i].dens);
|
printf("Whacked-out volume found, of particle %d: %f\n",i,p[i].dens);
|
||||||
p[i].dens = 1.;
|
p[i].dens = 1.;
|
||||||
}
|
}
|
||||||
|
|
@ -343,6 +357,9 @@ int main(int argc,char **argv) {
|
||||||
fwrite(&np,1,4,zon);
|
fwrite(&np,1,4,zon);
|
||||||
fwrite(&nzones,1,4,zon);
|
fwrite(&nzones,1,4,zon);
|
||||||
for (h=0; h<nzones; h++) {
|
for (h=0; h<nzones; h++) {
|
||||||
|
// PMS
|
||||||
|
//printf("%d %d %d", &(z[h].np), m[h], z[h].np);
|
||||||
|
// END PMS
|
||||||
fwrite(&(z[h].np),1,4,zon);
|
fwrite(&(z[h].np),1,4,zon);
|
||||||
fwrite(m[h],z[h].np,4,zon);
|
fwrite(m[h],z[h].np,4,zon);
|
||||||
free(m[h]);
|
free(m[h]);
|
||||||
|
|
@ -540,11 +557,15 @@ int main(int argc,char **argv) {
|
||||||
for (h=0; h<nzones; h++) {
|
for (h=0; h<nzones; h++) {
|
||||||
i = iord[h];
|
i = iord[h];
|
||||||
prob = exp(-5.12*(z[i].denscontrast-1.) - 0.8*pow(z[i].denscontrast-1.,2.8));
|
prob = exp(-5.12*(z[i].denscontrast-1.) - 0.8*pow(z[i].denscontrast-1.,2.8));
|
||||||
|
// PMS
|
||||||
|
if (z[i].np == 1) continue;
|
||||||
|
// END PMS
|
||||||
fprintf(txt,"%d %d %d %e %e %d %d %e %d %f %6.2e\n",
|
fprintf(txt,"%d %d %d %e %e %d %d %e %d %f %6.2e\n",
|
||||||
h+1, i, z[i].core, p[z[i].core].dens, z[i].vol, z[i].np, z[i].nhl, z[i].voljoin, z[i].npjoin, z[i].denscontrast, prob);
|
h+1, i, z[i].core, p[z[i].core].dens, z[i].vol, z[i].np, z[i].nhl, z[i].voljoin, z[i].npjoin, z[i].denscontrast, prob);
|
||||||
|
|
||||||
} /* h+1 to start from 1, not zero */
|
} /* h+1 to start from 1, not zero */
|
||||||
fclose(txt);
|
fclose(txt);
|
||||||
|
|
||||||
|
printf("Done!\n");FF;
|
||||||
return(0);
|
return(0);
|
||||||
}
|
}
|
||||||
|
|
|
||||||
|
|
@ -18,7 +18,7 @@ int main(int argc, char *argv[]) {
|
||||||
coordT deladjs[3*MAXVERVER], points[3*MAXVERVER];
|
coordT deladjs[3*MAXVERVER], points[3*MAXVERVER];
|
||||||
pointT intpoints[3*MAXVERVER];
|
pointT intpoints[3*MAXVERVER];
|
||||||
FILE *pos, *out;
|
FILE *pos, *out;
|
||||||
char *posfile, outfile[80], *suffix;
|
char *posfile, outfile[200], *suffix, *outDir;
|
||||||
PARTADJ *adjs;
|
PARTADJ *adjs;
|
||||||
float *vols;
|
float *vols;
|
||||||
float predict, xmin,xmax,ymin,ymax,zmin,zmax;
|
float predict, xmin,xmax,ymin,ymax,zmin,zmax;
|
||||||
|
|
@ -33,7 +33,7 @@ int main(int argc, char *argv[]) {
|
||||||
int b[3];
|
int b[3];
|
||||||
double totalvol;
|
double totalvol;
|
||||||
|
|
||||||
if (argc != 9) {
|
if (argc != 10) {
|
||||||
printf("Wrong number of arguments.\n");
|
printf("Wrong number of arguments.\n");
|
||||||
printf("arg1: position file\n");
|
printf("arg1: position file\n");
|
||||||
printf("arg2: border size\n");
|
printf("arg2: border size\n");
|
||||||
|
|
@ -41,6 +41,7 @@ int main(int argc, char *argv[]) {
|
||||||
printf("arg4: suffix\n");
|
printf("arg4: suffix\n");
|
||||||
printf("arg5: number of divisions\n");
|
printf("arg5: number of divisions\n");
|
||||||
printf("arg6-8: b[0-2]\n\n");
|
printf("arg6-8: b[0-2]\n\n");
|
||||||
|
printf("arg9: output directory\n");
|
||||||
exit(0);
|
exit(0);
|
||||||
}
|
}
|
||||||
posfile = argv[1];
|
posfile = argv[1];
|
||||||
|
|
@ -76,6 +77,7 @@ int main(int argc, char *argv[]) {
|
||||||
printf("That's no b index; try again.\n");
|
printf("That's no b index; try again.\n");
|
||||||
exit(0);
|
exit(0);
|
||||||
}
|
}
|
||||||
|
outDir = argv[9];
|
||||||
|
|
||||||
/* Boxsize should be the range in r, yielding a range 0-1 */
|
/* Boxsize should be the range in r, yielding a range 0-1 */
|
||||||
np = posread(posfile,&r,1./boxsize);
|
np = posread(posfile,&r,1./boxsize);
|
||||||
|
|
@ -106,7 +108,7 @@ int main(int argc, char *argv[]) {
|
||||||
}
|
}
|
||||||
g = (bf / 2.)*(1. + sqrt(1 - 2.*s*s/(bf*bf)));
|
g = (bf / 2.)*(1. + sqrt(1 - 2.*s*s/(bf*bf)));
|
||||||
printf("s = %f, bf = %f, g = %f.\n",s,bf,g);
|
printf("s = %f, bf = %f, g = %f.\n",s,bf,g);
|
||||||
|
|
||||||
fflush(stdout);
|
fflush(stdout);
|
||||||
|
|
||||||
adjs = (PARTADJ *)malloc(np*sizeof(PARTADJ));
|
adjs = (PARTADJ *)malloc(np*sizeof(PARTADJ));
|
||||||
|
|
@ -305,10 +307,10 @@ int main(int argc, char *argv[]) {
|
||||||
totalvol += (double)vols[i];
|
totalvol += (double)vols[i];
|
||||||
}
|
}
|
||||||
printf("Average volume = %g\n",totalvol/(float)nvp);
|
printf("Average volume = %g\n",totalvol/(float)nvp);
|
||||||
|
|
||||||
/* Now the output!
|
/* Now the output!
|
||||||
First number of particles */
|
First number of particles */
|
||||||
sprintf(outfile,"part.%s.%02d.%02d.%02d",suffix,b[0],b[1],b[2]);
|
sprintf(outfile,"%s/part.%s.%02d.%02d.%02d",outDir,suffix,b[0],b[1],b[2]);
|
||||||
|
|
||||||
printf("Output to %s\n\n",outfile);
|
printf("Output to %s\n\n",outfile);
|
||||||
out = fopen(outfile,"w");
|
out = fopen(outfile,"w");
|
||||||
|
|
|
||||||
|
|
@ -11,7 +11,7 @@ int main(int argc, char *argv[]) {
|
||||||
int i, np;
|
int i, np;
|
||||||
float **rfloat, rtemp[3];
|
float **rfloat, rtemp[3];
|
||||||
FILE *pos, *scr;
|
FILE *pos, *scr;
|
||||||
char *posfile, scrfile[80], systemstr[90], *suffix;
|
char *posfile, scrfile[200], systemstr[90], *suffix, *outDir, *vobozPath;
|
||||||
float xmin,xmax,ymin,ymax,zmin,zmax;
|
float xmin,xmax,ymin,ymax,zmin,zmax;
|
||||||
|
|
||||||
int isitinbuf;
|
int isitinbuf;
|
||||||
|
|
@ -23,14 +23,20 @@ int main(int argc, char *argv[]) {
|
||||||
float border, boxsize;
|
float border, boxsize;
|
||||||
float c[3];
|
float c[3];
|
||||||
int b[3];
|
int b[3];
|
||||||
|
int numThreads;
|
||||||
|
int mockIndex;
|
||||||
|
|
||||||
if (argc != 6) {
|
if (argc != 10) {
|
||||||
printf("Wrong number of arguments.\n");
|
printf("Wrong number of arguments.\n");
|
||||||
printf("arg1: position file\n");
|
printf("arg1: position file\n");
|
||||||
printf("arg2: buffer size (default 0.1)\n");
|
printf("arg2: buffer size (default 0.1)\n");
|
||||||
printf("arg3: box size\n");
|
printf("arg3: box size\n");
|
||||||
printf("arg4: number of divisions (default 2)\n");
|
printf("arg4: number of divisions (default 2)\n");
|
||||||
printf("arg5: suffix describing this run\n\n");
|
printf("arg5: suffix describing this run\n");
|
||||||
|
printf("arg6: number of parallel threads\n");
|
||||||
|
printf("arg7: location of voboz executables\n");
|
||||||
|
printf("arg8: output directory\n");
|
||||||
|
printf("arg9: index of mock galaxies\n\n");
|
||||||
exit(0);
|
exit(0);
|
||||||
}
|
}
|
||||||
posfile = argv[1];
|
posfile = argv[1];
|
||||||
|
|
@ -55,6 +61,18 @@ int main(int argc, char *argv[]) {
|
||||||
}
|
}
|
||||||
|
|
||||||
suffix = argv[5];
|
suffix = argv[5];
|
||||||
|
vobozPath = argv[6];
|
||||||
|
if (sscanf(vobozPath,"%d",&numThreads) != 1) {
|
||||||
|
printf("That's no number of threads; try again.\n");
|
||||||
|
exit(0);
|
||||||
|
}
|
||||||
|
vobozPath = argv[7];
|
||||||
|
outDir = argv[8];
|
||||||
|
if (sscanf(argv[9],"%d",&mockIndex) != 1) {
|
||||||
|
printf("That's no mock galaxy index; try again.\n");
|
||||||
|
exit(0);
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
/* Read the position file */
|
/* Read the position file */
|
||||||
np = posread(posfile,&rfloat,1./boxsize);
|
np = posread(posfile,&rfloat,1./boxsize);
|
||||||
|
|
@ -141,15 +159,19 @@ int main(int argc, char *argv[]) {
|
||||||
for (b[0]=0;b[0]<numdiv; b[0]++) {
|
for (b[0]=0;b[0]<numdiv; b[0]++) {
|
||||||
for (b[1] = 0; b[1] < numdiv; b[1]++) {
|
for (b[1] = 0; b[1] < numdiv; b[1]++) {
|
||||||
for (b[2] = 0; b[2] < numdiv; b[2]++) {
|
for (b[2] = 0; b[2] < numdiv; b[2]++) {
|
||||||
fprintf(scr,"./voz1b1 %s %f %f,%f,%f %s %d %d %d %d &\n",
|
// TEST
|
||||||
posfile,border,boxsize,boxsize,boxsize,suffix,numdiv,b[0],b[1],b[2]);
|
fprintf(scr,"%s/voz1b1 %s %f %f,%f,%f %s %d %d %d %d %s&\n",
|
||||||
|
vobozPath,
|
||||||
|
posfile,border,boxsize,boxsize,boxsize,suffix,numdiv,b[0],b[1],b[2],
|
||||||
|
outDir);
|
||||||
|
// END TEST
|
||||||
p++;
|
p++;
|
||||||
if ((p == NUMCPU)) { fprintf(scr, "wait\n"); p = 0; }
|
if ((p == numThreads)) { fprintf(scr, "wait\n"); p = 0; }
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
fprintf(scr,"wait\n");
|
fprintf(scr,"wait\n");
|
||||||
fprintf(scr,"./voztie %d %s\n",numdiv,suffix);
|
fprintf(scr,"%s/voztie %d %s %s %d\n", vobozPath, numdiv,suffix, outDir, mockIndex);
|
||||||
fclose(scr);
|
fclose(scr);
|
||||||
|
|
||||||
sprintf(systemstr,"chmod u+x %s",scrfile);
|
sprintf(systemstr,"chmod u+x %s",scrfile);
|
||||||
|
|
|
||||||
135
zobov/voztie.c
135
zobov/voztie.c
|
|
@ -6,7 +6,7 @@
|
||||||
int main(int argc, char *argv[]) {
|
int main(int argc, char *argv[]) {
|
||||||
|
|
||||||
FILE *part, *adj, *vol;
|
FILE *part, *adj, *vol;
|
||||||
char partfile[80], *suffix, adjfile[80], volfile[80];
|
char partfile[200], *suffix, adjfile[200], volfile[200], *outDir;
|
||||||
float *vols, volstemp;
|
float *vols, volstemp;
|
||||||
|
|
||||||
PARTADJ *adjs;
|
PARTADJ *adjs;
|
||||||
|
|
@ -16,11 +16,17 @@ int main(int argc, char *argv[]) {
|
||||||
int i,j,k,p,nout;
|
int i,j,k,p,nout;
|
||||||
int nvp,npnotdone,nvpmax, nvpsum, *orig;
|
int nvp,npnotdone,nvpmax, nvpsum, *orig;
|
||||||
double avgnadj, avgvol;
|
double avgnadj, avgvol;
|
||||||
|
|
||||||
if (argc != 3) {
|
// PMS
|
||||||
|
int mockIndex;
|
||||||
|
// END PMS
|
||||||
|
|
||||||
|
if (argc != 5) {
|
||||||
printf("Wrong number of arguments.\n");
|
printf("Wrong number of arguments.\n");
|
||||||
printf("arg1: number of divisions (default 2)\n");
|
printf("arg1: number of divisions (default 2)\n");
|
||||||
printf("arg2: suffix describing this run\n\n");
|
printf("arg2: suffix describing this run\n");
|
||||||
|
printf("arg3: file directory\n");
|
||||||
|
printf("arg4: Beginning index of mock particles\n\n");
|
||||||
exit(0);
|
exit(0);
|
||||||
}
|
}
|
||||||
if (sscanf(argv[1],"%d",&numdiv) != 1) {
|
if (sscanf(argv[1],"%d",&numdiv) != 1) {
|
||||||
|
|
@ -32,13 +38,18 @@ int main(int argc, char *argv[]) {
|
||||||
numdiv = 2;
|
numdiv = 2;
|
||||||
}
|
}
|
||||||
suffix = argv[2];
|
suffix = argv[2];
|
||||||
|
outDir = argv[3];
|
||||||
|
if (sscanf(argv[4],"%d",&mockIndex) != 1) {
|
||||||
|
printf("That's no mock galaxy index; try again.\n");
|
||||||
|
exit(0);
|
||||||
|
}
|
||||||
|
|
||||||
np = -1; nvpmax = -1; nvpsum = 0;
|
np = -1; nvpmax = -1; nvpsum = 0;
|
||||||
|
|
||||||
for (i = 0; i < numdiv; i++) {
|
for (i = 0; i < numdiv; i++) {
|
||||||
for (j = 0; j < numdiv; j++) {
|
for (j = 0; j < numdiv; j++) {
|
||||||
for (k = 0; k < numdiv; k++) {
|
for (k = 0; k < numdiv; k++) {
|
||||||
sprintf(partfile,"part.%s.%02d.%02d.%02d",suffix,i,j,k);
|
sprintf(partfile,"%s/part.%s.%02d.%02d.%02d",outDir,suffix,i,j,k);
|
||||||
part = fopen(partfile,"r");
|
part = fopen(partfile,"r");
|
||||||
if (part == NULL) {
|
if (part == NULL) {
|
||||||
printf("Unable to open file %s.\n\n",partfile);
|
printf("Unable to open file %s.\n\n",partfile);
|
||||||
|
|
@ -46,6 +57,7 @@ int main(int argc, char *argv[]) {
|
||||||
}
|
}
|
||||||
fread(&np2,1,sizeof(int),part);
|
fread(&np2,1,sizeof(int),part);
|
||||||
fread(&nvp,1,sizeof(int),part);
|
fread(&nvp,1,sizeof(int),part);
|
||||||
|
nvpsum += nvp;
|
||||||
if (np == -1)
|
if (np == -1)
|
||||||
np = np2;
|
np = np2;
|
||||||
else
|
else
|
||||||
|
|
@ -58,9 +70,14 @@ int main(int argc, char *argv[]) {
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
printf("We have %d particles to tie together.\n",np); fflush(stdout);
|
printf("We have %d particles to tie together.\n",np); fflush(stdout);
|
||||||
printf("The maximum number of particles in a file is %d.\n",nvpmax);
|
printf("The maximum number of particles in a file is %d.\n",nvpmax);
|
||||||
|
|
||||||
|
// PMS
|
||||||
|
if (mockIndex == -1) mockIndex = np;
|
||||||
|
// END PMS
|
||||||
|
|
||||||
adjs = (PARTADJ *)malloc(np*sizeof(PARTADJ));
|
adjs = (PARTADJ *)malloc(np*sizeof(PARTADJ));
|
||||||
if (adjs == NULL) printf("Couldn't allocate adjs.\n");
|
if (adjs == NULL) printf("Couldn't allocate adjs.\n");
|
||||||
vols = (float *)malloc(np*sizeof(float));
|
vols = (float *)malloc(np*sizeof(float));
|
||||||
|
|
@ -77,7 +94,7 @@ int main(int argc, char *argv[]) {
|
||||||
for (i = 0; i < numdiv; i++) {
|
for (i = 0; i < numdiv; i++) {
|
||||||
for (j = 0; j < numdiv; j++) {
|
for (j = 0; j < numdiv; j++) {
|
||||||
for (k = 0; k < numdiv; k++) {
|
for (k = 0; k < numdiv; k++) {
|
||||||
sprintf(partfile,"part.%s.%02d.%02d.%02d",suffix,i,j,k);
|
sprintf(partfile,"%s/part.%s.%02d.%02d.%02d",outDir,suffix,i,j,k);
|
||||||
part = fopen(partfile,"r");
|
part = fopen(partfile,"r");
|
||||||
if (part == NULL) {
|
if (part == NULL) {
|
||||||
printf("Unable to open file %s.\n\n",partfile);
|
printf("Unable to open file %s.\n\n",partfile);
|
||||||
|
|
@ -93,10 +110,14 @@ int main(int argc, char *argv[]) {
|
||||||
for (p=0;p<nvp;p++) {
|
for (p=0;p<nvp;p++) {
|
||||||
fread(&volstemp,1,sizeof(float),part);
|
fread(&volstemp,1,sizeof(float),part);
|
||||||
if (vols[orig[p]] > -1.)
|
if (vols[orig[p]] > -1.)
|
||||||
if (fabs(vols[orig[p]]-volstemp)/volstemp > 1.5e-3) {
|
// PMS
|
||||||
// printf("Inconsistent volumes for p. %d: (%10g,%10g)!\n",
|
if (fabs(vols[orig[p]]-volstemp)/volstemp > 1.5e-3 && orig[p] < mockIndex) {
|
||||||
// orig[p],vols[orig[p]],volstemp);
|
//if (fabs(vols[orig[p]]-volstemp)/volstemp > 1.5e-3) {
|
||||||
// exit(0);
|
// END PMS
|
||||||
|
printf("Inconsistent volumes for p. %d: (%10g,%10g)!\n",
|
||||||
|
orig[p],vols[orig[p]],volstemp);
|
||||||
|
// TEST
|
||||||
|
//exit(0);
|
||||||
}
|
}
|
||||||
vols[orig[p]] = volstemp;
|
vols[orig[p]] = volstemp;
|
||||||
}
|
}
|
||||||
|
|
@ -121,8 +142,71 @@ int main(int argc, char *argv[]) {
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
printf("\n");
|
printf("\n");
|
||||||
|
|
||||||
|
// PMS : remove mock galaxies and anything adjacent to a mock galaxy
|
||||||
|
printf("\nRemoving mock galaxies...\n");
|
||||||
|
|
||||||
|
// completely unlink mock particles
|
||||||
|
for (i = mockIndex; i < np; i++) {
|
||||||
|
vols[i] = 1.e-29;
|
||||||
|
adjs[i].nadj = 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
int numRemoved = 0;
|
||||||
|
|
||||||
|
// unlink particles adjacent to mock galaxies
|
||||||
|
for (i = 0; i < mockIndex; i++) {
|
||||||
|
for (j = 0; j < adjs[i].nadj; j++) {
|
||||||
|
if (adjs[i].adj[j] > mockIndex) {
|
||||||
|
//printf("KILLING %d\n", i);
|
||||||
|
vols[i] = 1.e-29;
|
||||||
|
adjs[i].nadj = 0;
|
||||||
|
numRemoved++;
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// update all other adjacencies
|
||||||
|
for (i = 0; i < mockIndex; i++) {
|
||||||
|
|
||||||
|
int numAdjSaved = 0;
|
||||||
|
for (j = 0; j < adjs[i].nadj; j++) {
|
||||||
|
|
||||||
|
//if ( vols[adjs[i].adj[j]] != -99) {
|
||||||
|
if ( adjs[adjs[i].adj[j]].nadj != 0) {
|
||||||
|
adjs[i].adj[numAdjSaved] = adjs[i].adj[j];
|
||||||
|
numAdjSaved++;
|
||||||
|
}
|
||||||
|
|
||||||
|
}
|
||||||
|
adjs[i].nadj = numAdjSaved;
|
||||||
|
|
||||||
|
}
|
||||||
|
|
||||||
|
/*
|
||||||
|
for (i = 0; i < mockIndex; i++) {
|
||||||
|
printf("ADJ: %d %d : ", i, adjs[i].nadj);
|
||||||
|
for (j = 0; j < adjs[i].nadj; j++) {
|
||||||
|
printf(" %d", adjs[i].adj[j]);
|
||||||
|
}
|
||||||
|
printf("\n");
|
||||||
|
}
|
||||||
|
*/
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
printf("Removed %d mock galaxies and %d adjacent galaxies.\n", np-mockIndex,
|
||||||
|
numRemoved);
|
||||||
|
printf("There are %d galaxies remaining.\n", mockIndex-numRemoved);
|
||||||
|
|
||||||
|
// END PMS
|
||||||
|
|
||||||
npnotdone = 0; avgnadj = 0.; avgvol = 0.;
|
npnotdone = 0; avgnadj = 0.; avgvol = 0.;
|
||||||
for (p=0;p<np;p++) {
|
for (p=0;p<np;p++) {
|
||||||
|
// PMS
|
||||||
|
if (vols[p] == 1.e-29) continue;
|
||||||
|
// END PMS
|
||||||
if (vols[p] == -1.) npnotdone++;
|
if (vols[p] == -1.) npnotdone++;
|
||||||
avgnadj += (double)(adjs[p].nadj);
|
avgnadj += (double)(adjs[p].nadj);
|
||||||
avgvol += (double)(vols[p]);
|
avgvol += (double)(vols[p]);
|
||||||
|
|
@ -138,25 +222,34 @@ int main(int argc, char *argv[]) {
|
||||||
|
|
||||||
/* Now the output! */
|
/* Now the output! */
|
||||||
|
|
||||||
sprintf(adjfile,"adj%s.dat",suffix);
|
sprintf(adjfile,"%s/adj%s.dat",outDir,suffix);
|
||||||
sprintf(volfile,"vol%s.dat",suffix);
|
sprintf(volfile,"%s/vol%s.dat",outDir,suffix);
|
||||||
|
|
||||||
printf("Outputting to %s, %s\n\n",adjfile,volfile);
|
printf("Outputting to%s, %s\n\n", adjfile, volfile);
|
||||||
|
|
||||||
adj = fopen(adjfile,"w");
|
adj = fopen(adjfile,"w");
|
||||||
if (adj == NULL) {
|
if (adj == NULL) {
|
||||||
printf("Unable to open %s\n",adjfile);
|
printf("Unable to open %s\n",adjfile);
|
||||||
exit(0);
|
exit(0);
|
||||||
}
|
}
|
||||||
fwrite(&np,1, sizeof(int),adj);
|
// PMS
|
||||||
|
fwrite(&mockIndex,1, sizeof(int),adj);
|
||||||
|
//fwrite(&np,1, sizeof(int),adj);
|
||||||
|
// END OMS
|
||||||
/* Adjacencies: first the numbers of adjacencies,
|
/* Adjacencies: first the numbers of adjacencies,
|
||||||
and the number we're actually going to write per particle */
|
and the number we're actually going to write per particle */
|
||||||
for (i=0;i<np;i++)
|
// PMS
|
||||||
|
for (i=0;i<mockIndex;i++)
|
||||||
|
//for (i=0;i<np;i++)
|
||||||
|
// END PMS
|
||||||
fwrite(&adjs[i].nadj,1,sizeof(int),adj);
|
fwrite(&adjs[i].nadj,1,sizeof(int),adj);
|
||||||
|
|
||||||
/* Now the lists of adjacencies (without double counting) */
|
/* Now the lists of adjacencies (without double counting) */
|
||||||
for (i=0;i<np;i++)
|
// PMS
|
||||||
if (adjs[i].nadj > 0) {
|
for (i=0;i<mockIndex;i++) {
|
||||||
|
//for (i=0;i<np;i++) {
|
||||||
|
//if (adjs[i].nadj > 0) {
|
||||||
|
// END PMS
|
||||||
nout = 0;
|
nout = 0;
|
||||||
for (j=0;j<adjs[i].nadj; j++) if (adjs[i].adj[j] > i) nout++;
|
for (j=0;j<adjs[i].nadj; j++) if (adjs[i].adj[j] > i) nout++;
|
||||||
fwrite(&nout,1,sizeof(int),adj);
|
fwrite(&nout,1,sizeof(int),adj);
|
||||||
|
|
@ -173,8 +266,12 @@ int main(int argc, char *argv[]) {
|
||||||
printf("Unable to open %s\n",volfile);
|
printf("Unable to open %s\n",volfile);
|
||||||
exit(0);
|
exit(0);
|
||||||
}
|
}
|
||||||
fwrite(&np,1, sizeof(int),vol);
|
// PMS
|
||||||
fwrite(vols,sizeof(float),np,vol);
|
fwrite(&mockIndex,1, sizeof(int),vol);
|
||||||
|
fwrite(vols,sizeof(float),mockIndex,vol);
|
||||||
|
//fwrite(&np,1, sizeof(int),vol);
|
||||||
|
//fwrite(vols,sizeof(float),np,vol);
|
||||||
|
// END PMS
|
||||||
|
|
||||||
fclose(vol);
|
fclose(vol);
|
||||||
|
|
||||||
|
|
|
||||||
|
|
@ -36,6 +36,8 @@ int delaunadj (coordT *points, int nvp, int nvpbuf, int nvpall, PARTADJ **adjs)
|
||||||
int numdiv;
|
int numdiv;
|
||||||
|
|
||||||
PARTADJ adjst;
|
PARTADJ adjst;
|
||||||
|
|
||||||
|
int errorReported = 0;
|
||||||
|
|
||||||
adjst.adj = (int *)malloc(MAXVERVER*sizeof(int));
|
adjst.adj = (int *)malloc(MAXVERVER*sizeof(int));
|
||||||
if (adjst.adj == NULL) {
|
if (adjst.adj == NULL) {
|
||||||
|
|
@ -100,9 +102,11 @@ int delaunadj (coordT *points, int nvp, int nvpbuf, int nvpall, PARTADJ **adjs)
|
||||||
if (adjst.nadj >= 4) {
|
if (adjst.nadj >= 4) {
|
||||||
qsort((void *)adjst.adj, adjst.nadj, sizeof(int), &compar);
|
qsort((void *)adjst.adj, adjst.nadj, sizeof(int), &compar);
|
||||||
count = 1;
|
count = 1;
|
||||||
|
|
||||||
for (i=1; i<adjst.nadj; i++)
|
for (i=1; i<adjst.nadj; i++)
|
||||||
if (adjst.adj[i] != adjst.adj[i-1]) {
|
if (adjst.adj[i] != adjst.adj[i-1]) {
|
||||||
if (adjst.adj[i] >= nvpbuf) {
|
if (adjst.adj[i] >= nvpbuf && !errorReported) {
|
||||||
|
errorReported = 1;
|
||||||
printf("Guard point encountered. Increase border and/or nguard.\n");
|
printf("Guard point encountered. Increase border and/or nguard.\n");
|
||||||
printf("P:(%f,%f,%f), G: (%f,%f,%f)\n",points[3*ver],points[3*ver+1],points[3*ver+2],
|
printf("P:(%f,%f,%f), G: (%f,%f,%f)\n",points[3*ver],points[3*ver+1],points[3*ver+2],
|
||||||
points[3*adjst.adj[i]],points[3*adjst.adj[i]+1],points[3*adjst.adj[i]+2]);
|
points[3*adjst.adj[i]],points[3*adjst.adj[i]+1],points[3*adjst.adj[i]+2]);
|
||||||
|
|
|
||||||
Loading…
Add table
Add a link
Reference in a new issue