build_model.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Imports\n",
    "from buildingmotif import BuildingMOTIF\n",
    "from rdflib import Namespace, Literal\n",
    "from buildingmotif.dataclasses import Model\n",
    "from buildingmotif.dataclasses import Library\n",
    "from buildingmotif.namespaces import BRICK, REF\n",
    "import csv\n",
    "import json\n",
    "import os"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Binding namespaces and initializing model\n",
    "VLTT = Namespace('https://www.doesntexist.org/volttronsemantics#')\n",
    "BLDG = Namespace('urn:bldg/')\n",
    "bm = BuildingMOTIF(\"sqlite://\") # in-memory instance\n",
    "model = Model.create(BLDG, description=\"Test Model\") \n",
    "model.graph.bind(\"vltt\", VLTT)\n",
    "model.graph.bind(\"ref\", REF)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2023-03-12 23:18:43,432 | root |  WARNING: Warning: could not find dependee http://data.ashrae.org/bacnet/2020#BACnetDevice\n",
      "2023-03-12 23:18:43,433 | root |  WARNING: Warning: could not find dependee https://brickschema.org/schema/Brick/ref#ifcProject\n"
     ]
    }
   ],
   "source": [
    "# getting libraries and templates\n",
    "brick = Library.load(ontology_graph=\"../BuildingMOTIF/libraries/brick/Brick-full.ttl\")\n",
    "lib = Library.load(directory=\"vltt-templates\")\n",
    "topic_name = lib.get_template_by_name(\"volttron-topic\")\n",
    "point_list = lib.get_template_by_name(\"volttron-point-list\")\n",
    "device_config = lib.get_template_by_name(\"volttron-device-config\")\n",
    "bacnet_lib = Library.load(directory='../BuildingMOTIF/libraries/bacnet')\n",
    "bacnet_point_template = bacnet_lib.get_template_by_name(\"brick-point\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [],
   "source": [
    "bacnet_device_template = bacnet_lib.get_template_by_name('brick-device')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [],
   "source": [
    "#read csv files and create list of dicts\n",
    "def read_csv(path):\n",
    "    line = 0\n",
    "    contents = []\n",
    "    with open(path, 'r') as csv_file:\n",
    "        csv_reader = csv.DictReader(csv_file)\n",
    "        for row in csv_reader:\n",
    "            contents.append(row)\n",
    "        return contents\n",
    "\n",
    "# get templates using list of dictionaries from read_csv\n",
    "def get_templates(dct_list, key):\n",
    "    templates = {}\n",
    "    type_set = {item[key] for item in dct_list}\n",
    "    for type in type_set:\n",
    "        templates[type] = brick.get_template_by_name(BRICK[type])\n",
    "    return templates\n",
    "\n",
    "# add points given an item dictionary from the entity table\n",
    "def add_points(item, filepath, model):\n",
    "    points = read_csv(filepath)\n",
    "    templates = get_templates(points, 'Brick Type')\n",
    "    name = item.get('URI')\n",
    "\n",
    "    for point in points:\n",
    "        type = point.get('Brick Type')\n",
    "        point_name = name + '.' + point.get('Point Name')\n",
    "        topic= item.get('base_topic') + '/' + point.get('Point Name')\n",
    "        # print(point_name)\n",
    "        model.add_graph(\n",
    "            templates[type].evaluate(\n",
    "                {\n",
    "                    \"name\":BLDG[point_name]\n",
    "                }\n",
    "            )\n",
    "        )\n",
    "        model.add_graph(\n",
    "            topic_name.evaluate(\n",
    "                {\n",
    "                    \"name\":BLDG[point_name + '.' + 'topic'],\n",
    "                    \"topic\":Literal(topic)\n",
    "                }\n",
    "            )\n",
    "        )\n",
    "        model.graph.add((BLDG[item['URI']], BRICK.hasPoint, BLDG[point_name]))\n",
    "        model.graph.add((BLDG[point_name], REF['hasExternalReference'], BLDG[point_name + '.topic']))\n",
    "\n",
    "def add_brick_relations(filepath, model):\n",
    "    triples = read_csv(filepath)\n",
    "    for triple in triples:\n",
    "        model.graph.add((BLDG[triple['subjectURI']], BRICK[triple['relation']], BLDG[triple['objectURI']]))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# For examples/IoT"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [],
   "source": [
    "entity_table_path  = 'examples/IoT_site/entity_table.csv'\n",
    "relation_table_path = 'examples/IoT_site/entity_relations.csv'\n",
    "point_list_dir = 'examples/IoT_site/volttron_configs'\n",
    "contents = read_csv(entity_table_path)\n",
    "templates = get_templates(contents, 'type')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Instantiate templates and add to model\n",
    "for item in contents:\n",
    "    type = item.get('type')\n",
    "    name = item.get('URI')\n",
    "    # print(name)\n",
    "\n",
    "    model.add_graph(\n",
    "        templates[type].evaluate(\n",
    "            {\n",
    "                \"name\":BLDG[name]\n",
    "            }\n",
    "        )\n",
    "    )\n",
    "\n",
    "    if item.get('point_list', None):\n",
    "        model.add_graph(\n",
    "            point_list.evaluate(\n",
    "                {\n",
    "                    \"name\":BLDG[name+\".point_list\"],\n",
    "                    \"config-path\": Literal(item.get('point_list'))\n",
    "                }\n",
    "            )\n",
    "        )\n",
    "        model.graph.add((BLDG[name], REF['hasExternalReference'], BLDG[name+\".point_list\"]))\n",
    "\n",
    "        add_points(item, os.path.join(point_list_dir,item.get('point_list')), model)\n",
    "\n",
    "    if item.get('config', None):\n",
    "        model.add_graph(\n",
    "            device_config.evaluate(\n",
    "                {\n",
    "                    \"name\":BLDG[name+\".config\"],\n",
    "                    \"config-path\": Literal(item.get('config'))\n",
    "                }\n",
    "            )\n",
    "        )\n",
    "        model.graph.add((BLDG[name], REF['hasExternalReference'], BLDG[name+\".config\"]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [],
   "source": [
    "add_brick_relations(relation_table_path, model)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<84e174f6-3aa0-4b02-9085-9e44ea5aa339> a rdfg:Graph;rdflib:storage [a rdflib:Store;rdfs:label 'SQLAlchemy'].\n"
     ]
    }
   ],
   "source": [
    "print(model.graph.serialize('IoT_model.ttl'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# For BACnet (BOPtest) example"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Creating model using volttron topics"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "rdflib.namespace.Namespace"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model_bacnet.graph.bind('bacnet', Namespace('http://data.ashrae.org/bacnet/2020#'))\n",
    "model_bacnet.graph.bind('brick', BRICK)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "model_bacnet = Model.create(BLDG, description=\"Test BACnet Model\") \n",
    "model_bacnet.graph.bind(\"vltt\", VLTT)\n",
    "model_bacnet.graph.bind(\"ref\", REF)\n",
    "model_bacnet.graph.bind('bacnet', Namespace('http://data.ashrae.org/bacnet/2020#'))\n",
    "model_bacnet.graph.bind('brick', BRICK)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [],
   "source": [
    "entity_table_path  = 'examples/BACnet/entity_table.csv'\n",
    "relation_table_path = 'examples/BACnet/'\n",
    "point_list_dir = 'examples/BACnet/'\n",
    "contents = read_csv(entity_table_path)\n",
    "templates = get_templates(contents, 'type')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Instantiate templates and add to model_bacnet\n",
    "for item in contents:\n",
    "    type = item.get('type')\n",
    "    name = item.get('URI')\n",
    "    # print(name)\n",
    "\n",
    "    model_bacnet.add_graph(\n",
    "        templates[type].evaluate(\n",
    "            {\n",
    "                \"name\":BLDG[name]\n",
    "            }\n",
    "        )\n",
    "    )\n",
    "\n",
    "    if item.get('point_list', None):\n",
    "        model_bacnet.add_graph(\n",
    "            point_list.evaluate(\n",
    "                {\n",
    "                    \"name\":BLDG[name+\".point_list\"],\n",
    "                    \"config-path\": Literal(item.get('point_list'))\n",
    "                }\n",
    "            )\n",
    "        )\n",
    "        model_bacnet.graph.add((BLDG[name], REF['hasExternalReference'], BLDG[name+\".point_list\"]))\n",
    "\n",
    "        add_points(item, os.path.join(point_list_dir,item.get('point_list')), model_bacnet)\n",
    "\n",
    "    if item.get('config', None):\n",
    "        model_bacnet.add_graph(\n",
    "            device_config.evaluate(\n",
    "                {\n",
    "                    \"name\":BLDG[name+\".config\"],\n",
    "                    \"config-path\": Literal(item.get('config'))\n",
    "                }\n",
    "            )\n",
    "        )\n",
    "        model_bacnet.graph.add((BLDG[name], REF['hasExternalReference'], BLDG[name+\".config\"]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "@prefix brick: <https://brickschema.org/schema/Brick#> .\n",
      "@prefix owl: <http://www.w3.org/2002/07/owl#> .\n",
      "@prefix ref: <https://brickschema.org/schema/Brick/ref#> .\n",
      "@prefix vltt: <https://www.doesntexist.org/volttronsemantics#> .\n",
      "\n",
      "<urn:bldg/> a owl:Ontology .\n",
      "\n",
      "<urn:bldg/building> a brick:Building .\n",
      "\n",
      "<urn:bldg/hvacZone> a brick:Zone ;\n",
      "    brick:hasPoint <urn:bldg/hvacZone.ahu_reaFloSupAir_y_bacnet>,\n",
      "        <urn:bldg/hvacZone.ahu_reaPFanRet_y_bacnet>,\n",
      "        <urn:bldg/hvacZone.ahu_reaPFanSup_y_bacnet>,\n",
      "        <urn:bldg/hvacZone.ahu_reaTRetAir_y_bacnet>,\n",
      "        <urn:bldg/hvacZone.oveTZonSet_u_bacnet>,\n",
      "        <urn:bldg/hvacZone.reaCO2Zon_y_bacnet>,\n",
      "        <urn:bldg/hvacZone.reaPEle_y_bacnet>,\n",
      "        <urn:bldg/hvacZone.reaPPum_y_bacnet>,\n",
      "        <urn:bldg/hvacZone.reaQHea_y_bacnet>,\n",
      "        <urn:bldg/hvacZone.reaTZon_y_bacnet> ;\n",
      "    ref:hasExternalReference <urn:bldg/hvacZone.config>,\n",
      "        <urn:bldg/hvacZone.point_list> .\n",
      "\n",
      "<urn:bldg/hvacZone.ahu_reaFloSupAir_y_bacnet.topic> a vltt:VolttronTopic ;\n",
      "    vltt:hasTopicName \"BOPTest/singlezone_commercial_hvac/ahu_reaFloSupAir_y_bacnet\" .\n",
      "\n",
      "<urn:bldg/hvacZone.ahu_reaPFanRet_y_bacnet.topic> a vltt:VolttronTopic ;\n",
      "    vltt:hasTopicName \"BOPTest/singlezone_commercial_hvac/ahu_reaPFanRet_y_bacnet\" .\n",
      "\n",
      "<urn:bldg/hvacZone.ahu_reaPFanSup_y_bacnet.topic> a vltt:VolttronTopic ;\n",
      "    vltt:hasTopicName \"BOPTest/singlezone_commercial_hvac/ahu_reaPFanSup_y_bacnet\" .\n",
      "\n",
      "<urn:bldg/hvacZone.ahu_reaTRetAir_y_bacnet.topic> a vltt:VolttronTopic ;\n",
      "    vltt:hasTopicName \"BOPTest/singlezone_commercial_hvac/ahu_reaTRetAir_y_bacnet\" .\n",
      "\n",
      "<urn:bldg/hvacZone.oveTZonSet_u_bacnet.topic> a vltt:VolttronTopic ;\n",
      "    vltt:hasTopicName \"BOPTest/singlezone_commercial_hvac/oveTZonSet_u_bacnet\" .\n",
      "\n",
      "<urn:bldg/hvacZone.reaCO2Zon_y_bacnet.topic> a vltt:VolttronTopic ;\n",
      "    vltt:hasTopicName \"BOPTest/singlezone_commercial_hvac/reaCO2Zon_y_bacnet\" .\n",
      "\n",
      "<urn:bldg/hvacZone.reaPEle_y_bacnet.topic> a vltt:VolttronTopic ;\n",
      "    vltt:hasTopicName \"BOPTest/singlezone_commercial_hvac/reaPEle_y_bacnet\" .\n",
      "\n",
      "<urn:bldg/hvacZone.reaPPum_y_bacnet.topic> a vltt:VolttronTopic ;\n",
      "    vltt:hasTopicName \"BOPTest/singlezone_commercial_hvac/reaPPum_y_bacnet\" .\n",
      "\n",
      "<urn:bldg/hvacZone.reaQHea_y_bacnet.topic> a vltt:VolttronTopic ;\n",
      "    vltt:hasTopicName \"BOPTest/singlezone_commercial_hvac/reaQHea_y_bacnet\" .\n",
      "\n",
      "<urn:bldg/hvacZone.reaTZon_y_bacnet.topic> a vltt:VolttronTopic ;\n",
      "    vltt:hasTopicName \"BOPTest/singlezone_commercial_hvac/reaTZon_y_bacnet\" .\n",
      "\n",
      "<urn:bldg/space> a brick:Space .\n",
      "\n",
      "<urn:bldg/hvacZone.ahu_reaFloSupAir_y_bacnet> a brick:Supply_Air_Flow_Sensor .\n",
      "\n",
      "<urn:bldg/hvacZone.ahu_reaPFanRet_y_bacnet> a brick:Electric_Power_Sensor .\n",
      "\n",
      "<urn:bldg/hvacZone.ahu_reaPFanSup_y_bacnet> a brick:Electric_Power_Sensor .\n",
      "\n",
      "<urn:bldg/hvacZone.ahu_reaTRetAir_y_bacnet> a brick:Return_Air_Temperature_Sensor .\n",
      "\n",
      "<urn:bldg/hvacZone.config> a vltt:VolttronDeviceConfig ;\n",
      "    vltt:hasPath \"examples/BACnet/bacnet.config\" .\n",
      "\n",
      "<urn:bldg/hvacZone.oveTZonSet_u_bacnet> a brick:Zone_Air_Heating_Temperature_Setpoint,\n",
      "        brick:Zone_Air_Temperature_Setpoint .\n",
      "\n",
      "<urn:bldg/hvacZone.point_list> a vltt:VolttronPointList ;\n",
      "    vltt:hasPath \"point_list.csv\" .\n",
      "\n",
      "<urn:bldg/hvacZone.reaCO2Zon_y_bacnet> a brick:CO2_Level_Sensor .\n",
      "\n",
      "<urn:bldg/hvacZone.reaPEle_y_bacnet> a brick:Electric_Power_Sensor .\n",
      "\n",
      "<urn:bldg/hvacZone.reaPPum_y_bacnet> a brick:Electric_Power_Sensor .\n",
      "\n",
      "<urn:bldg/hvacZone.reaQHea_y_bacnet> a brick:Thermal_Power_Sensor .\n",
      "\n",
      "<urn:bldg/hvacZone.reaTZon_y_bacnet> a brick:Zone_Air_Temperature_Sensor .\n",
      "\n",
      "\n"
     ]
    }
   ],
   "source": [
    "model_bacnet.graph.print()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## adding information using ref schema BACnetReference"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [],
   "source": [
    "# add BACnet information to graph\n",
    "def create_BACnet_device(config_file, device_name, model):\n",
    "    with open(config_file,'r') as f:\n",
    "        config = json.load(f)\n",
    "    inputs = {\n",
    "        'address': Literal(config.get('driver_config').get('device_address')),\n",
    "        'instance-number': Literal(config.get('driver_config').get('device_id')),\n",
    "        'name': BLDG[device_name + '.bacnet.device']\n",
    "    }\n",
    "    model.add_graph(\n",
    "        bacnet_device_template.evaluate(inputs)\n",
    "    )\n",
    "    \n",
    "def add_BACnet_refs(item, filepath, device_name, model):\n",
    "    points = read_csv(filepath)\n",
    "    name = item.get('URI')\n",
    "\n",
    "    for point in points:\n",
    "        bacnet_point_name = name + '.' + point.get('Point Name')\n",
    "        inputs = {\n",
    "            'name': BLDG[bacnet_point_name],\n",
    "            'identifier': Literal(point.get('BACnetObjectType')),\n",
    "            'obj-name': Literal(point.get('BACnetPointName')),\n",
    "            'units': Literal(point.get('Units')),\n",
    "            'device': BLDG[device_name + '.bacnet.device']\n",
    "        }\n",
    "            # print(point_name)\n",
    "        model.add_graph(\n",
    "            bacnet_point_template.evaluate(inputs)\n",
    "            )\n",
    "        \n",
    "        model.graph.add((BLDG[point.get('Point Name')], REF['hasExternalReference'], BLDG[bacnet_point_name]))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "examples/BACnet/point_list.csv\n"
     ]
    }
   ],
   "source": [
    "bacnet_file_path = 'examples/BACnet/bacnet.config'\n",
    "for item in contents:\n",
    "    if item.get('config') == bacnet_file_path:\n",
    "        device_name = item.get('URI')\n",
    "        create_BACnet_device(bacnet_file_path, device_name, model_bacnet)\n",
    "        print(os.path.join(point_list_dir,item.get('point_list')))\n",
    "        add_BACnet_refs(item, os.path.join(point_list_dir,item.get('point_list')), device_name, model_bacnet)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<Graph identifier=f627445a-a45e-4038-933d-740d891c64dc (<class 'rdflib.graph.Graph'>)>"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model_bacnet.graph.serialize('bacnet_model.ttl')"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "base",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.3"
  },
  "vscode": {
   "interpreter": {
    "hash": "4256a7c48e0d05b8c5d9035f2da9ccd67848a8ce35912b30e9695a74575e054a"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}