def setUpClass(cls):
     logging.basicConfig(level=logging.INFO)
     parser = Parser('../test_data', 'euro16_k2.txt')
     parser = parser.get_scenario(2)
     networkTopology = parser.networkTopology
     cls.graph = graph_factory(networkTopology)
     cls.candidate_path_fetcher = CandidatePathsFetcher(parser.candidatePaths,
                                                        networkTopology.n_nodes,
                                                        parser.pathsLengths)
 def setUp(self):
     parser = Parser('./data', 'euro16_k2.txt')
     self.scenario = parser.get_scenario(0)
     self.graph = graph_factory(self.scenario.networkTopology)
     self.logger = logging.getLogger(str(self.__class__))
     candidate_path_fetcher = CandidatePathsFetcher(self.scenario.candidatePaths,
                                                    self.scenario.networkTopology.n_nodes,
                                                    self.scenario.pathsLengths)
     self.demand_factory = DemandsFactory(candidate_path_fetcher)
     self.sa = SimulatedAnnealing()
 def setUpClass(cls):
     logging.basicConfig(level=logging.INFO)
     parser = Parser('../test_data', 'euro16_k2.txt')
     scenario = parser.get_scenario(2)
     networkTopology = scenario.networkTopology
     cls.graph = graph_factory(networkTopology)
     cls.candidate_path_fetcher = CandidatePathsFetcher(scenario.candidatePaths,
                                                        networkTopology.n_nodes,
                                                        scenario.pathsLengths)
     cls.demands = unicast_demands_factory(scenario.unicastDemands, cls.candidate_path_fetcher)
 def setUp(self):
     parser = Parser("../test_data", "euro16_k2.txt")
     scenario = parser.get_scenario(2)
     graph = graph_factory(scenario.networkTopology)
     candidatePathFetcher = CandidatePathsFetcher(scenario.candidatePaths, len(graph.nodes), scenario.pathsLengths)
     # get path
     list_of_paths1 = candidatePathFetcher.fetch_candidates(0, 1)
     # 1, 6, 10
     self.path = list_of_paths1[1]
     self.edges = graph.edges
     self.sa = SpectrumAllocator(graph)
    def setUpClass(cls):
        logging.basicConfig(level=logging.INFO)
        parser = Parser('../test_data', 'euro16_k2.txt')
        # 40.dem, 10.dea, 31.rep
        cls.parser = parser.get_scenario(261)
        networkTopology = cls.parser.networkTopology
        cls.graph = graph_factory(networkTopology)
        cls.candidate_path_fetcher = CandidatePathsFetcher(cls.parser.candidatePaths,
                                                           networkTopology.n_nodes,
                                                           cls.parser.pathsLengths)
        cls.demand_factory = DemandsFactory(cls.candidate_path_fetcher)

        cls.unicast_demands = cls.demand_factory.get_unicast_demands(cls.parser.unicastDemands)
        cls.anycast_demands = cls.demand_factory.get_anycast_demands(cls.parser.anycastDemands, cls.parser.dataCenters)
 def setUpClass(cls):
     logging.basicConfig(level=logging.INFO)
     parser = Parser('../test_data', 'euro16_k2.txt')
     parser = parser.get_scenario(0)
     cls.networkTopology = parser.networkTopology
     cls.graph = graph_factory(cls.networkTopology)
    def cool_temperature(self):
        self.temperature *= 1 - self.cooling_rate

    def is_not_cold(self):
        return self.temperature > self.minimal_temperature


if __name__ == "__main__":
    from parser.parser import Parser
    from graph.graph import graph_factory
    from graph.path import CandidatePathsFetcher
    from demand.demand import DemandsFactory
    logging.basicConfig(level=logging.INFO)
    test_parser = Parser('../test/test_data', 'euro16_k2.txt')
    scenario = test_parser.get_scenario(100)
    graph = graph_factory(scenario.networkTopology)
    candidate_path_fetcher = CandidatePathsFetcher(scenario.candidatePaths,
                                                   scenario.networkTopology.n_nodes,
                                                   scenario.pathsLengths)
    demand_factory = DemandsFactory(candidate_path_fetcher)
    sa = SimulatedAnnealing()
    uni_demands = demand_factory.get_unicast_demands(scenario.unicastDemands)
    any_demands = demand_factory.get_anycast_demands(scenario.anycastDemands, scenario.dataCenters)
    demands = uni_demands + any_demands
    sa.run(graph, demands)
    print sa.best_energy
    # for demand in sa.best_solution:
    #     if isinstance(demand, UnicastDemand):
    #         print demand.get_selected_path()
    #     elif isinstance(demand, AnycastDemand):
    #         print demand.get_selected_path_up()