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; }