bool Sprinkler::load_config() {
bool ret = true;
ret &= load_time();
ret &= load_sprinkler_config();
ret &= load_sensors_config();
ret &= load_valves_config();
ret &= load_irrigations_instructions();
m_valves_manager.Update(valves, irrigations);
return ret;
}
void system_pre_init(void)
{
timestamp_t t;
if (load_time(&t))
force_time(t);
ramdata_get_persistent();
__running_copy = get_image_copy();
if (__running_copy == SYSTEM_IMAGE_UNKNOWN) {
__running_copy = SYSTEM_IMAGE_RO;
system_set_reset_flags(load_reset_flags());
}
*(uintptr_t *)(__host_flash + CONFIG_RO_MEM_OFF + 4) =
(uintptr_t)__ro_jump_resetvec;
*(uintptr_t *)(__host_flash + CONFIG_RW_MEM_OFF + 4) =
(uintptr_t)__rw_jump_resetvec;
}
void MacroParameterizationWavelets::Step(State & state)
{
std::cout.precision(8);
static int count_steps = 0;
timeunit field_time(0), PIC_time(0), algebra_time(0), load_time(0), lift_time(0), pushback_time(0), cutoff_time(0);
std::chrono::high_resolution_clock::time_point start, stop;
int number_of_microsteps = _plasma->get_number_of_microsteps();
if (number_of_microsteps == 0)
{
std::shared_ptr<double> simulation_time = state.get_simulation_time();
double current_time = *simulation_time;
start = std::chrono::high_resolution_clock::now();
this->SetAccField(state);
stop = std::chrono::high_resolution_clock::now();
field_time += std::chrono::duration_cast<timeunit>(stop - start);
start = std::chrono::high_resolution_clock::now();
for (int i=0; i<_plasma->get_macro_to_micro_dt_ratio(); i++)
state.Step();
stop = std::chrono::high_resolution_clock::now();
PIC_time += std::chrono::duration_cast<timeunit>(stop - start);
start = std::chrono::high_resolution_clock::now();
_stack_index = 0;
this->RestrictAndPushback(state, 0.);
stop = std::chrono::high_resolution_clock::now();
pushback_time += std::chrono::duration_cast<timeunit>(stop - start);
start = std::chrono::high_resolution_clock::now();
_stack_ion_distribution.front().Cutoff(_cutoff);
stop = std::chrono::high_resolution_clock::now();
cutoff_time += std::chrono::duration_cast<timeunit>(stop - start);
start = std::chrono::high_resolution_clock::now();
this->Lift();
stop = std::chrono::high_resolution_clock::now();
lift_time += std::chrono::duration_cast<timeunit>(stop - start);
*simulation_time = current_time + _plasma->get_macro_to_micro_dt_ratio()*_plasma->get_dt();
}
else if (number_of_microsteps == _plasma->get_macro_to_micro_dt_ratio())
{
std::shared_ptr<double> simulation_time = state.get_simulation_time();
double current_time = *simulation_time;
start = std::chrono::high_resolution_clock::now();
this->SetAccField(state);
stop = std::chrono::high_resolution_clock::now();
field_time += std::chrono::duration_cast<timeunit>(stop - start);
if (_record_microsteps)
_record_times.clear();
_stack_index = 0;
for (int i=0; i<number_of_microsteps; i++)
{
start = std::chrono::high_resolution_clock::now();
state.Step();
stop = std::chrono::high_resolution_clock::now();
PIC_time += std::chrono::duration_cast<timeunit>(stop - start);
}
start = std::chrono::high_resolution_clock::now();
this->RestrictAndPushback(state, 0.);
stop = std::chrono::high_resolution_clock::now();
pushback_time += std::chrono::duration_cast<timeunit>(stop - start);
start = std::chrono::high_resolution_clock::now();
_stack_ion_distribution.front().Cutoff(_cutoff);
stop = std::chrono::high_resolution_clock::now();
cutoff_time += std::chrono::duration_cast<timeunit>(stop - start);
_stack_index = 1;
start = std::chrono::high_resolution_clock::now();
this->Lift();
stop = std::chrono::high_resolution_clock::now();
lift_time += std::chrono::duration_cast<timeunit>(stop - start);
/* Here we load the electrons only, without using the normal MacroParameterizationWavelets::Load function */
start = std::chrono::high_resolution_clock::now();
std::vector<double>::iterator position = state.get_vector_of_position_arrays().at(1)->begin();
std::vector<double>::iterator velocity_x = state.get_vector_of_x_velocity_arrays().at(1)->begin();
std::vector<double>::iterator velocity_y = state.get_vector_of_y_velocity_arrays().at(1)->begin();
std::vector<double>::iterator weight = state.get_vector_of_weight_arrays().at(1)->begin();
int population_size = this->get_population_size(1);
_distributions.at(1)->Load(population_size, position, velocity_x, weight);
if (_cyclotronic_rotation_parameters.at(1) != 0.)
{
for (int i=0; i < population_size; i++)
{
double v = *(velocity_x+i);
double theta = RandomTools::Generate_randomly_uniform(0., 2.*M_PI);
velocity_x[i] = v*std::cos(theta);
velocity_y[i] = v*std::sin(theta);
}
}
state.Prepare(1, false);
stop = std::chrono::high_resolution_clock::now();
load_time += std::chrono::duration_cast<timeunit>(stop - start);
*simulation_time = current_time + _plasma->get_macro_to_micro_dt_ratio()*_plasma->get_dt();
if (_record_microsteps)
{
_record_ion_distribution.at(_record_times.size()) = _stack_ion_distribution.front();
_record_times.push_back(*simulation_time);
}
}
else
{
std::shared_ptr<double> simulation_time = state.get_simulation_time();
double current_time = *simulation_time;
double ratio = static_cast<double>(_plasma->get_macro_to_micro_dt_ratio() - number_of_microsteps);
/* Explicit Euler integration */
/* Obtain the ion acceleration field for approximation of the characteristics */
start = std::chrono::high_resolution_clock::now();
this->SetAccField(state);
stop = std::chrono::high_resolution_clock::now();
field_time += std::chrono::duration_cast<timeunit>(stop - start);
if (_record_microsteps)
_record_times.clear();
/* Now we advance while measuring the coarse data for a set number of microsteps */
_stack_index = 0;
start = std::chrono::high_resolution_clock::now();
this->RestrictAndPushback(state, ratio + number_of_microsteps);
stop = std::chrono::high_resolution_clock::now();
pushback_time += std::chrono::duration_cast<timeunit>(stop - start);
for (int i=0; i<number_of_microsteps; i++)
{
start = std::chrono::high_resolution_clock::now();
state.Step();
stop = std::chrono::high_resolution_clock::now();
PIC_time += std::chrono::duration_cast<timeunit>(stop - start);
start = std::chrono::high_resolution_clock::now();
this->RestrictAndPushback(state, ratio + number_of_microsteps-i-1);
stop = std::chrono::high_resolution_clock::now();
pushback_time += std::chrono::duration_cast<timeunit>(stop - start);
}
/**************************/
/* Extrapolate using EFPI */
/**************************/
/* First we calculate the slope using the mean-square estimate */
start = std::chrono::high_resolution_clock::now();
static ActiveWaveletRepresentation first_slope = ActiveWaveletRepresentation(_plasma, _ion_vmax, _depth, _macro_grid_size);
double slope_factor = static_cast<double>(6*ratio)/static_cast<double>(number_of_microsteps*(number_of_microsteps+1)*(number_of_microsteps+2));
first_slope = slope_factor*number_of_microsteps*(_stack_ion_distribution.at(number_of_microsteps)-_stack_ion_distribution.front());
for (int i=1; 2*i<number_of_microsteps; i++)
first_slope += slope_factor*(number_of_microsteps-2*i)*(_stack_ion_distribution.at(number_of_microsteps-i)-_stack_ion_distribution.at(i));
/* We take a projective Euler step following this slope */
std::swap(_stack_ion_distribution.front(), _stack_ion_distribution.at(number_of_microsteps));
_stack_ion_distribution.front() += first_slope;
stop = std::chrono::high_resolution_clock::now();
algebra_time += std::chrono::duration_cast<timeunit>(stop - start);
/* We denoise the resulting distribution using a fixed wavelet resolution cutoff */
start = std::chrono::high_resolution_clock::now();
_stack_ion_distribution.front().Cutoff(_cutoff);
stop = std::chrono::high_resolution_clock::now();
cutoff_time += std::chrono::duration_cast<timeunit>(stop - start);
/* Finally we lift the distribution to the fine grid and we load the particles */
_stack_index = 1;
double ion_particle_moment, ion_distr_moment, electron_moment;
this->CalculateIonMoment(state, ion_particle_moment, ion_distr_moment);
this->CalculateElectronMoment(state, electron_moment);
std::cout << ++count_steps << " | Final particle ion moment: " << ion_particle_moment << "; Distribution ion moment: " << ion_distr_moment << "; Electron moment: " << electron_moment << "; Total moment: " << ion_particle_moment + electron_moment << std::endl;
start = std::chrono::high_resolution_clock::now();
this->Lift();
stop = std::chrono::high_resolution_clock::now();
lift_time += std::chrono::duration_cast<timeunit>(stop - start);
start = std::chrono::high_resolution_clock::now();
this->Load(state);
stop = std::chrono::high_resolution_clock::now();
load_time += std::chrono::duration_cast<timeunit>(stop - start);
*simulation_time = current_time + _plasma->get_macro_to_micro_dt_ratio()*_plasma->get_dt();
if (_record_microsteps)
{
_record_ion_distribution.at(_record_times.size()) = _stack_ion_distribution.front();
_record_times.push_back(*simulation_time);
}
}
_distributions.front()->GetDensityVelocityPressure(_ion_density, _ion_velocity, _ion_pressure);
std::swap(_current_step_ion_distribution, _stack_ion_distribution.front());
/* Diagnostics: output timing info */
// std::cout << ++count_steps << " | PIC time: " << PIC_time.count() << ", Field time: " << field_time.count() << ", Pushback time: " << pushback_time.count() << ", Algebra time: " << algebra_time.count() << ", Cutoff time: " << cutoff_time.count() << ", Load time: "<< load_time.count() << ", Lift time: " << lift_time.count() << std::endl;
/* Diagnostic: extract electron parameters */
std::vector<double>::iterator electron_position = state.get_vector_of_position_arrays().back()->begin();
std::vector<double>::iterator electron_velocity = state.get_vector_of_x_velocity_arrays().back()->begin();
std::vector<double>::iterator electron_weight = state.get_vector_of_weight_arrays().back()->begin();
int electron_population_size = state.get_vector_of_position_arrays().back()->size();
_distributions.back()->Weigh(electron_population_size, electron_position, electron_velocity, electron_weight);
// /* Diagnostic: extract electron velocity distribution */
// std::vector<std::vector<double> > profile_by_population;
// state.ComputeVelocityProfile(profile_by_population);
// std::cout << "t = " << count_steps << " | Velocity profile: " << std::endl;
// for (auto val: profile_by_population.back())
// std::cout << val << "\t";
// std::cout << std::endl;
}
