void generate_random_value(grnxx::GeoPoint *value) {
if ((rng() % 256) == 0) {
*value = grnxx::GeoPoint::na();
} else {
grnxx::Float latitude(-90.0 + (180.0 * rng() / rng.max()));
grnxx::Float longitude(-180.0 + (360.0 * rng() / rng.max()));
*value = grnxx::GeoPoint(latitude, longitude);
}
}
/**
* 初期化
* @todo:固定シードを与える
*/
inline void init() {
std::random_device rng;
std::array<uint32_t, 16> rng_seed;
std::generate(rng_seed.begin(), rng_seed.end(), std::ref(rng));
std::seed_seq rng_seed_seq(rng_seed.begin(), rng_seed.end());
mt.seed(rng_seed_seq);
}
void generate_random_value(grnxx::Float *value) {
if ((rng() % 256) == 0) {
*value = grnxx::Float::na();
} else {
*value = grnxx::Float(1.0 * rng() / rng.max());
}
}
GlobalBucket(const std::string& hostname, int16_t port, void (*killall)(void))
//: killall_(killall), joinLock_(false), joinMaster_(false) {
: killall_(killall), joinLock_(false), joinMaster_(false), debug_(std::cerr) {
me_.hostname = hostname;
me_.port = port;
randGen_.seed(std::chrono::system_clock::now().time_since_epoch().count());
pthread_mutex_init(&hostLock_, NULL);
}
void set_seed( uint64_t s ) {
gen.seed(s);
for(int i = 0; i < table_first_dim; ++i) {
for( uint64_t j = 0; j < table_second_dim; ++j) {
table[i][j] = (hash_type) gen();
}
}
}
namespace Random
{
std::mt19937_64 generator;
std::normal_distribution<double> normdist;
std::uniform_real_distribution<double> uniformDist;
void seed(int i)
{ generator.seed(i);
}
double uniform(double start, double end)
{ return start + (end-start)*uniformDist(generator);
}
double normal(double mean, double sigma, double cap)
{ double r = sigma*normdist(generator);
if(cap>0.0) while(fabs(r)>cap) r = sigma*normdist(generator); //regenerate till cap is satisfied
return mean + r;
}
complex normalComplex(double sigma)
{ return sigma * complex(normdist(generator), normdist(generator));
}
}
> size_t initialize(
Init_Cond& init_cond,
const double simulation_time,
const std::vector<uint64_t>& cells,
Grid& grid,
std::mt19937_64& random_source,
const double particle_temp_nrj_ratio,
const unsigned long long int first_particle_id,
const unsigned long long int particle_id_increase,
const bool replace,
const bool verbose
) {
if (verbose && grid.get_rank() == 0) {
std::cout << "Setting default particle state... ";
std::cout.flush();
}
size_t nr_particles_created = 0;
auto current_id_start = first_particle_id;
for (const auto cell_id: cells) {
random_source.seed(cell_id);
const auto
cell_start = grid.geometry.get_min(cell_id),
cell_end = grid.geometry.get_max(cell_id),
cell_length = grid.geometry.get_length(cell_id),
cell_center = grid.geometry.get_center(cell_id);
// classify cells for setting non-default initial state
init_cond.add_cell(
cell_id,
cell_start,
cell_end
);
auto* const cell_data = grid[cell_id];
if (cell_data == NULL) {
std::cerr << __FILE__ << "(" << __LINE__ << ") No data for cell: "
<< cell_id
<< std::endl;
abort();
}
// set default state
const auto
number_density
= init_cond.default_data.get_data(
Number_Density_T(),
cell_center,
simulation_time
),
temperature
= init_cond.default_data.get_data(
Temperature_T(),
cell_center,
simulation_time
),
charge_mass_ratio
= init_cond.default_data.get_data(
Charge_Mass_Ratio_T(),
cell_center,
simulation_time
),
species_mass
= init_cond.default_data.get_data(
Particle_Species_Mass_T(),
cell_center,
simulation_time
);
const auto bulk_velocity
= init_cond.default_data.get_data(
Bulk_Velocity_T(),
cell_center,
simulation_time
);
const auto nr_particles
= init_cond.default_data.get_data(
Nr_Particles_In_Cell_T(),
cell_center,
simulation_time
);
auto new_particles
= create_particles<
Particle,
Particle_Mass_T,
Particle_Charge_Mass_Ratio_T,
Particle_Position_T,
Particle_Velocity_T,
Particle_ID_T,
Particle_Species_Mass_T
>(
bulk_velocity,
Eigen::Vector3d{cell_start[0], cell_start[1], cell_start[2]},
Eigen::Vector3d{cell_end[0], cell_end[1], cell_end[2]},
Eigen::Vector3d{temperature, temperature, temperature},
nr_particles,
charge_mass_ratio,
species_mass * number_density * cell_length[0] * cell_length[1] * cell_length[2],
species_mass,
particle_temp_nrj_ratio,
random_source,
current_id_start,
particle_id_increase
);
nr_particles_created += nr_particles;
if (replace) {
(*cell_data)[Particles_T()] = std::move(new_particles);
} else {
(*cell_data)[Particles_T()].insert(
(*cell_data)[Particles_T()].end(),
new_particles.begin(),
new_particles.end()
);
}
current_id_start += nr_particles * particle_id_increase;
}
// set non-default initial conditions
if (verbose && grid.get_rank() == 0) {
std::cout << "done\nSetting non-default initial particle state... ";
std::cout.flush();
}
for (size_t bdy_id = 0; bdy_id < init_cond.get_number_of_boundaries(); bdy_id++) {
for (const auto& cell_id: init_cond.get_cells(bdy_id)) {
const auto
cell_start = grid.geometry.get_min(cell_id),
cell_end = grid.geometry.get_max(cell_id),
cell_length = grid.geometry.get_length(cell_id),
cell_center = grid.geometry.get_center(cell_id);
const auto
number_density
= init_cond.get_data(
Number_Density_T(),
bdy_id,
cell_center,
simulation_time
),
temperature
= init_cond.get_data(
Temperature_T(),
bdy_id,
cell_center,
simulation_time
),
charge_mass_ratio
= init_cond.get_data(
Charge_Mass_Ratio_T(),
bdy_id,
cell_center,
simulation_time
),
species_mass
= init_cond.get_data(
Particle_Species_Mass_T(),
bdy_id,
cell_center,
simulation_time
);
const auto bulk_velocity
= init_cond.get_data(
Bulk_Velocity_T(),
bdy_id,
cell_center,
simulation_time
);
const auto nr_particles
= init_cond.get_data(
Nr_Particles_In_Cell_T(),
bdy_id,
cell_center,
simulation_time
);
auto* const cell_data = grid[cell_id];
if (cell_data == NULL) {
std::cerr << __FILE__ << "(" << __LINE__ << ") No data for cell: "
<< cell_id
<< std::endl;
abort();
}
auto new_particles
= create_particles<
Particle,
Particle_Mass_T,
Particle_Charge_Mass_Ratio_T,
Particle_Position_T,
Particle_Velocity_T,
Particle_ID_T,
Particle_Species_Mass_T
>(
bulk_velocity,
Eigen::Vector3d{cell_start[0], cell_start[1], cell_start[2]},
Eigen::Vector3d{cell_end[0], cell_end[1], cell_end[2]},
Eigen::Vector3d{temperature, temperature, temperature},
nr_particles,
charge_mass_ratio,
species_mass * number_density * cell_length[0] * cell_length[1] * cell_length[2],
species_mass,
particle_temp_nrj_ratio,
random_source,
current_id_start,
particle_id_increase
);
nr_particles_created += nr_particles;
if (replace) {
(*cell_data)[Particles_T()] = std::move(new_particles);
} else {
(*cell_data)[Particles_T()].insert(
(*cell_data)[Particles_T()].end(),
new_particles.begin(),
new_particles.end()
);
}
current_id_start += nr_particles * particle_id_increase;
}
}
if (verbose && grid.get_rank() == 0) {
std::cout << "done" << std::endl;
}
return nr_particles_created;
}
/**@brief Generator a random nuber between 0 and 1 in the range [0,1)
*
* @return a double in [0,1)
*/
double unifRand() {
return mtGen_() / (static_cast<double>(mtGen_.max()) + 1);
}
/**@brief seed mtGen_ with the given seed
*
* @param givenSeed
*/
void seedNum(uint64_t givenSeed) {
currentSeed_ = givenSeed;
mtGen_.seed(givenSeed);
}
void init_random() {
uint64_t timeSeed = std::chrono::high_resolution_clock::now().time_since_epoch().count();
std::seed_seq ss = {uint32_t(timeSeed & 0xffffffff), uint32_t(timeSeed>>32)};
rng.seed(ss);
}
void seed(int i)
{ generator.seed(i);
}
void test_scored_subexpression() {
// Create a database with the default options.
auto db = grnxx::open_db("");
// Create a table with the default options.
auto table = db->create_table("Table");
constexpr size_t NUM_ROWS = 1 << 16;
// Generate random values.
grnxx::Array<grnxx::Float> float_values;
grnxx::Array<grnxx::Int> ref_values;
float_values.resize(NUM_ROWS);
ref_values.resize(NUM_ROWS);
for (size_t i = 0; i < NUM_ROWS; ++i) {
float_values[i] = grnxx::Float(1.0 * rng() / rng.max());
// ref_values[i] = mersenne_twister() % NUM_ROWS;
ref_values[i] = grnxx::Int(0);
}
// Create columns for Float and Int values.
auto float_column = table->create_column("Float", GRNXX_FLOAT);
grnxx::ColumnOptions options;
options.reference_table_name = "Table";
auto ref_column = table->create_column("Ref", GRNXX_INT, options);
// Store generated values into columns.
for (size_t i = 0; i < NUM_ROWS; ++i) {
grnxx::Int row_id = table->insert_row();
assert(row_id.match(grnxx::Int(i)));
float_column->set(row_id, float_values[i]);
}
for (size_t i = 0; i < NUM_ROWS; ++i) {
ref_column->set(grnxx::Int(i), ref_values[i]);
}
// Generate a list of records.
grnxx::Array<grnxx::Record> records;
auto cursor = table->create_cursor();
assert(cursor->read_all(&records) == table->num_rows());
// Set scores (Float).
auto builder = grnxx::ExpressionBuilder::create(table);
builder->push_column("Float");
auto expression = builder->release();
expression->adjust(&records);
// Test an expression (Ref.(_score > 0.5)).
builder->push_column("Ref");
builder->begin_subexpression();
builder->push_score();
builder->push_constant(grnxx::Float(0.5));
builder->push_operator(GRNXX_GREATER);
builder->end_subexpression();
expression = builder->release();
expression->filter(&records);
size_t count = 0;
for (size_t i = 0; i < NUM_ROWS; ++i) {
if (float_values[i].raw() > 0.5) {
assert(records[count].row_id.match(grnxx::Int(i)));
++count;
}
}
assert(records.size() == count);
}
unsigned long myrand_init(unsigned long s)
{
standard.seed(s);
return s;
}
// This is equivalent to srand().
static void seed(uint64_t new_seed = std::mt19937_64::default_seed) {
rng.seed(new_seed);
}
