guilhem_lavaux/vide_public
0
0
Fork 0
mirror of https://bitbucket.org/cosmicvoids/vide_public.git synced 2025-07-05 07:41:11 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

renamed c_tools to c_src and moved zobov to that directory

Browse source
This commit is contained in:
Paul M. Sutter 2024-05-22 15:54:36 -04:00
parent 50ad2d6d73
commit 3203c24ec5
48 changed files with 3 additions and 4 deletions
Download patch file Download diff file Expand all files Collapse all files

177
c_tools/prep/loaders/multidark_loader.cpp
View file

@ -1,177 +0,0 @@
/*+
VIDE -- Void IDentification and Examination -- ./c_tools/mock/loaders/multidark_loader.cpp
Copyright (C) 2010-2014 Guilhem Lavaux
Copyright (C) 2011-2014 P. M. Sutter
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; version 2 of the License.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License along
with this program; if not, write to the Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+*/
#include <cassert>
#include <boost/format.hpp>
#include <string>
#include <fstream>
#include <iostream>
#include <CosmoTool/loadRamses.hpp>
#include <CosmoTool/fortran.hpp>
#include "simulation_loader.hpp"
using boost::format;
using namespace std;
using namespace CosmoTool;
static const double one_kpc = 3.08567802e16; /* km */
static const double one_Gyr = 3.1558149984e16; /* sec */
class MultiDarkLoader: public SimulationLoader
{
protected:
SimuData *header;
string darkname;
SimulationPreprocessor *preproc;
public:
MultiDarkLoader(const std::string& name, SimuData *h, SimulationPreprocessor *p)
: preproc(p), darkname(name), header(h)
{
}
~MultiDarkLoader()
{
delete header;
}
int num_files()
{
return 1;
}
SimuData *getHeader()
{
return header;
}
SimuData *loadFile(int id)
{
if (id != 0)
return 0;
ifstream fp(darkname.c_str());
SimuData *simu = new SimuData;
fp >> simu->BoxSize >> simu->Omega_M >> simu->Hubble >> simu->time >> simu->NumPart;
simu->time = 1./(1.+simu->time); // convert to scale factor
simu->TotalNumPart = simu->NumPart;
simu->Omega_Lambda = 1.0 - simu->Omega_M;
long estimated = (preproc == 0) ? simu->NumPart : preproc->getEstimatedPostprocessed(simu->NumPart);
long allocated = estimated;
for (int k = 0; k < 3; k++) {
simu->Pos[k] = new float[allocated];
simu->Vel[k] = new float[allocated];
}
simu->Id = new int64_t[allocated];
long *uniqueID = new long[allocated];
long *index = new long[allocated];
double tempData;
double shift = 0.5*simu->BoxSize;
double rescale_position = simu->Hubble*1.e-5*100./simu->time;
double rescale_velocity = one_kpc/one_Gyr;
#define INFINITY std::numeric_limits<float>::max()
float min_pos[3] = {INFINITY,INFINITY, INFINITY}, max_pos[3] = {-INFINITY,-INFINITY,-INFINITY};
cout << "loading multidark particles" << endl;
long actualNumPart = 0;
for (long i = 0; i < simu->NumPart; i++) {
SingleParticle p;
fp >> p.ID >> p.Pos[0] >> p.Pos[1]
>> p.Pos[2] >> p.Vel[2] >> p.Vel[1] >> p.Vel[0] >> tempData;
if (p.ID == -99 &&
p.Pos[0] == -99 && p.Pos[1] == -99 &&
p.Pos[2] == -99 && p.Vel[2] == -99)
break;
//p.Pos[0] = p.Pos[0]*rescale_position + shift;
//p.Pos[1] = p.Pos[1]*rescale_position + shift;
//p.Pos[2] = p.Pos[2]*rescale_position + shift;
//p.Vel[2] = p.Vel[2]*rescale_velocity;
// enforce box size in case of roundoff error
for (int k = 0; k < 3; k++) {
if (p.Pos[k] < 0) p.Pos[k] += simu->BoxSize;
if (p.Pos[k] >= simu->BoxSize) p.Pos[k] -= simu->BoxSize;
}
if (preproc != 0 && !preproc->accept(p))
continue;
copyParticleToSimu(p, simu, actualNumPart);
uniqueID[actualNumPart]= p.ID;
index[actualNumPart] = i;
actualNumPart++;
if (actualNumPart == allocated)
{
allocated += (estimated+9)/10;
reallocSimu(simu, allocated);
reallocArray(uniqueID, allocated, actualNumPart);
reallocArray(index, allocated, actualNumPart);
}
for (int k = 0; k < 3; k++) {
min_pos[k] = std::min(min_pos[k], p.Pos[k]);
max_pos[k] = std::max(max_pos[k], p.Pos[k]);
}
}
for (int k = 0; k < 3; k++) cout << boost::format("min[%d] = %g, max[%d] = %g") % k % min_pos[k] % k %max_pos[k] << endl;
applyTransformations(simu);
simu->NumPart = actualNumPart;
simu->TotalNumPart = actualNumPart;
simu->new_attribute("uniqueID", uniqueID, delete_adaptor<long>);
simu->new_attribute("index", index, delete_adaptor<long>);
return simu;
}
};
SimulationLoader *multidarkLoader(const string& multidarkname, SimulationPreprocessor *p)
{
SimuData *header;
int actualNumPart;
ifstream fp(multidarkname.c_str());
cout << "opening multidark file " << multidarkname << endl;
if (!fp)
{
cout << "could not open file!" << endl;
return 0;
}
header = new SimuData();
fp >> header->BoxSize >> header->Omega_M >> header->Hubble >> header->time >> header->NumPart;
header->time = 1./(1.+header->time); // convert to scale factor
header->TotalNumPart = header->NumPart;
header->Omega_Lambda = 1.0 - header->Omega_M;
return new MultiDarkLoader(multidarkname, header, p);
}