def initialize_strategy(self):
self.initializer = Initializer(self.world)
self.actionQueue = ActionQueue(self.world)
self.__weather_map = WeatherMap(self.world.weather_by_cell_x_y,
Constant.WEATHER_MAP_CELL_SIZE)
self.__terrain_map = TerrainMap(self.world.terrain_by_cell_x_y,
Constant.TERRAIN_MAP_CELL_SIZE)
def __init__(self):
self.data_initializer = Initializer('sw_templates.json')
self.background_color = [
color / 255
for color in self.data_initializer.get_background_color()
]
self.create_window()
self.displayer = DisplayMaster(
self.data_initializer.get_all_figure_list(),
self.data_initializer.get_figure_color(),
self.data_initializer.get_move_vector())
def __init__(self, manager, editor): from Initializer import Initializer Initializer(manager, editor) from SelectedEncodingsExtractor import Extractor Extractor(manager, editor) from RowSelector import Selector Selector(manager, editor) from ModelUpdater import Updater Updater(manager, editor) from ModelDataGenerator import Generator Generator(manager, editor)
def __init__(self, manager, editor):
from Initializer import Initializer
Initializer(manager, editor)
from LanguageEmitter import Emitter
Emitter(manager, editor)
from LanguageSelector import Selector
Selector(manager, editor)
from ModelUpdater import Updater
Updater(manager, editor)
from DataModelGenerator import Generator
Generator(manager, editor)
def __init__(self, manager, editor):
from Initializer import Initializer
Initializer(manager, editor)
from FolderChanger import Changer
Changer(manager, editor)
from URISelector import Selector
Selector(manager, editor)
from URILoader import Loader
Loader(manager, editor)
from ActivatorHandler import Handler
Handler(manager, editor)
def __init__(self, manager):
from Initializer import Initializer
Initializer(manager)
from UpDownKeyHandler import Handler
Handler(manager)
from KeyboardHandler import Handler
Handler(manager)
from Disabler import Disabler
Disabler(manager)
from RowSelector import Selector
Selector(manager)
from RowActivator import Activator
Activator(manager)
from ModelUpdater import Updater
Updater(manager)
from ModelDataGenerator import Generator
Generator(manager)
def __init__(self, manager, editor): from Initializer import Initializer Initializer(manager, editor) from Disabler import Disabler Disabler(manager, editor) from RowDeleter import Deleter Deleter(manager, editor) from RowActivator import Activator Activator(manager, editor) from RowSelectionMonitor import Monitor Monitor(manager, editor) from RowSelector import Selector Selector(manager, editor) from ModelUpdater import Updater Updater(manager, editor) from ModelDataGenerator import Generator Generator(manager, editor)
def __init__(self, manager, editor):
from Initializer import Initializer
Initializer(manager, editor)
from KeyboardHandler import Handler
Handler(manager, editor)
from FocusMonitor import Monitor
Monitor(manager, editor)
from ModelUpdater import Updater
Updater(manager, editor)
from ModelDataGenerator import Generator
Generator(manager, editor)
from RowExpansionHandler import Handler
Handler(manager, editor)
from RowActivationHandler import Handler
Handler(manager, editor)
from FocusSwitcher import Switcher
Switcher(manager, editor)
from FocusGrabber import Grabber
Grabber(manager, editor)
from SensitivityManager import Manager
Manager(manager)
def prepare_simulation(self):
r"""Set up a Fourier propagator for the simulation loop. Set the
potential and initial values according to the configuration.
:raise ValueError: For invalid or missing input data.
"""
# The potential instance
potential = BlockFactory().create_potential(self.parameters)
# Compute the position space grid points
grid = BlockFactory().create_grid(self.parameters)
# Construct initial values
I = Initializer(self.parameters)
initialvalues = I.initialize_for_fourier(grid)
# Transform the initial values to the canonical basis
BT = BasisTransformationWF(potential)
BT.set_grid(grid)
BT.transform_to_canonical(initialvalues)
# Finally create and initialize the propagator instace
self.propagator = FourierPropagator(potential, initialvalues,
self.parameters)
# Write some initial values to disk
slots = self._tm.compute_number_saves()
self.IOManager.add_grid(self.parameters, blockid="global")
self.IOManager.add_fourieroperators(self.parameters)
self.IOManager.add_wavefunction(self.parameters, timeslots=slots)
self.IOManager.save_grid(grid.get_nodes(flat=False), blockid="global")
self.IOManager.save_fourieroperators(self.propagator.get_operators())
self.IOManager.save_wavefunction(initialvalues.get_values(),
timestep=0)
def __init__(self, editor, uri, encoding): GObject.__init__(self) from Destroyer import Destroyer Destroyer(self, editor) from FileMounter import Mounter Mounter(self, editor) from GIOErrorHandler import Handler Handler(self, editor) from BusyManager import Manager Manager(self, editor) from StateNotifier import Notifier Notifier(self, editor) from ErrorManager import Manager Manager(self, editor) from TextInserter import Inserter Inserter(self, editor) from EncodingProcessor import Processor Processor(self, editor) from URIReader import Reader Reader(self, editor) from FileTypeChecker import Checker Checker(self, editor) from Initializer import Initializer Initializer(self, editor, uri, encoding)
def visualize(DE, iterations, title='Differential Evolution'):
results, time = DE.run(iterations)
fig, ax = plt.subplots(figsize=(8, 8))
for x in range(10):
plt.plot(results[:, x], label='Vector' + str(x))
ax.ticklabel_format(style='plain')
plt.ylabel("Profit/Fitness")
plt.xlabel("Iteration")
print('Time needed:', time)
plt.legend()
plt.show()
# Parameter:
np = 10 #Populationsize
problemnumber = 1
F = 0.5 #Scale Factor
Cr = 0.3 #Crossover probability
ppp = PPP(problemnumber)
initializer = Initializer(ppp, np)
donorgenerator = DonorGenerator(F)
trialgenerator = TrialGenerator(Cr, problemnumber)
selector = Selector(ppp)
de = DE
DifferentialEvolution = de(ppp, initializer, donorgenerator, trialgenerator,
selector)
visualize(DifferentialEvolution, 500)
def single_case_analysis_one_port_image_geometry():
""" case study for image geometry design """
# ------------ Generate the data-layer:
json_interpreter = generate_data_layer()
# ------------ Generate the Fourier Coefficients:
#
r = 0.2
br = 0.3
delta = 0.17
n_coefs = 100
period = 1
a_s, b_s = generate_fourier_coefficients(n_coefs, period, my_fun, br, r,
delta)
# n_coefs = 100
# period = 1
# a_s, b_s = generate_fourier_coefficients(n_coefs, period, my_fun_2, delta1, delta2)
# delta1, delta2 = 0.12, 0.3
# ---------- Pack the inputs:
# Define the oxidizer flow
ox_flow = 1.2
init_parameters = {
'combustion': {
'geometric_params': {
'type': SinglePortImageGeometry,
'L': 0.40,
'externalRadius': 0.05,
'imagePixelSize': 2048,
'imageMeterSize': 0.1
},
'shape_params': {
'a': a_s,
'b': b_s,
'baseRadius': 0.032,
'branches': 12,
'impact': 0.8,
'n': 50
},
'nozzle_params': {
'At': 0.000589,
'expansion': 5.7,
'lambda_e': 0.98,
'erosion': 0
},
'set_nozzle_design': False,
'design_params': {
'gamma': 1.27,
'p_chamber': 3200000,
'p_exit': 100000,
'c_star': 1500,
'ox_flow': ox_flow,
'OF': 5
},
},
}
simulation_parameters = {
'CombustionModel': CombustionObjectImage,
'combustion': {
'ox_flow': ox_flow,
'safety_thickness': 0.004,
'dt': 0.05,
'max_burn_time': 5
},
'mass_simulator': {
'ox_flow': ox_flow,
'burn_time': 'TBD',
'extra_filling': 0.05,
'injection_loss': 0.5,
'area_injection': 0.000105,
'system': SystemDynamic
},
'trajectory': {
'initial_conditions': {
'h0': 0,
'v0': 0,
'm0': 'TBD'
},
'simulation_time': 60
}
}
# -------------- Generate the initializer:
init_obj = Initializer(init_parameters=init_parameters,
simulation_parameters=simulation_parameters,
json_interpreter=json_interpreter)
# -------------- Generate the simulation object:
simulation_object = SimulationObject(initializer_collection=init_obj)
print("Minimum Thickness Before: {x:5.5f} mm \n".format(
x=1000 *
simulation_object.combustion_module.geometry.min_bloc_thickness()))
# -------------- Generate deep copy of geometry object:
geometry_object_original = deepcopy(
simulation_object.combustion_module.geometry)
# --------------- Run the simulation:
simulation_object.run_simulation_in_batch()
print("Minimum Thickness After: {x:5.5f} mm \n".format(
x=1000 *
simulation_object.combustion_module.geometry.min_bloc_thickness()))
# Print the total mass
print("\nRockets Total Mass: {0} kgs".format(
simulation_object.mass_simulator_module.get_mass()))
# Print the splitted masses
print(simulation_object.mass_simulator_module)
# Print combustion results
print(simulation_object.combustion_module)
# --------------- Export results to csv files:
# data directory
data_directory = "../data/data_tests"
file_name_expression = "Griffon Output Test {number}.csv"
simulation_object.export_results_to_file(
file_name_expression="/".join([data_directory, file_name_expression]))
# --------------- Plot the results
simulation_object.results_collection.elements_list[
0].combustion.plot_results()
simulation_object.results_collection.elements_list[
0].trajectory.plot_results()
# ---------------- Plot the geometries before and after:
geometry_object_original.export_geometry(
file_name="../Design/Design Files/original_geometry.txt")
simulation_object.combustion_module.geometry.export_geometry(
file_name="../Design/Design Files/geometry_after_burn.txt")
geometry_object_original.draw_geometry()
simulation_object.combustion_module.geometry.draw_geometry()
def single_case_analysis_three_circular_ports():
"""
Study the behavior of the rocket for a single case with ThreeCircularPort
:return: nothing
"""
# ------------ Generate the data-layer:
json_interpreter = generate_data_layer(
"Thermodynamic Data 36 bar OF 0,1 to 8,0 H2O2 87,5.json")
# ---------- Pack the inputs:
# Set the ox_flow
ox_flow = 1.12
init_parameters = {
'combustion': {
'geometric_params': {
'type': ThreeCircularPorts,
'L': 0.325,
'portsIntialRadius': 0.016,
'r_ext': 0.07,
'regressionModel': Reg.TwoRegimesMarxmanAndFloodedModel
},
'nozzle_params': {
'At': 0.000589,
'expansion': 5.7,
'lambda_e': 0.98,
'erosion': 0
},
'set_nozzle_design': True,
'design_params': {
'gamma': 1.27,
'p_chamber': 3600000,
'p_exit': 100000,
'c_star': 1500,
'ox_flow': ox_flow,
'OF': 5
},
},
}
simulation_parameters = {
'combustion': {
'ox_flow': ox_flow,
'safety_thickness': 0.005,
'dt': 0.01,
'max_burn_time': 5
},
'mass_simulator': {
'ox_flow': ox_flow,
'burn_time': 'TBD',
'system': SystemDynamic,
'extra_filling': 0.1,
'injection_loss': 0.5,
'area_injection': 0.000105
},
'trajectory': {
'initial_conditions': {
'h0': 0,
'v0': 0,
'm0': 'TBD'
},
'simulation_time': 60
}
}
# -------------- Generate the initializer:
init_obj = Initializer(init_parameters=init_parameters,
simulation_parameters=simulation_parameters,
json_interpreter=json_interpreter)
# -------------- Generate the simulation object:
simulation_object = SimulationObject(initializer_collection=init_obj)
# --------------- Run the simulation:
simulation_object.run_simulation_in_batch()
# Print the total mass
print("\nRockets Total Mass: {0} kgs".format(
simulation_object.mass_simulator_module.get_mass()))
# Print the splitted masses
print(simulation_object.mass_simulator_module)
# # data directory
# data_directory = "../data/data_tests"
#
# file_name_expression = "Tentative Design {number}.csv"
#
# simulation_object.export_results_to_file(file_name_expression="/".join([data_directory,
# file_name_expression]))
#
# # Save to json the mass simulator dict
# output_file = "Tentative Design 1.json"
# with open("/".join([data_directory, output_file]), 'w') as f:
# json.dump(simulation_object.mass_simulator_module.dict, f)
# --------------- Plot the results
simulation_object.results_collection.elements_list[
0].combustion.plot_results()
simulation_object.results_collection.elements_list[
0].trajectory.plot_results()
# Show any plots
plt.show()
def test_simulation_initializer():
""" the method is in charge of generating the inputs for the initializer and
instantiating it. """
# ------------ Generate the data-layer:
json_interpreter = generate_data_layer(
"Thermodynamic Data 36 bar OF 0,1 to 8,0 H2O2 87,5.json")
# ---------- Pack the inputs:
init_parameters = {
'combustion': {
'geometric_params': {
'type': OneCircularPort,
'L': 0.5,
'rintInitial': 0.04,
'rext0': 0.1
},
'nozzle_params': {
'At': 0.000589,
'expansion': 5.7,
'lambda_e': 0.98,
'erosion': 0
},
'design_params': {
'gamma': 1.27,
'p_chamber': 3600000,
'p_exit': 100000,
'c_star': 1500,
'isp': 230,
'thrust': 30000
},
},
'mass_simulator': {
'tank_filling': 0.9
}
}
simulation_parameters = {
'combustion': {
'ox_flow': 'TBD',
'injection_loss': 0.5,
'area_injection': 0.000105,
'safety_thickness': 0.005,
'dt': 0.05
},
'trajectory': {
'initial_conditions': {
'h0': 0,
'v0': 0,
'm0': 'TBD'
},
'simulation_time': 40
}
}
# -------------- Generate the initializer:
init_obj = Initializer(init_parameters=init_parameters,
simulation_parameters=simulation_parameters,
json_interpreter=json_interpreter)
# -------------- Generate the simulation object:
simulation_object = SimulationObject(initializer_collection=init_obj)
# --------------- Run the simulation:
simulation_object.run_simulation_in_batch()
# --------------- Plot the results
# simulation_object.combustion_module.plot_results()
# simulation_object.trajectory_module.plot_results()
# print("Hello World"
# Export results to csv files
# data directory
data_directory = "..\data\data_tests"
file_name_expression = "Griffon Output Test {number}.csv"
simulation_object.export_results_to_file(
file_name_expression="/".join([data_directory, file_name_expression]))
# Plot results
simulation_object.results_collection.elements_list[
0].combustion.plot_results()
simulation_object.results_collection.elements_list[
0].trajectory.plot_results()
def generate_analysis_cases_multi_port_geometry():
""" generate analysis cases generates the associated dictionaries that will be used in the
run in batch method.
:return InitializerCollection"""
# ------------ Generate the data-layer:
json_interpreter = generate_data_layer(
"Thermodynamic Data 36 bar OF 0,1 to 8,0 H2O2 87,5.json")
# Set the parameters over which we want to iterate
ports_number = 4
burn_time = 5
external_radius = 0.08
chamber_length = 0.4
internal_radius = 0.01 * np.linspace(0.5, 2, 10)
r_center = 0.01
ox_flows = 0.001 * np.linspace(50, 400, 10)
# Get the Initializer Collection
collection = InitializerCollection([])
combinations = list(itertools.product(internal_radius, ox_flows))
for r_int, ox_flow in combinations:
# ---------- Pack the inputs:
init_parameters = {
'combustion': {
'geometric_params': {
'type': MultipleCircularPortsWithCircularCenter,
'L': chamber_length,
'N': ports_number,
'ringPortsIntialRadius': r_int,
'centralPortInitialRadius': r_center,
'r_ext': external_radius,
'regressionModel':
Reg.MarxmanAndConstantFloodingRegimeModel
},
'nozzle_params': {
'At': 0.000589,
'expansion': 5.7,
'lambda_e': 0.98,
'erosion': 0
},
'set_nozzle_design': True,
'design_params': {
'gamma': 1.27,
'p_chamber': 3600000,
'p_exit': 100000,
'c_star': 1500,
'ox_flow': ox_flow,
'OF': 5
},
},
}
simulation_parameters = {
'combustion': {
'ox_flow': ox_flow,
'safety_thickness': 0.0025,
'dt': 0.05,
'max_burn_time': burn_time
},
'mass_simulator': {
'ox_flow': ox_flow,
'burn_time': 'TBD',
'system': SystemDynamic,
'extra_filling': 0.05,
'injection_loss': 0.5,
'area_injection': 0.000105
},
'trajectory': {
'initial_conditions': {
'h0': 0,
'v0': 0,
'm0': 'TBD'
},
'simulation_time': 60
}
}
# Add initializer to the collection
new = Initializer(init_parameters=init_parameters,
simulation_parameters=simulation_parameters,
json_interpreter=json_interpreter)
collection.add_element(new)
# Return the collection
return collection
from Map import Map
from Initializer import Initializer
my_map = Map('start')
my_game = Initializer(my_map)
my_game.play()
#-*- coding:utf-8 -*-
"""
Description:
Author: shelldream
Date:
"""
import sys
reload(sys).setdefaultencoding('utf-8')
sys.path.append("../")
import Initializer.Initializer as Init
import tensorflow as tf
if __name__ == "__main__":
initializer = Init.Initializer("w", [128, 64], initializer="")
w = initializer.init()
print w
def single_case_analysis_one_port_review():
"""
Study the behavior of the rocket for a single case with OneCircularPort
:return: nothing
"""
# ------------ Generate the data-layer:
json_interpreter = generate_data_layer(
"Thermodynamic Data 36 bar OF 0,1 to 8,0 H2O2 87,5.json")
# ---------- Pack the inputs:
ox_flow = 1.09
init_parameters = {
'combustion': {
'geometric_params': {
'type': OneCircularPort,
'L': 0.325,
'rintInitial': 0.03,
'rext0': 0.05,
'regressionModel': Reg.MarxmanAndConstantFloodingRegimeModel
},
'nozzle_params': {
'At': 0.000589,
'expansion': 5.7,
'lambda_e': 0.98,
'erosion': 0
},
'set_nozzle_design': True,
'design_params': {
'gamma': 1.27,
'p_chamber': 3600000,
'p_exit': 100000,
'c_star': 1580,
'ox_flow': ox_flow,
'OF': 5.5
},
},
}
simulation_parameters = {
'combustion': {
'ox_flow': ox_flow,
'safety_thickness': 0.005,
'dt': 0.01,
'max_burn_time': 4.75
},
'mass_simulator': {
'ox_flow': ox_flow,
'burn_time': 'TBD',
'system': SystemStatic,
'system_dict': {
'dry_mass': 12.35 + 20 + 1.3,
'pressurizer_mass': 0.17,
'oxidizer_mass': 'TBD',
'fuel_mass': 'TBD'
},
'extra_filling': 0.1,
'injection_loss': 0.5,
'area_injection': 0.000105
},
'trajectory': {
'initial_conditions': {
'h0': 0,
'v0': 0,
'm0': 'TBD'
},
'simulation_time': 60
}
}
# -------------- Generate the initializer:
init_obj = Initializer(init_parameters=init_parameters,
simulation_parameters=simulation_parameters,
json_interpreter=json_interpreter)
# -------------- Generate the simulation object:
simulation_object = SimulationObject(initializer_collection=init_obj)
# --------------- Run the simulation:
simulation_object.run_simulation_in_batch()
# Print the total mass
print("\nRockets Total Mass: {0} kgs".format(
simulation_object.mass_simulator_module.get_mass()))
# Print the splitted masses
print(simulation_object.mass_simulator_module)
# Print combustion results
print(simulation_object.combustion_module)
# Print Trajectory results
print(simulation_object.trajectory_module)
# --------------- Plot the results
simulation_object.results_collection.elements_list[
0].combustion.plot_results()
simulation_object.results_collection.elements_list[
0].trajectory.plot_results()
# # data directory
# data_directory = "../Design/Design Files/Proposed Designs/Single Port Geometry/"
#
# file_name_expression = "Tentative Design Single Port Reviewed {number}.csv"
#
# simulation_object.export_results_to_file(file_name_expression="/".join([data_directory,
# file_name_expression]))
#
# # Save to json the mass simulator dict
# output_file = "Tentative Design Single Port Reviewed 1.json"
# with open("/".join([data_directory, output_file]), 'w') as f:
# json.dump(simulation_object.mass_simulator_module.dict, f)
# Show any plots
plt.show()
def __init__(self):
GObject.__init__(self)
from Initializer import Initializer
Initializer(self)
from Monitor import Monitor
Monitor(self)
iteration_best.append(max(evaluations))
#updating pheromone matrix
self.pheromone_matrix = self.evaporator.evaporate(
self.pheromone_matrix)
self.pheromone_matrix = self.intensificator.intensify(
self.pheromone_matrix, solutions)
return np.array(self.best_solutions_scores), np.array(self.solutions_generations), \
np.array(self.evaluations_generations)
taskinitializer = Taskinitializer(1)
initializer = Initializer()
solutiongenerator = SolutionGenerator(alpha=1, beta=1, num_of_ants=20)
evaporator = Evaporator(rho=0.1)
intensificator = Intensificator(delta=0.5)
antco = ACO(taskinitializer,
initializer,
solutiongenerator,
evaporator,
intensificator,
50,
printing=False)
solutions, scores, best_solutions = antco.run()
plt.plot(best_solutions)
plt.ylabel('')
def test_simulation_initializer(isImageBased):
""" the method is in charge of generating the inputs for the initializer and
instantiating it. """
# ------------ Generate the data-layer:
json_interpreter = generate_data_layer("DataLayerONERATests_Hycom14.json")
# ---------- Pack the inputs:
init_parameters = {
'combustion': {
'geometric_params': {'type': SinglePortImageGeometry, 'L': 0.4,
'externalRadius': 0.05, 'imagePixelSize': 1024,
'imageMeterSize': 0.1},
'shape_params': {'a': [0,1], 'b': [1, 0, 0],
'baseRadius': 0.036, 'branches': 10, 'impact': 0.1,
'n': 40},
'nozzle_params': {'At': 0.000589, 'expansion': 5.7, 'lambda_e': 0.98,
'erosion': 0},
'set_nozzle_design': True,
'design_params': {'gamma': 1.27, 'p_chamber': 3200000, 'p_exit': 100000,
'c_star': 1500, 'ox_flow': 1.2, 'OF': 5},
},
}
simulation_parameters = {
'combustion': {'ox_flow': 1, 'safety_thickness': 0.005, 'dt': 0.05,
'max_burn_time': None},
'mass_simulator': {'ox_flow': 1, 'burn_time': 'TBD', 'extra_filling': 0.05,
'injection_loss': 0.5, 'area_injection': 0.000105, 'system' : SystemDynamic},
'trajectory': {'initial_conditions': {'h0': 0, 'v0': 0, 'm0': 'TBD'},
'simulation_time': 100}
}
# -------------- Generate the initializer:
init_obj = Initializer(init_parameters=init_parameters,
simulation_parameters=simulation_parameters,
json_interpreter=json_interpreter)
# -------------- Generate the simulation object:
simulation_object = SimulationObject(isImageBased, initializer_collection=init_obj)
# --------------- Run the simulation:
simulation_object.run_simulation_in_batch(isImageBased)
# Print the total mass
print("\nRockets Total Mass: {0} kgs".format(simulation_object.mass_simulator_module.get_mass()))
# Print the splitted masses
print(simulation_object.mass_simulator_module)
# --------------- Export results to csv files:
# data directory
data_directory = "../data/data_tests"
file_name_expression = "Griffon Output Test {number}.csv"
simulation_object.export_results_to_file(file_name_expression="/".join([data_directory,
file_name_expression]))
# --------------- Plot the results
simulation_object.results_collection.elements_list[0].combustion.plot_results()
simulation_object.results_collection.elements_list[0].trajectory.plot_results()
# for debugging
from Initializer import Initializer
from DonorGenerator import DonorGenerator
from TrialGenerator import TrialGenerator
from Selector import Selector
from DE import DE
"""
Step 1: Read values of the control parameters of DE: scale
factor F, crossover rate Cr, and the population size NP from
user.
"""
# Parameter:
# np
# xmin =
# xmax =
# F =
# Cr =
initializer = Initializer(xmin, xmax, np)
donorgenerator = DonorGenerator(F)
trialgenerator = TrialGenerator(Cr)
selector = Selector
de = DE
DifferentialEvolution = de(initializer, donorgenerator, trialgenerator,
selector)
# for debugging
from Initializer import Initializer
from DonorGenerator import DonorGenerator
from TrialGenerator import TrialGenerator
from Selector import Selector
from DE import DE
"""
Step 1: Read values of the control parameters of DE: scale
factor F, crossover rate Cr, and the population size NP from
user.
"""
# Parameter:
# np
# (xmin =)
# (xmax =)
# problemnumber =
# F =
# Cr =
#initializer = Initializer(xmin, xmax, np)
initializer = Initializer(problemnumber, Np)
donorgenerator = DonorGenerator(F)
trialgenerator = TrialGenerator(Cr)
selector = Selector
de = DE
DifferentialEvolution = de(initializer, donorgenerator, trialgenerator,
selector)
def main():
parser = argparse.ArgumentParser(
description='Initialize or update a Postgres database with OSM data')
parser.add_argument(
'-i',
'--init',
dest='initialize',
action='store_const',
const=True,
default=False,
help='Initialize the database and supply a planet file')
parser.add_argument(
'-u',
'--update',
dest='update',
action='store_const',
const=True,
default=False,
help='Update and initialized database by downloading updates')
parser.add_argument('-f',
'--filter',
dest='filter_path',
default='./config/filter.json',
help='Filter file')
parser.add_argument('-b',
'--base_url',
dest='base_url',
default='https://planet.osm.ch/replication',
help='Planet website. Used both in init and update')
parser.add_argument(
'-m',
'--mode',
dest='mode',
default='hour',
help='replication mode (hour, minute...). Used both in init and update'
)
parser.add_argument('-ph',
'--psqlhost',
dest='psqlhost',
required=True,
help='Postgres host')
parser.add_argument('-ppo',
'--psqlport',
dest='psqlport',
default=5432,
help='Postgres port')
parser.add_argument('-pd',
'--psqldb',
dest='psqldb',
required=True,
help='Postgres database')
parser.add_argument('-pu',
'--psqluser',
dest='psqluser',
required=True,
help='Postgres user')
parser.add_argument('-pp',
'--psqlpassword',
dest='psqlpassword',
required=True,
help='Postgres password')
parser.add_argument(
'-p',
'--planet',
dest='planet_path',
default=None,
help='Planet file in pbf format. Option valid only if --init is used')
parser.add_argument('-d',
'--debug',
dest='debug',
action='store_const',
const=True,
default=False,
help='Debug mode')
args = parser.parse_args()
if args.initialize and args.update:
return print('Select either --init or --update, not both')
if not args.initialize and not args.update:
return print('Select one of --init or --update')
if args.initialize and args.planet_path is None:
return print('To initialize, we need a planet file (-p)')
if args.update and args.planet_path:
print('Ignoring planet file during updatess')
setup_logging(args.debug)
logging.debug('Options parsed')
logging.info(f'base url: {args.base_url}, mode: {args.mode}')
filt = Filter(args.filter_path)
if filt is None:
return
psql = PSQL(args.psqlhost, args.psqlport, args.psqldb, args.psqluser,
args.psqlpassword)
if args.initialize:
try:
initializer = Initializer(args, psql, filt)
initializer.start()
except:
logging.critical('Something came up.', exc_info=True)
return
psql.stop()
logging.info('Stopping PSQL. It might take some seconds')
