/* initialise RPacket */
static void init_rpacket(rpacket_t *rp){
double MU = 0.3;
double R = 7.5e14;
double ENERGY = 0.9;
int NEXT_LINE_ID = 1;
double NU = 0.4;
double NU_LINE = 0.2;
int CURRENT_SHELL_ID = 0;
double TAU_EVENT = 2.9e13;
rpacket_set_current_shell_id(rp, CURRENT_SHELL_ID);
rpacket_set_next_shell_id(rp, CURRENT_SHELL_ID+1);
rpacket_set_mu(rp, MU);
rpacket_set_nu(rp, NU);
rpacket_set_r(rp, R);
rpacket_set_last_line(rp, false);
rpacket_set_recently_crossed_boundary(rp, 1);
rpacket_set_close_line(rp, false);
rpacket_set_nu_line(rp, NU_LINE);
rpacket_set_next_line_id(rp, NEXT_LINE_ID);
rpacket_set_tau_event(rp, TAU_EVENT);
rpacket_set_virtual_packet(rp, 0);
rpacket_set_energy(rp, ENERGY);
rpacket_set_virtual_packet_flag(rp, true);
rpacket_set_status(rp, TARDIS_PACKET_STATUS_IN_PROCESS);
rpacket_set_id(rp, 0);
rpacket_set_current_continuum_id(rp, 1);
}
void
move_packet_across_shell_boundary (rpacket_t * packet,
storage_model_t * storage, double distance, rk_state *mt_state)
{
move_packet (packet, storage, distance);
if (rpacket_get_virtual_packet (packet) > 0)
{
double delta_tau_event = rpacket_get_chi_continuum(packet) * distance;
rpacket_set_tau_event (packet,
rpacket_get_tau_event (packet) +
delta_tau_event);
}
else
{
rpacket_reset_tau_event (packet, mt_state);
}
if ((rpacket_get_current_shell_id (packet) < storage->no_of_shells - 1
&& rpacket_get_next_shell_id (packet) == 1)
|| (rpacket_get_current_shell_id (packet) > 0
&& rpacket_get_next_shell_id (packet) == -1))
{
rpacket_set_current_shell_id (packet,
rpacket_get_current_shell_id (packet) +
rpacket_get_next_shell_id (packet));
}
else if (rpacket_get_next_shell_id (packet) == 1)
{
rpacket_set_status (packet, TARDIS_PACKET_STATUS_EMITTED);
}
else if ((storage->reflective_inner_boundary == 0) ||
(rk_double (mt_state) > storage->inner_boundary_albedo))
{
rpacket_set_status (packet, TARDIS_PACKET_STATUS_REABSORBED);
}
else
{
double doppler_factor = rpacket_doppler_factor (packet, storage);
double comov_nu = rpacket_get_nu (packet) * doppler_factor;
double comov_energy = rpacket_get_energy (packet) * doppler_factor;
rpacket_set_mu (packet, rk_double (mt_state));
double inverse_doppler_factor = 1.0 / rpacket_doppler_factor (packet, storage);
rpacket_set_nu (packet, comov_nu * inverse_doppler_factor);
rpacket_set_energy (packet, comov_energy * inverse_doppler_factor);
if (rpacket_get_virtual_packet_flag (packet) > 0)
{
montecarlo_one_packet (storage, packet, -2, mt_state);
}
}
}
tardis_error_t
rpacket_init (rpacket_t * packet, storage_model_t * storage, int packet_index,
int virtual_packet_flag, double * chi_bf_tmp_partial)
{
int64_t current_line_id;
tardis_error_t ret_val = TARDIS_ERROR_OK;
double current_nu = storage->packet_nus[packet_index];
double current_energy = storage->packet_energies[packet_index];
double current_mu = storage->packet_mus[packet_index];
double comov_current_nu = current_nu;
int current_shell_id = 0;
double current_r = storage->r_inner[0];
double beta = current_r * storage->inverse_time_explosion * INVERSE_C;
if (storage->full_relativity)
{
current_nu = current_nu * (1 + beta * current_mu) / sqrt(1 - beta * beta);
current_energy = current_energy * (1 + beta * current_mu) / sqrt(1 - beta * beta);
current_mu = (current_mu + beta) / (1 + beta * current_mu);
}
else
{
current_nu = current_nu / (1 - beta * current_mu);
current_energy = current_energy / (1 - beta * current_mu);
}
if ((ret_val =
line_search (storage->line_list_nu, comov_current_nu,
storage->no_of_lines,
¤t_line_id)) != TARDIS_ERROR_OK)
{
return ret_val;
}
bool last_line = (current_line_id == storage->no_of_lines);
rpacket_set_nu (packet, current_nu);
rpacket_set_mu (packet, current_mu);
rpacket_set_energy (packet, current_energy);
rpacket_set_r (packet, current_r);
rpacket_set_current_shell_id (packet, current_shell_id);
rpacket_set_next_line_id (packet, current_line_id);
rpacket_set_last_line (packet, last_line);
rpacket_set_close_line (packet, false);
rpacket_set_virtual_packet_flag (packet, virtual_packet_flag);
packet->chi_bf_tmp_partial = chi_bf_tmp_partial;
packet->compute_chi_bf = true;
packet->vpacket_weight = 1.0;
return ret_val;
}
void move_packet_across_shell_boundary(rpacket_t *packet, storage_model_t *storage, double distance)
{
double comov_energy, doppler_factor, comov_nu, inverse_doppler_factor;
move_packet(packet, storage, distance);
if (rpacket_get_virtual_packet(packet) > 0)
{
double delta_tau_event = distance *
storage->electron_densities[rpacket_get_current_shell_id(packet)] *
storage->sigma_thomson;
rpacket_set_tau_event(packet, rpacket_get_tau_event(packet) + delta_tau_event);
}
else
{
rpacket_reset_tau_event(packet);
}
if ((rpacket_get_current_shell_id(packet) < storage->no_of_shells - 1 && rpacket_get_next_shell_id(packet) == 1) ||
(rpacket_get_current_shell_id(packet) > 0 && rpacket_get_next_shell_id(packet) == -1))
{
rpacket_set_current_shell_id(packet, rpacket_get_current_shell_id(packet) + rpacket_get_next_shell_id(packet));
rpacket_set_recently_crossed_boundary(packet, rpacket_get_next_shell_id(packet));
}
else if (rpacket_get_next_shell_id(packet) == 1)
{
rpacket_set_status(packet, TARDIS_PACKET_STATUS_EMITTED);
}
else if ((storage->reflective_inner_boundary == 0) ||
(rk_double(&mt_state) > storage->inner_boundary_albedo))
{
rpacket_set_status(packet, TARDIS_PACKET_STATUS_REABSORBED);
}
else
{
doppler_factor = rpacket_doppler_factor(packet, storage);
comov_nu = rpacket_get_nu(packet) * doppler_factor;
comov_energy = rpacket_get_energy(packet) * doppler_factor;
rpacket_set_mu(packet, rk_double(&mt_state));
inverse_doppler_factor = 1.0 / rpacket_doppler_factor(packet, storage);
rpacket_set_nu(packet, comov_nu * inverse_doppler_factor);
rpacket_set_energy(packet, comov_energy * inverse_doppler_factor);
rpacket_set_recently_crossed_boundary(packet, 1);
if (rpacket_get_virtual_packet_flag(packet) > 0)
{
montecarlo_one_packet(storage, packet, -2);
}
}
}
void montecarlo_thomson_scatter(rpacket_t *packet, storage_model_t *storage, double distance)
{
double comov_energy, doppler_factor, comov_nu, inverse_doppler_factor;
doppler_factor = move_packet(packet, storage, distance);
comov_nu = rpacket_get_nu(packet) * doppler_factor;
comov_energy = rpacket_get_energy(packet) * doppler_factor;
rpacket_set_mu(packet, 2.0 * rk_double(&mt_state) - 1.0);
inverse_doppler_factor = 1.0 / rpacket_doppler_factor(packet, storage);
rpacket_set_nu(packet, comov_nu * inverse_doppler_factor);
rpacket_set_energy(packet, comov_energy * inverse_doppler_factor);
rpacket_reset_tau_event(packet);
rpacket_set_recently_crossed_boundary(packet, 0);
storage->last_interaction_type[storage->current_packet_id] = 1;
if (rpacket_get_virtual_packet_flag(packet) > 0)
{
montecarlo_one_packet(storage, packet, 1);
}
}
void
montecarlo_thomson_scatter (rpacket_t * packet, storage_model_t * storage,
double distance, rk_state *mt_state)
{
move_packet (packet, storage, distance);
double doppler_factor = rpacket_doppler_factor (packet, storage);
double comov_nu = rpacket_get_nu (packet) * doppler_factor;
double comov_energy = rpacket_get_energy (packet) * doppler_factor;
rpacket_set_mu (packet, 2.0 * rk_double (mt_state) - 1.0);
double inverse_doppler_factor = 1.0 / rpacket_doppler_factor (packet, storage);
rpacket_set_nu (packet, comov_nu * inverse_doppler_factor);
rpacket_set_energy (packet, comov_energy * inverse_doppler_factor);
rpacket_reset_tau_event (packet, mt_state);
storage->last_interaction_type[rpacket_get_id (packet)] = 1;
if (rpacket_get_virtual_packet_flag (packet) > 0)
{
montecarlo_one_packet (storage, packet, 1, mt_state);
}
}
tardis_error_t rpacket_init(rpacket_t *packet, storage_model_t *storage, int packet_index, int virtual_packet_flag)
{
double nu_line;
double current_r;
double current_mu;
double current_nu;
double comov_current_nu;
double current_energy;
int64_t current_line_id;
int current_shell_id;
bool last_line;
bool close_line;
int recently_crossed_boundary;
tardis_error_t ret_val = TARDIS_ERROR_OK;
current_nu = storage->packet_nus[packet_index];
current_energy = storage->packet_energies[packet_index];
current_mu = storage->packet_mus[packet_index];
comov_current_nu = current_nu;
current_shell_id = 0;
current_r = storage->r_inner[0];
current_nu = current_nu / (1 - (current_mu * current_r * storage->inverse_time_explosion * INVERSE_C));
current_energy = current_energy / (1 - (current_mu * current_r * storage->inverse_time_explosion * INVERSE_C));
if ((ret_val = line_search(storage->line_list_nu, comov_current_nu, storage->no_of_lines, ¤t_line_id)) != TARDIS_ERROR_OK)
{
return ret_val;
}
last_line = (current_line_id == storage->no_of_lines);
recently_crossed_boundary = true;
rpacket_set_nu(packet, current_nu);
rpacket_set_mu(packet, current_mu);
rpacket_set_energy(packet, current_energy);
rpacket_set_r(packet, current_r);
rpacket_set_current_shell_id(packet, current_shell_id);
rpacket_set_next_line_id(packet, current_line_id);
rpacket_set_last_line(packet, last_line);
rpacket_set_close_line(packet, false);
rpacket_set_recently_crossed_boundary(packet, recently_crossed_boundary);
rpacket_set_virtual_packet_flag(packet, virtual_packet_flag);
return ret_val;
}
void
montecarlo_line_scatter (rpacket_t * packet, storage_model_t * storage,
double distance, rk_state *mt_state)
{
uint64_t next_line_id = rpacket_get_next_line_id (packet);
uint64_t line2d_idx = next_line_id +
storage->no_of_lines * rpacket_get_current_shell_id (packet);
if (rpacket_get_virtual_packet (packet) == 0)
{
increment_j_blue_estimator (packet, storage, distance, line2d_idx);
increment_Edotlu_estimator (packet, storage, line2d_idx);
}
double tau_line =
storage->line_lists_tau_sobolevs[line2d_idx];
double tau_continuum = rpacket_get_chi_continuum(packet) * distance;
double tau_combined = tau_line + tau_continuum;
//rpacket_set_next_line_id (packet, rpacket_get_next_line_id (packet) + 1);
if (next_line_id + 1 == storage->no_of_lines)
{
rpacket_set_last_line (packet, true);
}
if (rpacket_get_virtual_packet (packet) > 0)
{
rpacket_set_tau_event (packet,
rpacket_get_tau_event (packet) + tau_line);
rpacket_set_next_line_id (packet, next_line_id + 1);
}
else if (rpacket_get_tau_event (packet) < tau_combined)
{
move_packet (packet, storage, distance);
double old_doppler_factor = rpacket_doppler_factor (packet, storage);
rpacket_set_mu (packet, 2.0 * rk_double (mt_state) - 1.0);
double inverse_doppler_factor = 1.0 / rpacket_doppler_factor (packet, storage);
double comov_energy = rpacket_get_energy (packet) * old_doppler_factor;
rpacket_set_energy (packet, comov_energy * inverse_doppler_factor);
storage->last_interaction_in_nu[rpacket_get_id (packet)] =
rpacket_get_nu (packet);
storage->last_line_interaction_in_id[rpacket_get_id (packet)] =
next_line_id;
storage->last_line_interaction_shell_id[rpacket_get_id (packet)] =
rpacket_get_current_shell_id (packet);
storage->last_interaction_type[rpacket_get_id (packet)] = 2;
int64_t emission_line_id = 0;
if (storage->line_interaction_id == 0)
{
emission_line_id = next_line_id;
}
else if (storage->line_interaction_id >= 1)
{
emission_line_id = macro_atom (packet, storage, mt_state);
}
storage->last_line_interaction_out_id[rpacket_get_id (packet)] =
emission_line_id;
rpacket_set_nu (packet,
storage->line_list_nu[emission_line_id] *
inverse_doppler_factor);
rpacket_set_nu_line (packet, storage->line_list_nu[emission_line_id]);
rpacket_set_next_line_id (packet, emission_line_id + 1);
rpacket_reset_tau_event (packet, mt_state);
if (rpacket_get_virtual_packet_flag (packet) > 0)
{
bool virtual_close_line = false;
if (!rpacket_get_last_line (packet) &&
fabs (storage->line_list_nu[rpacket_get_next_line_id (packet)] -
rpacket_get_nu_line (packet)) <
(rpacket_get_nu_line (packet)* 1e-7))
{
virtual_close_line = true;
}
// QUESTIONABLE!!!
bool old_close_line = rpacket_get_close_line (packet);
rpacket_set_close_line (packet, virtual_close_line);
montecarlo_one_packet (storage, packet, 1, mt_state);
rpacket_set_close_line (packet, old_close_line);
virtual_close_line = false;
}
}
else
{
rpacket_set_tau_event (packet,
rpacket_get_tau_event (packet) - tau_line);
rpacket_set_next_line_id (packet, next_line_id + 1);
}
if (!rpacket_get_last_line (packet) &&
fabs (storage->line_list_nu[rpacket_get_next_line_id (packet)] -
rpacket_get_nu_line (packet)) < (rpacket_get_nu_line (packet)*
1e-7))
{
rpacket_set_close_line (packet, true);
}
}
int64_t
montecarlo_one_packet (storage_model_t * storage, rpacket_t * packet,
int64_t virtual_mode, rk_state *mt_state)
{
int64_t reabsorbed=-1;
if (virtual_mode == 0)
{
reabsorbed = montecarlo_one_packet_loop (storage, packet, 0, mt_state);
}
else
{
if ((rpacket_get_nu (packet) > storage->spectrum_virt_start_nu) && (rpacket_get_nu(packet) < storage->spectrum_virt_end_nu))
{
for (int64_t i = 0; i < rpacket_get_virtual_packet_flag (packet); i++)
{
double weight;
rpacket_t virt_packet = *packet;
double mu_min;
if (rpacket_get_r(&virt_packet) > storage->r_inner[0])
{
mu_min =
-1.0 * sqrt (1.0 -
(storage->r_inner[0] / rpacket_get_r(&virt_packet)) *
(storage->r_inner[0] / rpacket_get_r(&virt_packet)));
}
else
{
mu_min = 0.0;
}
double mu_bin = (1.0 - mu_min) / rpacket_get_virtual_packet_flag (packet);
rpacket_set_mu(&virt_packet,mu_min + (i + rk_double (mt_state)) * mu_bin);
switch (virtual_mode)
{
case -2:
weight = 1.0 / rpacket_get_virtual_packet_flag (packet);
break;
case -1:
weight =
2.0 * rpacket_get_mu(&virt_packet) /
rpacket_get_virtual_packet_flag (packet);
break;
case 1:
weight =
(1.0 -
mu_min) / 2.0 / rpacket_get_virtual_packet_flag (packet);
break;
default:
fprintf (stderr, "Something has gone horribly wrong!\n");
// FIXME MR: we need to somehow signal an error here
// I'm adding an exit() here to inform the compiler about the impossible path
exit(1);
}
double doppler_factor_ratio =
rpacket_doppler_factor (packet, storage) /
rpacket_doppler_factor (&virt_packet, storage);
rpacket_set_energy(&virt_packet,
rpacket_get_energy (packet) * doppler_factor_ratio);
rpacket_set_nu(&virt_packet,rpacket_get_nu (packet) * doppler_factor_ratio);
reabsorbed = montecarlo_one_packet_loop (storage, &virt_packet, 1, mt_state);
#ifdef WITH_VPACKET_LOGGING
#ifdef WITHOPENMP
#pragma omp critical
{
#endif // WITHOPENMP
if (storage->virt_packet_count >= storage->virt_array_size)
{
storage->virt_array_size *= 2;
storage->virt_packet_nus = safe_realloc(storage->virt_packet_nus, sizeof(double) * storage->virt_array_size);
storage->virt_packet_energies = safe_realloc(storage->virt_packet_energies, sizeof(double) * storage->virt_array_size);
storage->virt_packet_last_interaction_in_nu = safe_realloc(storage->virt_packet_last_interaction_in_nu, sizeof(double) * storage->virt_array_size);
storage->virt_packet_last_interaction_type = safe_realloc(storage->virt_packet_last_interaction_type, sizeof(int64_t) * storage->virt_array_size);
storage->virt_packet_last_line_interaction_in_id = safe_realloc(storage->virt_packet_last_line_interaction_in_id, sizeof(int64_t) * storage->virt_array_size);
storage->virt_packet_last_line_interaction_out_id = safe_realloc(storage->virt_packet_last_line_interaction_out_id, sizeof(int64_t) * storage->virt_array_size);
}
storage->virt_packet_nus[storage->virt_packet_count] = rpacket_get_nu(&virt_packet);
storage->virt_packet_energies[storage->virt_packet_count] = rpacket_get_energy(&virt_packet) * weight;
storage->virt_packet_last_interaction_in_nu[storage->virt_packet_count] = storage->last_interaction_in_nu[rpacket_get_id (packet)];
storage->virt_packet_last_interaction_type[storage->virt_packet_count] = storage->last_interaction_type[rpacket_get_id (packet)];
storage->virt_packet_last_line_interaction_in_id[storage->virt_packet_count] = storage->last_line_interaction_in_id[rpacket_get_id (packet)];
storage->virt_packet_last_line_interaction_out_id[storage->virt_packet_count] = storage->last_line_interaction_out_id[rpacket_get_id (packet)];
storage->virt_packet_count += 1;
#ifdef WITHOPENMP
}
#endif // WITHOPENMP
#endif // WITH_VPACKET_LOGGING
if ((rpacket_get_nu(&virt_packet) < storage->spectrum_end_nu) &&
(rpacket_get_nu(&virt_packet) > storage->spectrum_start_nu))
{
#ifdef WITHOPENMP
#pragma omp critical
{
#endif // WITHOPENMP
int64_t virt_id_nu =
floor ((rpacket_get_nu(&virt_packet) -
storage->spectrum_start_nu) /
storage->spectrum_delta_nu);
storage->spectrum_virt_nu[virt_id_nu] +=
rpacket_get_energy(&virt_packet) * weight;
#ifdef WITHOPENMP
}
#endif // WITHOPENMP
}
}
}
else
{
return 1;
}
}
return reabsorbed;
}
void montecarlo_line_scatter(rpacket_t *packet, storage_model_t *storage, double distance)
{
double comov_energy = 0.0;
int64_t emission_line_id = 0;
double old_doppler_factor = 0.0;
double inverse_doppler_factor = 0.0;
double tau_line = 0.0;
double tau_electron = 0.0;
double tau_combined = 0.0;
bool virtual_close_line = false;
int64_t j_blue_idx = -1;
if (rpacket_get_virtual_packet(packet) == 0)
{
j_blue_idx = rpacket_get_current_shell_id(packet) * storage->line_lists_j_blues_nd + rpacket_get_next_line_id(packet);
increment_j_blue_estimator(packet, storage, distance, j_blue_idx);
}
tau_line = storage->line_lists_tau_sobolevs[rpacket_get_current_shell_id(packet) * storage->line_lists_tau_sobolevs_nd + rpacket_get_next_line_id(packet)];
tau_electron = storage->sigma_thomson * storage->electron_densities[rpacket_get_current_shell_id(packet)] * distance;
tau_combined = tau_line + tau_electron;
rpacket_set_next_line_id(packet, rpacket_get_next_line_id(packet) + 1);
if (rpacket_get_next_line_id(packet) == storage->no_of_lines)
{
rpacket_set_last_line(packet, true);
}
if (rpacket_get_virtual_packet(packet) > 0)
{
rpacket_set_tau_event(packet, rpacket_get_tau_event(packet) + tau_line);
}
else if (rpacket_get_tau_event(packet) < tau_combined)
{
old_doppler_factor = move_packet(packet, storage, distance);
rpacket_set_mu(packet, 2.0 * rk_double(&mt_state) - 1.0);
inverse_doppler_factor = 1.0 / rpacket_doppler_factor(packet, storage);
comov_energy = rpacket_get_energy(packet) * old_doppler_factor;
rpacket_set_energy(packet, comov_energy * inverse_doppler_factor);
storage->last_line_interaction_in_id[storage->current_packet_id] = rpacket_get_next_line_id(packet) - 1;
storage->last_line_interaction_shell_id[storage->current_packet_id] = rpacket_get_current_shell_id(packet);
storage->last_interaction_type[storage->current_packet_id] = 2;
if (storage->line_interaction_id == 0)
{
emission_line_id = rpacket_get_next_line_id(packet) - 1;
}
else if (storage->line_interaction_id >= 1)
{
emission_line_id = macro_atom(packet, storage);
}
storage->last_line_interaction_out_id[storage->current_packet_id] = emission_line_id;
rpacket_set_nu(packet, storage->line_list_nu[emission_line_id] * inverse_doppler_factor);
rpacket_set_nu_line(packet, storage->line_list_nu[emission_line_id]);
rpacket_set_next_line_id(packet, emission_line_id + 1);
rpacket_reset_tau_event(packet);
rpacket_set_recently_crossed_boundary(packet, 0);
if (rpacket_get_virtual_packet_flag(packet) > 0)
{
virtual_close_line = false;
if (!rpacket_get_last_line(packet) &&
fabs(storage->line_list_nu[rpacket_get_next_line_id(packet)] -
rpacket_get_nu_line(packet)) / rpacket_get_nu_line(packet) < 1e-7)
{
virtual_close_line = true;
}
// QUESTIONABLE!!!
bool old_close_line = rpacket_get_close_line(packet);
rpacket_set_close_line(packet, virtual_close_line);
montecarlo_one_packet(storage, packet, 1);
rpacket_set_close_line(packet, old_close_line);
virtual_close_line = false;
}
}
else
{
rpacket_set_tau_event(packet, rpacket_get_tau_event(packet) - tau_line);
}
if (!rpacket_get_last_line(packet) &&
fabs(storage->line_list_nu[rpacket_get_next_line_id(packet)] -
rpacket_get_nu_line(packet)) / rpacket_get_nu_line(packet) < 1e-7)
{
rpacket_set_close_line(packet, true);
}
}
bool
test_rpacket_get_nu(double value) {
rpacket_t rp;
rpacket_set_nu(&rp, value);
return value==rpacket_get_nu(&rp);
}