Example #1
0
def test_cable_with_connector():
    haus = (
        simple_haus.HausCreator()
        .geschoss()
        .wall(0, 0, 40, 400)
        .wall(0, 0, 400, 40)
        .wall(360, 0, 40, 400)
        .con(0, 250, 0, 400, 0, 0)
        .room()
        .Steckdose(40, 200)
        .Steckdose(360, 200)
        .get_house()
    )
    haus2 = copy.deepcopy(haus)
    create_nodes_from_walls(haus)
    assert len(haus.nodes) == 12
    associate_objects_to_walls_and_nodes(haus)
    assert len(haus.nodes) == 12 + 3 * 2
    autogenerate_kabel(haus)
    assert len(haus.kabel) == 1
    calc_wires(haus)
    assert haus.kabel[-1].length > 7.9

    create_nodes_from_walls(haus2)
    associate_objects_to_walls_and_nodes(haus2)
    autogenerate_kabel(haus2)
    create_nodes_from_connectors(haus2)
    assert len(haus2.nodes) == 12 + 3 * 2 + 2
    calc_wires(haus2)
    assert haus2.kabel[-1].length < 7.9
Example #2
0
def test_simple_haus_kabel():
    haus = Haus()
    yaml = simple_haus.define_testcase()

    read_struktur(haus, yaml["struktur"])
    read_anschluesse(haus, yaml["anschluesse"])
    read_kabel(haus, yaml["kabel"])
    autogenerate_kabel(haus)
    create_nodes_from_walls(haus)
    create_nodes_from_connectors(haus)
    associate_objects_to_walls_and_nodes(haus)
    calc_wires(haus)
    create_roombook(haus)
    assert len(haus.kabel) == 7
    # explicit cable
    assert haus.kabel[0].start == "1.1.1"
    assert len(haus.kabel[0].end) == 3
    assert haus.kabel[0].end[0] == "2.2.3"
    assert haus.kabel[0].end[1] == "2.2.4"
    assert haus.kabel[0].end[2] == "2.2.5"
    assert haus.kabel[0].length == approx(9.4)
    # impicit definde cabels
    assert haus.kabel[1].start == "1.1.1"
    assert len(haus.kabel[1].end) == 1
    assert haus.kabel[1].end[0] == "1.1.2"
    assert haus.kabel[1].type == KabelType.NYM5x15
    assert haus.kabel[1].length == approx(3.4)

    assert haus.kabel[2].length == approx(3.6)
    assert haus.kabel[3].end[0] == "2.1.1"
    # directly above it
    assert haus.kabel[3].length == approx(2.8)
    assert haus.kabel[4].length == approx(5.6)
Example #3
0
def read_setup(yaml_file):
    with open(yaml_file, "r") as stream:
        data = yaml.safe_load(stream)
    # print("Reading Setup for {}".format(data["config"]["name"]))

    folder = os.path.dirname(os.path.abspath(yaml_file)) + "/"
    file_anschluesse = folder + data["config"]["anschluesse"]
    file_struktur = folder + data["config"]["struktur"]
    file_kabel = folder + data["config"]["kabel"]
    if not os.path.isfile(file_struktur):
        raise RuntimeError("File not found: {}".format(file_struktur))
    if not os.path.isfile(file_anschluesse):
        raise RuntimeError("File not found: {}".format(file_anschluesse))
    if not os.path.isfile(file_kabel):
        raise RuntimeError("File not found: {}".format(file_kabel))
    haus = Haus()

    # Read YAML filess
    with open(file_struktur, "r") as stream:
        yaml_struktur = yaml.safe_load(stream)
    with open(file_anschluesse, "r") as stream:
        yaml_anschluesse = yaml.safe_load(stream)
    with open(file_kabel, "r") as stream:
        yaml_kabel = yaml.safe_load(stream)

    read_struktur(haus, yaml_struktur)
    read_anschluesse(haus, yaml_anschluesse)
    read_kabel(haus, yaml_kabel)
    autogenerate_kabel(haus)

    create_nodes_from_walls(haus)
    create_nodes_from_connectors(haus)

    return haus
Example #4
0
def test_single_wall_kabel():
    haus = Haus()
    yaml = simple_haus.single_wall()

    read_struktur(haus, yaml["struktur"])
    read_anschluesse(haus, yaml["anschluesse"])
    create_nodes_from_walls(haus)
    associate_objects_to_walls_and_nodes(haus)
    autogenerate_kabel(haus, False)
    calc_wires(haus)
Example #5
0
def test_autogenerate_kabels():
    haus = Haus()
    yaml = simple_haus.define_testcase()

    yaml["anschluesse"] = {
        "geschosse": [
            {
                "id": 1,
                "name": "G1",
                "rooms": [
                    {
                        "id": 1,
                        "name": "R11",
                        "objects": [
                            {
                                "id": 1,
                                "name": "O111",
                                "con-type": "steckdose",
                                "anzahl": 1,
                                "pos": {"hori": [20, 150], "vert": "oben"},
                            },
                            {
                                "id": 2,
                                "name": "O112",
                                "con-type": "knx",
                                "knx-component": "gt",
                                "pos": {"hori": [200, 20], "vert": "oben"},
                            },
                            {
                                "id": 3,
                                "name": "O113",
                                "con-type": "knx",
                                "knx-component": "pm",
                                "pos": {"hori": [350, 20], "vert": "oben"},
                            },
                        ],
                    }
                ],
            }
        ]
    }
    yaml["kabel"] = {"kabel": []}
    read_struktur(haus, yaml["struktur"])
    read_anschluesse(haus, yaml["anschluesse"])
    read_kabel(haus, yaml["kabel"])
    autogenerate_kabel(haus, False)
    calc_wires(haus)
    create_roombook(haus)
    assert len(haus.kabel) == 2
    assert haus.kabel[0].length == approx(1.30 + 1.80)
    assert haus.kabel[1].length == approx(1.30 + 3.30)
Example #6
0
def test_autogen_kabel_with_astar_len_calc():
    haus = Haus()
    yaml = simple_haus.define_testcase()
    read_struktur(haus, yaml["struktur"])
    read_anschluesse(haus, yaml["anschluesse"])
    # read_kabel(haus,yaml["kabel"])
    autogenerate_kabel(haus)
    create_nodes_from_walls(haus)
    assert len(haus.nodes) == 8 + 16
    haus.geschosse[0].nodes[4].connect(haus.geschosse[1].nodes[0])
    associate_objects_to_walls_and_nodes(haus)

    calc_wires(haus)
    create_roombook(haus)
Example #7
0
def test_astar():
    haus = Haus()
    yaml = simple_haus.define_testcase_simple1()

    read_struktur(haus, yaml["struktur"])
    read_anschluesse(haus, yaml["anschluesse"])
    create_nodes_from_walls(haus)
    associate_objects_to_walls_and_nodes(haus)
    autogenerate_kabel(haus)

    assert len(haus.kabel) == 1

    get_kabel_objects(haus, haus.kabel[0])
    path = calc_kabel_len(haus.kabel[0])

    assert len(path) == 6

    for e in path:
        print("EDGE: {}".format(e))

    assert haus.kabel[0].length == approx(
        (40 + 240 + 2 * sqrt(10**2 + 30**2)) * 0.01)