bool raycast(game* g, vec2 from, vec2 to) {
ivec2 cur(fast_floor(from.x), fast_floor(from.y));
ivec2 end(fast_floor(to.x), fast_floor(to.y));
ivec2 sign(sign(to.x - from.x), sign(to.y - from.y));
vec2 abs_delta(abs(to.x - from.x), abs(to.y - from.y));
vec2 delta_t(vec2(1.0f) / abs_delta);
vec2 lb(to_vec2(cur));
vec2 ub(lb + vec2(1.0f));
vec2 t(vec2((from.x > to.x) ? (from.x - lb.x) : (ub.x - from.x), (from.y > to.y) ? (from.y - lb.y) : (ub.y - from.y)) / abs_delta);
for(;;) {
if (g->is_raycast_solid(cur.x, cur.y))
return true;
if (t.x <= t.y) {
if (cur.x == end.x) break;
t.x += delta_t.x;
cur.x += sign.x;
}
else {
if (cur.y == end.y) break;
t.y += delta_t.y;
cur.y += sign.y;
}
}
return false;
}
void euler_cromer(const data* dat, output_function output)
{
int i;
double dt = dat->eta * delta_t_factor;
vector *a = (vector*) malloc((dat->N)*sizeof(vector)),
*a_1 = (vector*) malloc((dat->N)*sizeof(vector)),
*r = init_r(dat),
*v = init_v(dat);
double time = 0;
output(time, dt, dat, r, v);
while (time < dat->t_max)
{
accelerations(dat, r, a);
adots(dat, r, v, a_1);
for (i = 0; i < dat->N; i++)
{
vector v_neu = vector_add(v[i], scalar_mult(dt, a[i])),
r_neu = vector_add(r[i], scalar_mult(0.5 * dt, vector_add(v[i], v_neu)));
r[i] = r_neu;
v[i] = v_neu;
}
dt = delta_t(dat, a, a_1);
time += dt;
output(time, dt, dat, r, v);
}
free(a); free(r); free(v);
}
void *delay_test(void *threadID)
{
int i;
unsigned int max_sleep_calls=3;
int flags = 0;
struct timespec rtclk_resolution;
sleep_count = 0;
if(clock_getres(CLOCK_REALTIME, &rtclk_resolution) == ERROR)
{
perror("clock_getres");
exit(-1);
}
else
{
printf("\n\nPOSIX Clock demo using system RT clock with resolution:\n\t%ld secs, %ld microsecs, %ld nanosecs\n", rtclk_resolution.tv_sec, (rtclk_resolution.tv_nsec/1000), rtclk_resolution.tv_nsec);
}
/* run test for 3 seconds */
sleep_time.tv_sec=3;
sleep_time.tv_nsec=0;
sleep_requested.tv_sec=sleep_time.tv_sec;
sleep_requested.tv_nsec=sleep_time.tv_nsec;
/* start time stamp */
clock_gettime(CLOCK_REALTIME, &rtclk_start_time);
/* request sleep time and repeat if time remains */
do
{
nanosleep(&sleep_time, &remaining_time);
sleep_time.tv_sec = remaining_time.tv_sec;
sleep_time.tv_nsec = remaining_time.tv_nsec;
sleep_count++;
}
while (((remaining_time.tv_sec > 0) || (remaining_time.tv_nsec > 0)) && (sleep_count < max_sleep_calls));
clock_gettime(CLOCK_REALTIME, &rtclk_stop_time);
delta_t(&rtclk_stop_time, &rtclk_start_time, &rtclk_dt);
delta_t(&rtclk_dt, &sleep_requested, &delay_error);
end_delay_test();
}
void Packet_Generator::handle_next(Packet*)
{
if (keep_running) {
output(new Packet(8*packet_size), delta_t());
id++;
if (max_packets && id >= max_packets)
start(false);
}
}
void OvrScrollManager::TouchRelative( Vector3f touchPos )
{
if ( !TouchIsDown )
{
return;
}
// Check if the touch is valid for this( horizontal / vertical ) scrolling type
bool isValid = false;
if( fabsf( LastTouchPosistion.x - touchPos.x ) > fabsf( LastTouchPosistion.y - touchPos.y ) )
{
if( CurrentScrollType == HORIZONTAL_SCROLL )
{
isValid = true;
}
}
else
{
if( CurrentScrollType == VERTICAL_SCROLL )
{
isValid = true;
}
}
if( isValid )
{
float touchVal;
float lastTouchVal;
float curMove;
if( CurrentScrollType == HORIZONTAL_SCROLL )
{
touchVal = touchPos.x;
lastTouchVal = LastTouchPosistion.x;
curMove = lastTouchVal - touchVal;
}
else
{
touchVal = touchPos.y;
lastTouchVal = LastTouchPosistion.y;
curMove = touchVal - lastTouchVal;
}
float const DISTANCE_SCALE = ScrollBehavior.DistanceScale;
Position += curMove * DISTANCE_SCALE;
float const DISTANCE_RAMP = 150.0f;
float const ramp = fabsf( touchVal ) / DISTANCE_RAMP;
Deltas.Append( delta_t( curMove * DISTANCE_SCALE * ramp, vrapi_GetTimeInSeconds() ) );
}
LastTouchPosistion = touchPos;
}
void leap_frog(const data* dat, output_function output)
{
int i;
double dt = dat->eta * delta_t_factor;
vector *a = (vector*) malloc((dat->N)*sizeof(vector)),
*a_1 = (vector*) malloc((dat->N)*sizeof(vector)),
*r_p = (vector*) malloc((dat->N)*sizeof(vector)), // r_(n+1/2), not initialized
*r = init_r(dat), // r_(n+1)
*r_n = (vector*) malloc((dat->N)*sizeof(vector)), // r_(n+3/2), not initialized
*v = init_v(dat); // v_(n+1)
double time = 0;
output(time, dt, dat, r, v);
// initial step
for (i = 0; i < dat->N; i++)
// set r_(1/2)
r_n[i] = vector_add(r[i], scalar_mult(0.5 * dt, v[i]));
// regular timesteps
while (time < dat->t_max)
{
// a_(n+1/2)
accelerations(dat, r_n, a);
adots(dat, r_n, v, a_1);
for (i = 0; i < dat->N; i++)
{
// store previous values as r_(n+1/2)
r_p[i] = r_n[i];
// v_(n+1)
vector_add_to(&v[i], scalar_mult(dt, a[i]));
// r_(n+3/2)
vector_add_to(&r_n[i], scalar_mult(dt, v[i]));
// build r_(n+1)
r[i] = scalar_mult(0.5, vector_add(r_p[i], r_n[i]));
}
dt = delta_t(dat, a, a_1);
time += dt;
output(time, dt, dat, r, v);
}
free(a); free(r_p); free(r); free(r_n); free(v);
}
/*NP*/
void write_file2( char *filename )
/*************************************************************/
/* WRITE_FILE */
/* John Hart NSSFC KCMO */
/* */
/* Writes contents of sndg array into SHARP95 file. */
/*************************************************************/
{
short i, j;
short idx[7];
float sfctemp, sfcdwpt, sfcpres, j1, j2, ix1;
struct _parcel pcl;
char st[80];
FILE *fout;
idx[1] = getParmIndex("PRES");
idx[2] = getParmIndex("HGHT");
idx[3] = getParmIndex("TEMP");
idx[4] = getParmIndex("DWPT");
idx[5] = getParmIndex("DRCT");
idx[6] = getParmIndex("SPED");
fout = fopen( filename, "wt" );
if (fout==NULL)
{
printf("Unable to write output file!\n" );
return;
}
fputs( "%TITLE%\n", fout );
fputs( raobtitle, fout );
fputs( "\n\n", fout );
fprintf( fout, " LEVEL HGHT TEMP DWPT WDIR WSPD\n");
fprintf( fout, "-------------------------------------------------------------------\n");
fputs( "%RAW%\n", fout );
for(i=0; i<numlvl; i++)
{
for(j=1; j<=5; j++) fprintf( fout, "%8.2f, ", sndg[i][idx[j]]);
fprintf( fout, "%8.2f\n", sndg[i][idx[6]]);
}
fputs( "%END%\n\n", fout );
if ((numlvl<4) || (!qc(i_dwpt(700, I_PRES)))) return;
fprintf( fout, "----- Parcel Information-----\n");
/* ----- Calculate Parcel Data ----- */
sfctemp = lplvals.temp;
sfcdwpt = lplvals.dwpt;
sfcpres = lplvals.pres;
strcpy( st, "*** " );
strcat( st, lplvals.desc );
strcat( st, " ***" );
fprintf( fout, "%s\n", st);
ix1 = parcel( -1, -1, sfcpres, sfctemp, sfcdwpt, &pcl);
fprintf( fout, "LPL: P=%.0f T=%.0fF Td=%.0fF\n", sfcpres, ctof(sfctemp), ctof(sfcdwpt));
fprintf( fout, "CAPE: %6.0f J/kg\n", pcl.bplus);
fprintf( fout, "CINH: %6.0f J/kg\n", pcl.bminus);
fprintf( fout, "LI: %6.0f C\n", pcl.li5);
fprintf( fout, "LI(300mb): %6.0f C\n", pcl.li3);
fprintf( fout, "3km Cape: %6.0f J/kg\n", pcl.cape3km);
j1 = pcl.bplus;
j2 = i_hght(pcl.elpres, I_PRES) - i_hght(pcl.lfcpres, I_PRES);
fprintf( fout, "NCAPE: %6.2f m/s2\n\n", j1/j2);
fprintf( fout, "LCL: %6.0fmb %6.0fm\n", pcl.lclpres, agl(i_hght(pcl.lclpres, I_PRES)));
fprintf( fout, "LFC: %6.0fmb %6.0fm\n", pcl.lfcpres, agl(i_hght(pcl.lfcpres, I_PRES)));
fprintf( fout, "EL: %6.0fmb %6.0fm\n", pcl.elpres, agl(i_hght(pcl.elpres, I_PRES)));
fprintf( fout, "MPL: %6.0fmb %6.0fm\n", pcl.mplpres, agl(i_hght(pcl.mplpres, I_PRES)));
fprintf( fout, "All heights AGL\n\n" );
fprintf( fout, "----- Moisture -----\n" );
strcpy( st, qc2( precip_water( &ix1, -1, -1), " in", 2 ));
fprintf( fout, "Precip Water: %s\n", st);
strcpy( st, qc2( mean_mixratio( &ix1, -1, -1 ), " g/Kg", 1 ));
fprintf( fout, "Mean W: %s\n\n", st);
fprintf( fout, "----- Lapse Rates -----\n" );
j1 = delta_t(&ix1);
j2 = lapse_rate( &ix1, 700, 500);
fprintf( fout, "700-500mb %.0f C %.1f C/km\n", j1, j2);
j1 = vert_tot(&ix1);
j2 = lapse_rate( &ix1, 850, 500);
fprintf( fout, "850-500mb %.0f C %.1f C/km\n", j1, j2);
fclose( fout );
}
bool
MAST::StructuralElement2D::thermal_residual (bool request_jacobian,
RealVectorX& f,
RealMatrixX& jac,
MAST::BoundaryConditionBase& bc)
{
FEMOperatorMatrix Bmat_mem, Bmat_bend, Bmat_vk;
const std::vector<Real>& JxW = _fe->get_JxW();
const std::vector<libMesh::Point>& xyz = _fe->get_xyz();
const unsigned int n_phi = (unsigned int)_fe->get_phi().size();
const unsigned int n1= this->n_direct_strain_components(), n2=6*n_phi,
n3 = this->n_von_karman_strain_components();
RealMatrixX
material_exp_A_mat,
material_exp_B_mat,
mat1_n1n2 = RealMatrixX::Zero(n1,n2),
mat2_n2n2 = RealMatrixX::Zero(n2,n2),
mat3,
mat4_n3n2 = RealMatrixX::Zero(n3,n2),
vk_dwdxi_mat = RealMatrixX::Zero(n1,n3),
stress = RealMatrixX::Zero(2,2),
local_jac = RealMatrixX::Zero(n2,n2);
RealVectorX
vec1_n1 = RealVectorX::Zero(n1),
vec2_n1 = RealVectorX::Zero(n1),
vec3_n2 = RealVectorX::Zero(n2),
vec4_2 = RealVectorX::Zero(2),
vec5_n3 = RealVectorX::Zero(n3),
local_f = RealVectorX::Zero(n2),
delta_t = RealVectorX::Zero(1);
local_f.setZero();
local_jac.setZero();
Bmat_mem.reinit(n1, _system.n_vars(), n_phi); // three stress-strain components
Bmat_bend.reinit(n1, _system.n_vars(), n_phi);
Bmat_vk.reinit(n3, _system.n_vars(), n_phi); // only dw/dx and dw/dy
bool if_vk = (_property.strain_type() == MAST::VON_KARMAN_STRAIN),
if_bending = (_property.bending_model(_elem, _fe->get_fe_type()) != MAST::NO_BENDING);
std::auto_ptr<MAST::FieldFunction<RealMatrixX > >
expansion_A = _property.thermal_expansion_A_matrix(*this),
expansion_B = _property.thermal_expansion_B_matrix(*this);
const MAST::FieldFunction<Real>
&temp_func = bc.get<MAST::FieldFunction<Real> >("temperature"),
&ref_temp_func = bc.get<MAST::FieldFunction<Real> >("ref_temperature");
Real t, t0;
libMesh::Point pt;
for (unsigned int qp=0; qp<JxW.size(); qp++) {
this->local_elem().global_coordinates_location(xyz[qp], pt);
// this is moved inside the domain since
(*expansion_A)(pt, _time, material_exp_A_mat);
(*expansion_B)(pt, _time, material_exp_B_mat);
// get the temperature function
temp_func(pt, _time, t);
ref_temp_func(pt, _time, t0);
delta_t(0) = t-t0;
vec1_n1 = material_exp_A_mat * delta_t; // [C]{alpha (T - T0)} (with membrane strain)
vec2_n1 = material_exp_B_mat * delta_t; // [C]{alpha (T - T0)} (with bending strain)
stress(0,0) = vec1_n1(0); // sigma_xx
stress(0,1) = vec1_n1(2); // sigma_xy
stress(1,0) = vec1_n1(2); // sigma_yx
stress(1,1) = vec1_n1(1); // sigma_yy
this->initialize_direct_strain_operator(qp, Bmat_mem);
// membrane strain
Bmat_mem.vector_mult_transpose(vec3_n2, vec1_n1);
local_f += JxW[qp] * vec3_n2;
if (if_bending) {
// bending strain
_bending_operator->initialize_bending_strain_operator(qp, Bmat_bend);
Bmat_bend.vector_mult_transpose(vec3_n2, vec2_n1);
local_f += JxW[qp] * vec3_n2;
// von Karman strain
if (if_vk) {
// get the vonKarman strain operator if needed
this->initialize_von_karman_strain_operator(qp,
vec2_n1, // epsilon_vk
vk_dwdxi_mat,
Bmat_vk);
// von Karman strain
vec4_2 = vk_dwdxi_mat.transpose() * vec1_n1;
Bmat_vk.vector_mult_transpose(vec3_n2, vec4_2);
local_f += JxW[qp] * vec3_n2;
}
if (request_jacobian && if_vk) { // Jacobian only for vk strain
// vk - vk
mat3 = RealMatrixX::Zero(2, n2);
Bmat_vk.left_multiply(mat3, stress);
Bmat_vk.right_multiply_transpose(mat2_n2n2, mat3);
local_jac += JxW[qp] * mat2_n2n2;
}
}
}
// now transform to the global coorodinate system
transform_vector_to_global_system(local_f, vec3_n2);
f -= vec3_n2;
if (request_jacobian && if_vk) {
transform_matrix_to_global_system(local_jac, mat2_n2n2);
jac -= mat2_n2n2;
}
// Jacobian contribution from von Karman strain
return request_jacobian && if_vk;
}
void runge_kutta(const data* dat, output_function output)
{
int i;
double dt = dat->eta * delta_t_factor;
vector *r = init_r(dat),
*v = init_v(dat),
*a = (vector*) malloc((dat->N)*sizeof(vector)),
*a_1 = (vector*) malloc((dat->N)*sizeof(vector));
// temporary r vector for acceleration calculations
vector *rt = (vector*) malloc((dat->N)*sizeof(vector));
vector *a1 = (vector*) malloc((dat->N)*sizeof(vector)),
*a2 = (vector*) malloc((dat->N)*sizeof(vector)),
*a3 = (vector*) malloc((dat->N)*sizeof(vector)),
*a4 = (vector*) malloc((dat->N)*sizeof(vector));
vector *r1 = (vector*) malloc((dat->N)*sizeof(vector)),
*r2 = (vector*) malloc((dat->N)*sizeof(vector)),
*r3 = (vector*) malloc((dat->N)*sizeof(vector)),
*r4 = (vector*) malloc((dat->N)*sizeof(vector));
vector *v1 = (vector*) malloc((dat->N)*sizeof(vector)),
*v2 = (vector*) malloc((dat->N)*sizeof(vector)),
*v3 = (vector*) malloc((dat->N)*sizeof(vector)),
*v4 = (vector*) malloc((dat->N)*sizeof(vector));
double time = 0;
while (time < dat->t_max)
{
accelerations(dat, r, a1);
for (i = 0; i < dat->N; i++)
{
v1[i] = scalar_mult(dt, a1[i]);
r1[i] = scalar_mult(dt, v[i]);
// temp r for a2
rt[i] = vector_add(r[i], scalar_mult(0.5, r1[i]));
}
accelerations(dat, rt, a2);
for (i = 0; i < dat->N; i++)
{
v2[i] = scalar_mult(dt, a2[i]);
r2[i] = scalar_mult(dt, vector_add(v[i], scalar_mult(0.5, v1[i])));
// temp r for a3
rt[i] = vector_add(r[i], scalar_mult(0.5, r2[i]));
}
accelerations(dat, rt, a3);
for (i = 0; i < dat->N; i++)
{
v3[i] = scalar_mult(dt, a3[i]);
r3[i] = scalar_mult(dt, vector_add(v[i], scalar_mult(0.5, v2[i])));
// temp r for a3
rt[i] = vector_add(r[i], scalar_mult(0.5, r3[i]));
}
accelerations(dat, rt, a4);
for (i = 0; i < dat->N; i++)
{
v4[i] = scalar_mult(dt, a4[i]);
r4[i] = scalar_mult(dt, vector_add(v[i], v3[i]));
// calculate v_(n+1) and r_(n+1)
vector_add_to(&v[i], vector_add(scalar_mult(1.0/6.0, v1[i]),
vector_add(scalar_mult(1.0/3.0, v2[i]),
vector_add(scalar_mult(1.0/3.0, v3[i]),
scalar_mult(1.0/6.0, v4[i])))));
vector_add_to(&r[i], vector_add(scalar_mult(1.0/6.0, r1[i]),
vector_add(scalar_mult(1.0/3.0, r2[i]),
vector_add(scalar_mult(1.0/3.0, r3[i]),
scalar_mult(1.0/6.0, r4[i])))));
}
// increase time
adots(dat, r, v, a_1);
dt = delta_t(dat, a1, a_1); // a1 = a(t_n), a_1 = a'(t_n)
time += dt;
output(time, dt, dat, r, v);
}
free(r); free(v); free(a); free(a_1);
free(rt);
free(r1); free(r2); free(r3); free(r4);
free(v1); free(v2); free(v3); free(v4);
free(a1); free(a2); free(a3); free(a4);
}
void hermite_iterated(const data* dat, output_function output, int iterations)
{
int i,j;
double dt = dat->eta * delta_t_factor;
vector *a = (vector*) malloc((dat->N)*sizeof(vector)), // a_n, not initialized
*a_p = (vector*) malloc((dat->N)*sizeof(vector)), // a_(n+1)^p, not initialized
*a_1 = (vector*) malloc((dat->N)*sizeof(vector)), // a_1_n, not initialized
*a_1_p = (vector*) malloc((dat->N)*sizeof(vector)), // a_1_(n+1)^p, not initialized
*r = init_r(dat), // r_n
*r_p = (vector*) malloc((dat->N)*sizeof(vector)), // r_(n+1)^p, not initialized
*v = init_v(dat), // v_n
*v_p = (vector*) malloc((dat->N)*sizeof(vector)); // v_(n+1)^p, not initialized
double time = 0;
accelerations(dat, r, a);
adots(dat, r, v, a_1);
dt = delta_t(dat, a, a_1);
output(time, dt, dat, r, v);
while (time < dat->t_max)
{
// prediction step
for (i = 0; i < dat->N; i++)
{
v_p[i] = vector_add(v[i],
vector_add(scalar_mult(dt, a[i]),
scalar_mult(0.5 * dt * dt, a_1[i])));
r_p[i] = vector_add(r[i],
vector_add(scalar_mult(dt, v[i]),
vector_add(scalar_mult(0.5 * dt * dt, a[i]),
scalar_mult(dt * dt * dt / 6.0, a_1[i]))));
}
// iteration of correction step
for (j = 0; j < iterations; j++)
{
// predict a, a_1
accelerations(dat, r_p, a_p);
adots(dat, r_p, v_p, a_1_p);
for (i = 0; i < dat->N; i++)
{
// correction steps -> overwrite "prediction" variables for convenience,
// will get written in r,v after iteration is done
v_p[i] = vector_add(v[i],
vector_add(scalar_mult(dt / 2.0, vector_add(a_p[i], a[i])),
scalar_mult(dt * dt / 12.0, vector_diff(a_1_p[i], a_1[i]))));
r_p[i] = vector_add(r[i],
vector_add(scalar_mult(dt / 2.0, vector_add(v_p[i], v[i])),
scalar_mult(dt * dt / 12.0, vector_diff(a_p[i], a[i]))));
}
}
// apply iterated correction steps
for (i = 0; i < dat->N; i++)
{
r[i] = r_p[i];
v[i] = v_p[i];
}
time += dt;
// a/a_1 values for next step
accelerations(dat, r, a);
adots(dat, r, v, a_1);
// new dt
dt = delta_t(dat, a, a_1);
output(time, dt, dat, r, v);
}
free(a); free(a_p);
free(a_1); free(a_1_p);
free(r); free(r_p);
free(v); free(v_p);
}
void hermite(const data* dat, output_function output)
{
int i;
double dt = dat->eta * delta_t_factor;
vector *a = (vector*) malloc((dat->N)*sizeof(vector)), // a_n, not initialized
*a_p = (vector*) malloc((dat->N)*sizeof(vector)), // a_(n+1)^p, not initialized
*a_1 = (vector*) malloc((dat->N)*sizeof(vector)), // a_1_n, not initialized
*a_1_p = (vector*) malloc((dat->N)*sizeof(vector)), // a_1_(n+1)^p, not initialized
*a_2 = (vector*) malloc((dat->N)*sizeof(vector)), // a_(n+1)^(2), not initialized
*a_3 = (vector*) malloc((dat->N)*sizeof(vector)), // a_(n+1)^(3), not initialized
*r = init_r(dat), // r_n
*r_p = (vector*) malloc((dat->N)*sizeof(vector)), // r_(n+1)^p, not initialized
*v = init_v(dat), // v_n
*v_p = (vector*) malloc((dat->N)*sizeof(vector)); // v_(n+1)^p, not initialized
double time = 0;
accelerations(dat, r, a);
adots(dat, r, v, a_1);
dt = delta_t(dat, a, a_1);
output(time, dt, dat, r, v);
while (time < dat->t_max)
{
// prediction step
for (i = 0; i < dat->N; i++)
{
v_p[i] = vector_add(v[i],
vector_add(scalar_mult(dt, a[i]),
scalar_mult(0.5 * dt * dt, a_1[i])));
r_p[i] = vector_add(r[i],
vector_add(scalar_mult(dt, v[i]),
vector_add(scalar_mult(0.5 * dt * dt, a[i]),
scalar_mult(dt * dt * dt / 6.0, a_1[i]))));
}
// predict a^p, a_1^p
accelerations(dat, r_p, a_p);
adots(dat, r_p, v_p, a_1_p);
for (i = 0; i < dat->N; i++)
{
// predict 2nd and 3rd derivations
a_2[i] = vector_add(scalar_mult(2 * (-3) / dt / dt, vector_diff(a[i], a_p[i])),
scalar_mult(2 * (-1) / dt, vector_add(scalar_mult(2, a_1[i]), a_1_p[i])));
a_3[i] = vector_add(scalar_mult(6 * 2 / dt / dt / dt, vector_diff(a[i], a_p[i])),
scalar_mult(6 / dt / dt, vector_add(a_1[i], a_1_p[i])));
// correction steps
v[i] = vector_add(v_p[i],
vector_add(scalar_mult(dt * dt * dt / 6.0, a_2[i]),
scalar_mult(dt * dt * dt / 24.0, a_3[i])));
r[i] = vector_add(r_p[i],
vector_add(scalar_mult(dt * dt * dt * dt / 24.0, a_2[i]),
scalar_mult(dt * dt * dt * dt * dt / 120.0, a_3[i])));
}
time += dt;
// a/a_1 values for next step
accelerations(dat, r, a);
adots(dat, r, v, a_1);
// new dt
dt = delta_t_(dat, a, a_1, a_2, a_3);
output(time, dt, dat, r, v);
}
free(a); free(a_p);
free(a_1); free(a_1_p);
free(r); free(r_p);
free(v); free(v_p);
}
int main(int argc, char **argv) {
struct LGalaxy *lgal;
float write_buff;
FILE *fp,*sp;
float *sfr_float;
double *Sfr;
int cubep3m_p = 1728;
float boxsize = 47.0;
int grid = 306;
float gridsize = boxsize/grid;
int cubep3m_cell = cubep3m_p*2;
long long cell;
int firstfile = 0;
int lastfile = 127;
char basename[2000];
char outputfolder[2000];
char zlistfile[2000];
char outputname[2048];
char zlist_string[100][1024];
char filename[2048];
char buff[1000];
int nTrees,nGals;
int dummy,*dummyarray;
int i,j,k;
int nSnaps,selected_snap;
double gridmass;
double total_cell,total_p;
const float Mpc2m = 3.08567758e22;
float m2Mpc = 1./Mpc2m;
const float Msun2kg = 1.98855e30;
float kg2Msun = 1./Msun2kg;
const float year2sec = 3600.*24*365.25;
const float m2km = 0.001;
const float omegam = 0.27;
float G = 6.674e-11; // SI
float h = 0.7;
float H0 = 100.0; // km/s / (Mpc/h)
float pi = 4.0*atan(1.0);
double rho_crit_0;
double gridmass_c; //to convert msun to gridmass
double dt,z1,z2;
if(argc == 6) {
sscanf(argv[1],"%d",&selected_snap);
sscanf(argv[2],"%s",basename);
sscanf(argv[3],"%s",outputfolder);
sscanf(argv[4],"%s",zlistfile);
sscanf(argv[5],"%d",&grid);
}
else {
printf("./gen_source <snap> <basename> <output> <zlist> <ngrid>\nExit\n");
exit(1);
}
printf("argc = %d , argv[0] = %s, argv[1] = %s\n",argc,argv[0],argv[1]);
sprintf(buff,"mkdir -p %s",outputfolder);
system(buff);
G = G*(m2km*m2km) * (m2Mpc) / (kg2Msun); // (Mpc/h) (km/s)^2 / (Msun/h)
rho_crit_0 = 3.* (H0*H0)/ (8.*pi*G); // # (Msun/h)/(Mpc/h)^3
printf("rho_crit_0 = %g\n",rho_crit_0);
total_p = (double)cubep3m_p* (double)cubep3m_p* (double)cubep3m_p;
total_cell = (double)cubep3m_cell*(double)cubep3m_cell*(double)cubep3m_cell;
printf("total cell = %g\n",total_cell);
gridmass = (double)omegam*(double)rho_crit_0*(double)(boxsize*boxsize*boxsize)/total_cell; // /(double)h; // Msun/h
printf("G = %g, gridmass = %lf\n",G,gridmass);
gridmass_c = 1./gridmass;
printf("gridmass_c = %lg\n",gridmass_c);
fp = fopen(zlistfile,"r");
i=0;
while (fscanf(fp, "%s", zlist_string[i]) != EOF) {
i++;
}
nSnaps = i;
fclose(fp);
printf("Total snapshot : %d\n",nSnaps);
for(j=0;j<nSnaps;j++) {
if(j == selected_snap) {
printf("Converting snapshot : %d\n",selected_snap);
Sfr = calloc(grid*grid*grid,sizeof(double));
if(j > 0) {
sscanf(zlist_string[j],"%lg",&z1);
sscanf(zlist_string[j-1],"%lg",&z2);
dt = delta_t((float)z2,(float)z1,(float)omegam, H0, h);
} else
dt = 0.;
dt *= (Mpc2m/h/1000.); // s
for (i=firstfile;i<=lastfile;i++) {
sprintf(filename, "%s%s_%d",basename,zlist_string[j],i);
if(i == firstfile || i == lastfile)
printf("Reading %s\n.....\n",filename);
fp = fopen(filename,"rb");
fread(&nTrees, sizeof(int), 1, fp);
fread(&nGals, sizeof(int),1, fp);
lgal = malloc(sizeof(struct LGalaxy)*nGals);
fseek(fp, nTrees*sizeof(int), SEEK_CUR); // skip nGalsperTree
fread(lgal,sizeof(struct LGalaxy),nGals,fp);
for(k=0;k<nGals;k++) {
cell = (int)(lgal[k].Pos[0]/gridsize) + (int)(lgal[k].Pos[1]/gridsize)*grid + (int)(lgal[k].Pos[2]/gridsize)*grid*grid;
Sfr[cell] += (double)(lgal[k].HaloM_Crit200*1.e10*gridmass_c);
}
free(lgal);
fclose(fp);
}
sprintf(outputname,"%s/%s.dat",outputfolder,zlist_string[j]);
printf("output to file: %s\n",outputname);
fp = fopen(outputname,"wb+");
fwrite(&grid,sizeof(int),1,fp);
fwrite(&grid,sizeof(int),1,fp);
fwrite(&grid,sizeof(int),1,fp);
for(i=0;i<grid*grid*grid;i++) {
write_buff = (float)Sfr[i];
fwrite(&write_buff,sizeof(float),1,fp);
}
fclose(fp);
printf("Finish converting snap :%d\n",selected_snap);
free(Sfr);
}
}
return 0;
}
