fastsmoothbuildings 0.1.0__py3-none-any.whl

fastsmoothbuildings/__init__.py

@@ -0,0 +1,16 @@
+"""FastSmoothBuildings: the Modelica library, and where tools find it.
+
+``LIBRARY`` is the folder of the library, to pass to rumoca (``rumoca.Session(roots=[str(LIBRARY)])``: rumoca reads
+every Modelica file below a root); ``ROOT`` the folder that holds it, to put on ``MODELICAPATH``; ``bundle()`` the
+library as the text of one file, to embed it in a generated model.
+"""
+
+from __future__ import annotations
+
+from typing import Final
+
+from fastsmoothbuildings._paths import LIBRARY, NAME, ROOT, modelica_version
+from fastsmoothbuildings.bundle import bundle, strip_documentation
+
+__version__: Final = modelica_version(LIBRARY / "package.mo")
+__all__ = ["LIBRARY", "NAME", "ROOT", "__version__", "bundle", "strip_documentation"]

fastsmoothbuildings/_paths.py

@@ -0,0 +1,32 @@
+"""Where the Modelica library is: inside the installed package, or at the root of a checkout (editable install)."""
+
+from __future__ import annotations
+
+import re
+from pathlib import Path
+from typing import Final
+
+NAME: Final = "FastSmoothBuildings"
+VERSION = re.compile(r'^\s*version\s*=\s*"(?P<version>[^"]+)"', re.MULTILINE)
+
+
+def _root() -> Path:
+    package = Path(__file__).resolve().parent
+    for root in (package / "modelica", package.parents[1]):
+        if (root / NAME / "package.mo").is_file():
+            return root
+    message = f"the Modelica library {NAME} is neither in {package / 'modelica'} nor at the root of a checkout"
+    raise FileNotFoundError(message)
+
+
+def modelica_version(package: Path) -> str:
+    """The ``version`` annotation of the ``package.mo`` of a library."""
+    match = VERSION.search(package.read_text(encoding="utf-8"))
+    if match is None:
+        message = f"{package} has no version annotation"
+        raise ValueError(message)
+    return match["version"]
+
+
+ROOT: Final = _root()
+LIBRARY: Final = ROOT / NAME

fastsmoothbuildings/bundle.py

@@ -0,0 +1,150 @@
+"""Single-file text of a Modelica library stored in the directory layout of the Modelica specification (13.4)."""
+
+from __future__ import annotations
+
+import re
+from collections.abc import Sequence
+from pathlib import Path
+
+from fastsmoothbuildings._paths import LIBRARY
+
+INDENT = "  "
+WITHIN = re.compile(r"\A\s*within\b[^;]*;[ \t]*\n")
+DOCUMENTATION = re.compile(r"\bDocumentation\s*\(")
+CLASS_ANNOTATION = re.compile(rf"^{INDENT}annotation\b")
+
+
+def read_class(path: Path) -> list[str]:
+    """Lines of a class file without its ``within`` clause."""
+    return WITHIN.sub("", path.read_text(encoding="utf-8"), count=1).rstrip("\n").split("\n")
+
+
+def package_order(package: Path) -> list[str]:
+    """Names listed in ``package.order``, in their order."""
+    order = package / "package.order"
+    return order.read_text(encoding="utf-8").split() if order.is_file() else []
+
+
+def _scan(line: str, in_string: bool, in_comment: bool) -> tuple[bool, bool]:
+    """Whether the end of ``line`` is inside a string and inside a block comment."""
+    index = 0
+    while index < len(line):
+        if in_string:
+            if line[index] == "\\":
+                index += 2
+                continue
+            in_string = line[index] != '"'
+        elif in_comment:
+            in_comment = not line.startswith("*/", index)
+            index += 0 if in_comment else 1
+        elif line.startswith("//", index):
+            break
+        else:
+            in_string = line[index] == '"'
+            in_comment = line.startswith("/*", index)
+            index += 1 if in_comment else 0
+        index += 1
+    return in_string, in_comment
+
+
+def code_starts(lines: Sequence[str]) -> list[bool]:
+    """Whether each line starts outside a string and outside a block comment."""
+    starts: list[bool] = []
+    in_string = in_comment = False
+    for line in lines:
+        starts.append(not (in_string or in_comment))
+        in_string, in_comment = _scan(line, in_string, in_comment)
+    return starts
+
+
+def code_mask(text: str) -> list[bool]:
+    """Whether each character of ``text`` is code: outside strings and comments."""
+    mask = [True] * len(text)
+    index, in_string = 0, False
+    while index < len(text):
+        if in_string:
+            mask[index] = False
+            if text[index] == "\\":
+                mask[index + 1 : index + 2] = [False] * len(mask[index + 1 : index + 2])
+                index += 2
+                continue
+            in_string = text[index] != '"'
+        elif text[index] == '"':
+            mask[index], in_string = False, True
+        elif text.startswith("//", index) or text.startswith("/*", index):
+            end = text.find("\n" if text[index + 1] == "/" else "*/", index + 2)
+            end = len(text) if end < 0 else end + (0 if text[index + 1] == "/" else 2)
+            mask[index:end] = [False] * (end - index)
+            index = end
+            continue
+        index += 1
+    return mask
+
+
+def _class_annotation(body: Sequence[str]) -> int:
+    """Index of the line that opens the annotation of the class in ``body`` (its declaration and elements),
+    ``len(body)`` without one: the classes stored in files go before it, an annotation ends a class."""
+    starts = code_starts(body)
+    found = [number for number, line in enumerate(body) if starts[number] and CLASS_ANNOTATION.match(line)]
+    return found[-1] if found else len(body)
+
+
+def _indented(lines: Sequence[str], depth: int) -> list[str]:
+    return [INDENT * depth + line if line else line for line in lines]
+
+
+def _package_lines(package: Path, depth: int) -> list[str]:
+    *body, end = read_class(package / "package.mo")
+    annotation = _class_annotation(body)
+    lines = _indented(body[:annotation], depth)
+    # a blank line separates the classes, except the first one from a declaration without elements
+    separator = [""] if any(line.rstrip().endswith(";") for line in body[:annotation]) else []
+    for name in package_order(package):
+        if (package / name / "package.mo").is_file():
+            child = _package_lines(package / name, depth + 1)
+        elif (package / f"{name}.mo").is_file():
+            child = _indented(read_class(package / f"{name}.mo"), depth + 1)
+        else:
+            continue  # a constant or a short class of package.mo
+        lines += [*separator, *child]
+        separator = [""]
+    return [*lines, *_indented([*body[annotation:], end], depth)]
+
+
+def bundle(library: Path | None = None, *, documentation: bool = True) -> str:
+    """The library at ``library`` (the folder holding its ``package.mo``, FastSmoothBuildings by default) as the
+    text of one file; ``documentation=False`` leaves out the ``Documentation`` annotations."""
+    text = "\n".join(_package_lines(library or LIBRARY, 0)) + "\n"
+    return text if documentation else strip_documentation(text)
+
+
+def strip_documentation(text: str) -> str:
+    """``text`` without its ``Documentation(...)`` annotations (with the comma that joins one to the other
+    elements of its ``annotation``)."""
+    mask = code_mask(text)
+    pieces: list[str] = []
+    position = 0
+    for match in DOCUMENTATION.finditer(text):
+        if match.start() < position or not mask[match.start()]:
+            continue
+        start, end = match.start(), _closing_parenthesis(text, match.end(), mask)
+        before = text[position:start].rstrip()
+        after = text[end:].lstrip()
+        if before.endswith(","):
+            before = before[:-1]
+        elif after.startswith(","):
+            end = len(text) - len(after[1:].lstrip())
+        pieces.append(before)
+        position = end
+    pieces.append(text[position:])
+    return "".join(pieces)
+
+
+def _closing_parenthesis(text: str, start: int, mask: Sequence[bool]) -> int:
+    """Index just after the parenthesis that closes the one opened before ``start``, strings skipped."""
+    depth, index = 1, start
+    while depth:
+        if mask[index]:
+            depth += {"(": 1, ")": -1}.get(text[index], 0)
+        index += 1
+    return index

fastsmoothbuildings/modelica/FastSmoothBuildings/BoundaryConditions/TiltedSurface.mo

@@ -0,0 +1,29 @@
+within FastSmoothBuildings.BoundaryConditions;
+model TiltedSurface "Solar irradiance on a tilted surface: direct, Perez diffuse (sky and ground), incidence"
+  parameter Real azi(unit="rad") "Surface azimuth: 0 south, pi/2 west";
+  parameter Real til(unit="rad") "Surface tilt: 0 roof, pi/2 wall";
+  parameter Real rho = 0.2 "Ground reflectance";
+  Interfaces.WeatherBusIn weaBus
+    annotation (Placement(transformation(extent={{-110,-10},{-90,10}})));
+  Real cosInc "Cosine of the incidence angle";
+  Real HDir(unit="W/m2") "Direct irradiance on the surface";
+  Real HDif(unit="W/m2") "Diffuse irradiance on the surface (sky and ground)";
+protected
+  constant Real bMin = cos(85*pi/180);
+equation
+  cosInc = cos(til)*(cos(weaBus.decAng)*cos(weaBus.solHouAng)*cos(weaBus.lat) + sin(weaBus.decAng)*sin(weaBus.lat))
+    + sin(til)*(sin(azi)*cos(weaBus.decAng)*sin(weaBus.solHouAng) + cos(azi)*(cos(weaBus.decAng)
+    *cos(weaBus.solHouAng)*sin(weaBus.lat) - sin(weaBus.decAng)*cos(weaBus.lat)));
+  HDir = Utilities.positivePart(cosInc*weaBus.HDirNor, 1e-2);
+  HDif = weaBus.HDifHor*(0.5*(1 - weaBus.F1)*(1 + cos(til)) + weaBus.F1*Utilities.smoothMax(0, cosInc, 0.01)
+    /Utilities.smoothMax(bMin, weaBus.cosZen, 0.01) + weaBus.F2*sin(til)) + weaBus.HGloHor*0.5*rho*(1 - cos(til));
+  annotation (Icon(coordinateSystem(preserveAspectRatio=false, extent={{-100,-100},{100,100}}), graphics={
+      Rectangle(extent={{-100,100},{100,-100}}, lineColor={0,0,0}, fillColor={255,255,255},
+        fillPattern=FillPattern.Solid),
+      Ellipse(extent={{-80,80},{-20,20}}, lineColor={255,220,220}, fillColor={255,255,0},
+        fillPattern=FillPattern.Sphere),
+      Polygon(points={{-20,-80},{80,20},{80,-80},{-20,-80}}, lineColor={0,0,0}, fillColor={175,175,175},
+        fillPattern=FillPattern.Solid),
+      Line(points={{-30,30},{30,-30}}, color={255,128,0}, arrow={Arrow.None,Arrow.Filled}),
+      Text(extent={{-150,150},{150,110}}, textColor={0,0,255}, textString="%name")}));
+end TiltedSurface;

fastsmoothbuildings/modelica/FastSmoothBuildings/BoundaryConditions/Weather.mo

@@ -0,0 +1,99 @@
+within FastSmoothBuildings.BoundaryConditions;
+model Weather "Weather data, solar position and Perez coefficients for the site"
+  parameter Real lat(unit="rad") = 0.8868 "Latitude (Uccle by default)";
+  parameter Real lon(unit="rad") = 0.0760 "Longitude (Uccle by default)";
+  parameter Real timZon(unit="s") = 3600 "Time zone (offset of the standard time from UTC)";
+  parameter Real alt(unit="m") = 100 "Altitude of the site";
+  parameter Real pAtm(unit="Pa") = 101325
+    "Atmospheric pressure, constant (Buildings' default; the runnable model takes the pressure of the site's
+     altitude when the YAML reads the pressure from the weather file)";
+  Interfaces.RealInput TDryBul(unit="K") "Outdoor dry-bulb air temperature"
+    annotation (Placement(transformation(extent={{-120,60},{-100,80}})));
+  Interfaces.RealInput TBlaSky(unit="K") "Black-body sky temperature"
+    annotation (Placement(transformation(extent={{-120,40},{-100,60}})));
+  Interfaces.RealInput winSpe(unit="m/s") "Wind speed"
+    annotation (Placement(transformation(extent={{-120,20},{-100,40}})));
+  Interfaces.RealInput winDir(unit="rad") "Wind direction, 0 from the north"
+    annotation (Placement(transformation(extent={{-120,0},{-100,20}})));
+  Interfaces.RealInput HDirNor(unit="W/m2") "Direct normal irradiance"
+    annotation (Placement(transformation(extent={{-120,-20},{-100,0}})));
+  Interfaces.RealInput HDifHor(unit="W/m2") "Diffuse horizontal irradiance"
+    annotation (Placement(transformation(extent={{-120,-40},{-100,-20}})));
+  Interfaces.RealInput HGloHor(unit="W/m2") "Global horizontal irradiance"
+    annotation (Placement(transformation(extent={{-120,-60},{-100,-40}})));
+  Interfaces.WeatherBus weaBus "Weather data and solar position"
+    annotation (Placement(transformation(extent={{90,-10},{110,10}})));
+protected
+  Real Bt "Intermediate variable of the equation of time";
+  Real eqnTim(unit="s") "Equation of time";
+  Real solTim(unit="s") "Solar time";
+  Real zen(unit="rad") "Solar zenith angle";
+  Real zenLim(unit="rad") "Zenith angle bounded by 90 degrees";
+  Real relAirMas "Relative air mass";
+  Real skyBri "Sky brightness";
+  Real HDifHorBou(unit="W/m2") "Diffuse horizontal irradiance bounded away from 0";
+  Real tmp "Intermediate variable of the sky clearness";
+  Real skyCle "Sky clearness";
+  Real a[8] "Weights of the sky clearness bins";
+  Real b[8] "Smooth steps of the sky clearness bins";
+  constant Real edges[7] = {1.065, 1.23, 1.50, 1.95, 2.80, 4.50, 6.20} "Sky clearness bin edges";
+  constant Real F11[8] = {-0.0083117, 0.1299457, 0.3296958, 0.5682053, 0.8730280, 1.1326077, 1.0601591, 0.6777470};
+  constant Real F12[8] = {0.5877285, 0.6825954, 0.4868735, 0.1874525, -0.3920403, -1.2367284, -1.5999137, -0.3272588};
+  constant Real F13[8] = {-0.0620636, -0.1513725, -0.2210958, -0.2951290, -0.3616149, -0.4118494, -0.3589221, -0.2504286};
+  constant Real F21[8] = {-0.0596012, -0.0189325, 0.0554140, 0.1088631, 0.2255647, 0.2877813, 0.2642124, 0.1561313};
+  constant Real F22[8] = {0.0721249, 0.0659650, -0.0639588, -0.1519229, -0.4620442, -0.8230357, -1.1272340, -1.3765031};
+  constant Real F23[8] = {-0.0220216, -0.0288748, -0.0260542, -0.0139754, 0.0012448, 0.0558651, 0.1310694, 0.2506212};
+equation
+  // Weather data
+  weaBus.TDryBul = TDryBul;
+  weaBus.TBlaSky = TBlaSky;
+  weaBus.winSpe = winSpe;
+  weaBus.winDir = winDir;
+  weaBus.HDirNor = HDirNor;
+  weaBus.HDifHor = HDifHor;
+  weaBus.HGloHor = HGloHor;
+  weaBus.pAtm = pAtm;
+  weaBus.lat = lat;
+  // Solar position (Buildings.BoundaryConditions.SolarGeometry; the model time is the clock time of the year)
+  weaBus.decAng = asin(-sin(23.45*pi/180)*cos((time/86400 + 10)*2*pi/365.25));
+  Bt = pi*((time + 86400)/86400 - 81)/182;
+  eqnTim = 60*(9.87*sin(2*Bt) - 7.53*cos(Bt) - 1.5*sin(Bt));
+  solTim = time - timZon + lon*43200/pi + eqnTim;
+  weaBus.solHouAng = (solTim/3600 - 12)*2*pi/24;
+  weaBus.cosZen = cos(lat)*cos(weaBus.decAng)*cos(weaBus.solHouAng) + sin(lat)*sin(weaBus.decAng);
+  zen = acos(Utilities.smoothLimitInside(weaBus.cosZen, -1, 1, 1e-6));
+  // Perez sky model (Buildings.BoundaryConditions.SolarIrradiation.BaseClasses)
+  zenLim = Utilities.smoothMin(zen, pi/2, 0.01);
+  relAirMas = exp(-0.0001184*alt)/(cos(zenLim) + 0.15*(93.9 - zenLim*180/pi)^(-1.253));
+  skyBri = Utilities.smoothMin(HDifHor*relAirMas/(1366.1*(1 + 0.033*cos(2*pi*(solTim/86400 + 1)/365))), 1, 0.025);
+  HDifHorBou = Utilities.smoothMax(HDifHor, 0.5e-4, 0.25e-4);
+  tmp = 5.534e-6*(180/pi)^3*zen^3;
+  skyCle = Utilities.smoothLimitInside(((HDirNor + HDifHorBou)/HDifHorBou + tmp)/(1 + tmp), 1, 8, 0.01);
+  for i in 1:7 loop
+    b[i] = Utilities.regStep(edges[i] - skyCle, 1, 0, 0.01);
+  end for;
+  b[8] = Utilities.regStep(skyCle - edges[7], 1, 0, 0.01);
+  a[1] = b[1];
+  for i in 2:7 loop
+    a[i] = b[i] - b[i - 1];
+  end for;
+  a[8] = b[8];
+  weaBus.F1 = Utilities.smoothMax(0, sum(a[i]*(F11[i] + F12[i]*skyBri + F13[i]*zen) for i in 1:8), 0.01);
+  weaBus.F2 = sum(a[i]*(F21[i] + F22[i]*skyBri + F23[i]*zen) for i in 1:8);
+  annotation (Icon(coordinateSystem(preserveAspectRatio=false, extent={{-100,-100},{100,100}}), graphics={
+      Rectangle(extent={{-100,100},{100,-100}}, lineColor={124,142,255}, fillColor={124,142,255},
+        fillPattern=FillPattern.Solid),
+      Ellipse(extent={{-73,77},{14,-10}}, lineColor={255,220,220}, lineThickness=1,
+        fillPattern=FillPattern.Sphere, fillColor={255,255,0}),
+      Polygon(points={{47,53}, {39,21}, {55,26}, {69,25}, {82,19}, {91,-14}, {69,-51}, {5,-55}, {-70,-53},
+        {-83,-15}, {-75,12}, {-51,13}, {-39,4}, {-46,35}, {-29,60}, {17,70}, {47,53}}, lineColor={220,220,220},
+        lineThickness=0.1, fillPattern=FillPattern.Sphere, smooth=Smooth.Bezier, fillColor={230,230,230}),
+      Text(extent={{-98,78},{-60,62}}, textColor={0,0,0}, textString="TDryBul"),
+      Text(extent={{-98,58},{-60,42}}, textColor={0,0,0}, textString="TBlaSky"),
+      Text(extent={{-98,38},{-60,22}}, textColor={0,0,0}, textString="winSpe"),
+      Text(extent={{-98,18},{-60,2}}, textColor={0,0,0}, textString="winDir"),
+      Text(extent={{-98,-2},{-60,-18}}, textColor={0,0,0}, textString="HDirNor"),
+      Text(extent={{-98,-22},{-60,-38}}, textColor={0,0,0}, textString="HDifHor"),
+      Text(extent={{-98,-42},{-60,-58}}, textColor={0,0,0}, textString="HGloHor"),
+      Text(extent={{-150,140},{150,100}}, textColor={0,0,255}, textString="%name")}));
+end Weather;

fastsmoothbuildings/modelica/FastSmoothBuildings/BoundaryConditions/package.mo

@@ -0,0 +1,8 @@
+within FastSmoothBuildings;
+package BoundaryConditions "Weather and solar irradiance (after Buildings.BoundaryConditions)"
+  annotation (Documentation(info="<html>
+<p>
+Weather data and solar irradiance after Buildings.BoundaryConditions: the weather inputs of a model, the solar position, the Perez sky model and the irradiance on tilted surfaces, without the events of a weather file reader.
+</p>
+</html>"));
+end BoundaryConditions;

fastsmoothbuildings/modelica/FastSmoothBuildings/BoundaryConditions/package.order

@@ -0,0 +1,2 @@
+Weather
+TiltedSurface

fastsmoothbuildings/modelica/FastSmoothBuildings/Controls/BoilerDemand.mo

@@ -0,0 +1,19 @@
+within FastSmoothBuildings.Controls;
+model BoilerDemand
+  "Demand of a production (trano BoilerControl, variant simple): on when a valve of its circuits opens beyond 0.5,
+   off when all are below 0.01"
+  parameter Integer n = 1 "Number of circuits";
+  parameter Real dMax = 1e-3 "Width of the smooth maximum of the openings";
+  Interfaces.RealInput yMax[n] "Largest opening of the valves of each circuit"
+    annotation (Placement(transformation(extent={{-140,-20},{-100,20}})));
+  Hysteresis hys(uLow=0.01, uHigh=0.5, u=smoothMaxN(yMax, dMax));
+  Interfaces.RealOutput y(unit="1") "Demand"
+    annotation (Placement(transformation(extent={{100,-20},{140,20}})));
+equation
+  y = hys.y;
+  annotation (Icon(coordinateSystem(preserveAspectRatio=false, extent={{-100,-100},{100,100}}), graphics={
+      Rectangle(extent={{-100,-100},{100,100}}, lineColor={0,0,127}, fillColor={255,255,255},
+        fillPattern=FillPattern.Solid),
+      Text(extent={{-90,40},{90,-40}}, textColor={0,0,0}, textString="demand"),
+      Text(extent={{-150,150},{150,110}}, textColor={0,0,255}, textString="%name")}));
+end BoilerDemand;

fastsmoothbuildings/modelica/FastSmoothBuildings/Controls/BoilerTemperatureControl.mo

@@ -0,0 +1,21 @@
+within FastSmoothBuildings.Controls;
+model BoilerTemperatureControl
+  "Firing of a boiler without storage (trano Buildings boiler): P controller (k) on the boiler temperature, while
+   there is demand"
+  parameter Real TempSet(unit="K") = 353.15 "Boiler temperature set point";
+  parameter Real k = 1 "Gain";
+  parameter Real dY = 1e-3 "Width of the smooth limits of the part load";
+  Interfaces.RealInput T(unit="K") "Boiler water temperature"
+    annotation (Placement(transformation(extent={{-140,40},{-100,80}})));
+  Interfaces.RealInput demand "Demand, 0 or 1"
+    annotation (Placement(transformation(extent={{-140,-80},{-100,-40}})));
+  Interfaces.RealOutput y(unit="1") "Part load ratio"
+    annotation (Placement(transformation(extent={{100,-20},{140,20}})));
+equation
+  y = demand*Utilities.smoothLimit(k*(TempSet - T), 0, 1, dY);
+  annotation (Icon(coordinateSystem(preserveAspectRatio=false, extent={{-100,-100},{100,100}}), graphics={
+      Rectangle(extent={{-100,-100},{100,100}}, lineColor={0,0,127}, fillColor={255,255,255},
+        fillPattern=FillPattern.Solid),
+      Text(extent={{-90,40},{90,-40}}, textColor={0,0,0}, textString="boiler"),
+      Text(extent={{-150,150},{150,110}}, textColor={0,0,255}, textString="%name")}));
+end BoilerTemperatureControl;

fastsmoothbuildings/modelica/FastSmoothBuildings/Controls/CollectorControl.mo

@@ -0,0 +1,26 @@
+within FastSmoothBuildings.Controls;
+model CollectorControl
+  "Collector control of a pump (trano CollectorControl): on when a valve opens beyond 0.5, off when all are
+   below 0.01, the speed from a P controller holding the head at dp_nominal"
+  parameter Integer nVal = 1 "Number of valves";
+  parameter Real k = 1 "Gain";
+  parameter Real dY = 1e-3 "Width of the smooth limits of the speed";
+  parameter Real dMax = 1e-3 "Width of the smooth maximum of the openings";
+  Interfaces.RealInput yVal[nVal] "Openings of the valves of the circuit"
+    annotation (Placement(transformation(extent={{-140,40},{-100,80}})));
+  Interfaces.RealInput dpRel "Head of the pump relative to its nominal head"
+    annotation (Placement(transformation(extent={{-140,-80},{-100,-40}})));
+  Interfaces.RealOutput yMax "Largest opening (the boiler control reads it)"
+    annotation (Placement(transformation(extent={{100,40},{140,80}})));
+  Hysteresis hysPum(uLow=0.01, uHigh=0.5, u=yMax);
+  Interfaces.RealOutput y(unit="1") "Speed of the pump"
+    annotation (Placement(transformation(extent={{100,-20},{140,20}})));
+equation
+  yMax = smoothMaxN(yVal, dMax);
+  y = Utilities.smoothLimit(k*(hysPum.y - dpRel), 0, 1, dY);
+  annotation (Icon(coordinateSystem(preserveAspectRatio=false, extent={{-100,-100},{100,100}}), graphics={
+      Rectangle(extent={{-100,-100},{100,100}}, lineColor={0,0,127}, fillColor={255,255,255},
+        fillPattern=FillPattern.Solid),
+      Text(extent={{-90,40},{90,-40}}, textColor={0,0,0}, textString="collector"),
+      Text(extent={{-150,150},{150,110}}, textColor={0,0,255}, textString="%name")}));
+end CollectorControl;

fastsmoothbuildings/modelica/FastSmoothBuildings/Controls/EmissionMonitored.mo

@@ -0,0 +1,20 @@
+within FastSmoothBuildings.Controls;
+model EmissionMonitored
+  "Variant MonitoredSetpoint: P controller (IDEAS LimPID) between 0 and 1 towards a set point read from external
+   data"
+  parameter Real k = 1 "Gain";
+  parameter Real dY = 1e-3 "Width of the smooth limits of the output";
+  Interfaces.RealInput TSet(unit="K") "Set point"
+    annotation (Placement(transformation(extent={{-140,40},{-100,80}})));
+  Interfaces.RealInput TZon(unit="K") "Zone air temperature"
+    annotation (Placement(transformation(extent={{-140,-80},{-100,-40}})));
+  Interfaces.RealOutput y(unit="1") "Valve opening, or share of the power of an ideal emitter"
+    annotation (Placement(transformation(extent={{100,-20},{140,20}})));
+equation
+  y = Utilities.smoothLimit(k*(TSet - TZon), 0, 1, dY);
+  annotation (Icon(coordinateSystem(preserveAspectRatio=false, extent={{-100,-100},{100,100}}), graphics={
+      Rectangle(extent={{-100,-100},{100,100}}, lineColor={0,0,127}, fillColor={255,255,255},
+        fillPattern=FillPattern.Solid),
+      Text(extent={{-90,40},{90,-40}}, textColor={0,0,0}, textString="P"),
+      Text(extent={{-150,150},{150,110}}, textColor={0,0,255}, textString="%name")}));
+end EmissionMonitored;

fastsmoothbuildings/modelica/FastSmoothBuildings/Controls/EmissionOnOff.mo

@@ -0,0 +1,10 @@
+within FastSmoothBuildings.Controls;
+model EmissionOnOff "Variant onoff: on below the set point minus half the band, off above it plus half the band"
+  extends PartialEmissionControl;
+  parameter Real bandwidth(unit="K") = 0.1 "Band of the on/off controller (Modelica OnOffController)";
+  Hysteresis onOff(uLow=-bandwidth/2, uHigh=bandwidth/2, u=TSet - TZon);
+equation
+  y = onOff.y;
+  annotation (Icon(coordinateSystem(preserveAspectRatio=false, extent={{-100,-100},{100,100}}), graphics={
+      Text(extent={{-90,40},{90,-40}}, textColor={0,0,0}, textString="on/off")}));
+end EmissionOnOff;

fastsmoothbuildings/modelica/FastSmoothBuildings/Controls/EmissionP.mo

@@ -0,0 +1,8 @@
+within FastSmoothBuildings.Controls;
+model EmissionP "Variant PController: P controller (IDEAS LimPID) between 0 and 1"
+  extends PartialEmissionControl(k=5);
+equation
+  y = Utilities.smoothLimit(k*(TSet - TZon), 0, 1, dY);
+  annotation (Icon(coordinateSystem(preserveAspectRatio=false, extent={{-100,-100},{100,100}}), graphics={
+      Text(extent={{-90,40},{90,-40}}, textColor={0,0,0}, textString="P")}));
+end EmissionP;

fastsmoothbuildings/modelica/FastSmoothBuildings/Controls/EmissionPI.mo

@@ -0,0 +1,11 @@
+within FastSmoothBuildings.Controls;
+model EmissionPI "Variant default: PI heating loop of Buildings G36 ControlLoops (k = 0.1, Ti = 900 s)"
+  extends PartialEmissionControl;
+  parameter Real kHea = 0.1 "Gain of the heating loop";
+  parameter Real TiHea(unit="s") = 900 "Integral time of the heating loop";
+  PI conHea(k=kHea, Ti=TiHea, dY=dY, e=TSet - TZon, enable=1);
+equation
+  y = conHea.y;
+  annotation (Icon(coordinateSystem(preserveAspectRatio=false, extent={{-100,-100},{100,100}}), graphics={
+      Text(extent={{-90,40},{90,-40}}, textColor={0,0,0}, textString="PI")}));
+end EmissionPI;

fastsmoothbuildings/modelica/FastSmoothBuildings/Controls/HeatPumpControl.mo

@@ -0,0 +1,45 @@
+within FastSmoothBuildings.Controls;
+model HeatPumpControl
+  "Control of trano's air-to-water heat pump (Buildings model): heating curve, heating season, buffer charged
+   between TSupSet - dTHys/2 and TSupSet + dTHys/2, compressor PI on the condenser outlet towards TSupSet + dTHys
+   (minimum speed yComMin); the minimum on and off times of the safety control are not modelled"
+  parameter Real TSet(unit="K") = 323.15 "Supply temperature at the design outdoor temperature";
+  parameter Real TSupMin(unit="K") = 303.15 "Supply temperature at the heating limit";
+  parameter Real TOutDes(unit="K") = 265.15 "Design outdoor temperature";
+  parameter Real TOutHeaLim(unit="K") = 289.15 "Heating limit";
+  parameter Real dTHys(unit="K") = 5 "Band of the buffer charging";
+  parameter Real kCom = 0.1 "Gain of the compressor controller";
+  parameter Real TiCom(unit="s") = 300 "Integral time of the compressor controller";
+  parameter Real yComMin = 0.3 "Minimum compressor speed";
+  parameter Real tauSen(unit="s") = 30 "Time constant of the condenser outlet temperature";
+  parameter Real dT(unit="K") = 0.1 "Width of the smooth limits of the heating curve";
+  parameter Real dY = 1e-3*(1 - yComMin) "Width of the smooth limits of the compressor speed";
+  Interfaces.RealInput demand "Demand of the circuits, 0 or 1"
+    annotation (Placement(transformation(extent={{-140,50},{-100,90}})));
+  Interfaces.RealInput TOut(unit="K") "Outdoor air temperature"
+    annotation (Placement(transformation(extent={{-140,5},{-100,45}})));
+  Interfaces.RealInput TBuf(unit="K") "Buffer temperature"
+    annotation (Placement(transformation(extent={{-140,-45},{-100,-5}})));
+  Interfaces.RealInput TConOut(unit="K") "Condenser outlet temperature"
+    annotation (Placement(transformation(extent={{-140,-90},{-100,-50}})));
+  Interfaces.RealOutput y(unit="1") "Compressor speed"
+    annotation (Placement(transformation(extent={{100,-20},{140,20}})));
+  Real TSupSet(unit="K") "Supply temperature set point (heating curve)";
+  Real TCon(unit="K", start=TSet, fixed=true) "Measured condenser outlet temperature";
+  Real heaOn "Heating on";
+  Hysteresis warOut(uLow=TOutHeaLim - 1, uHigh=TOutHeaLim + 1, u=TOut) "Outside the heating season";
+  Hysteresis bufCha(uLow=-dTHys/2, uHigh=dTHys/2, u=TSupSet - TBuf, y_start=1) "Charging the buffer";
+  PI conCom(k=kCom, Ti=TiCom, yMin=yComMin, yMax=1, yReset=yComMin, dY=dY, e=TSupSet + dTHys - TCon,
+    enable=heaOn);
+equation
+  TSupSet = Utilities.smoothMin(TSet, Utilities.smoothMax(TSupMin, TSet + (TSupMin - TSet)*(TOut - TOutDes)
+    /(TOutHeaLim - TOutDes), dT), dT);
+  tauSen*der(TCon) = TConOut - TCon;
+  heaOn = demand*(1 - warOut.y)*bufCha.y;
+  y = heaOn*conCom.y;
+  annotation (Icon(coordinateSystem(preserveAspectRatio=false, extent={{-100,-100},{100,100}}), graphics={
+      Rectangle(extent={{-100,-100},{100,100}}, lineColor={0,0,127}, fillColor={255,255,255},
+        fillPattern=FillPattern.Solid),
+      Text(extent={{-90,40},{90,-40}}, textColor={0,0,0}, textString="heat pump"),
+      Text(extent={{-150,150},{150,110}}, textColor={0,0,255}, textString="%name")}));
+end HeatPumpControl;

fastsmoothbuildings/modelica/FastSmoothBuildings/Controls/Hysteresis.mo

@@ -0,0 +1,35 @@
+within FastSmoothBuildings.Controls;
+model Hysteresis
+  "y goes to 1 when u rises above uHigh and back to 0 when u falls below uLow (CDL Hysteresis), as a bistable
+   state switching within tau"
+  parameter Real uLow "Threshold of the switch to 0";
+  parameter Real uHigh "Threshold of the switch to 1";
+  parameter Real tau(unit="s") = 10 "Switching time";
+  parameter Real dU = (uHigh - uLow)/10 "Half-width of the smooth transition of the switch";
+  parameter Real y_start = 0 "Initial output";
+  Interfaces.RealInput u
+    annotation (Placement(transformation(extent={{-140,-20},{-100,20}})));
+  Real y(start=y_start, fixed=true);
+equation
+  tau*der(y) = Utilities.regStep(u - (uHigh + (uLow - uHigh)*y), 1, 0, dU) - y;
+  annotation (Icon(coordinateSystem(preserveAspectRatio=false, extent={{-100,-100},{100,100}}), graphics={
+      Rectangle(extent={{-100,100},{100,-100}}, lineColor={0,0,0}, fillColor={210,210,210},
+        fillPattern=FillPattern.Solid, borderPattern=BorderPattern.Raised),
+      Polygon(points={{-80,90},{-88,68},{-72,68},{-80,90}}, lineColor={192,192,192}, fillColor={192,192,192},
+        fillPattern=FillPattern.Solid),
+      Line(points={{-80,68},{-80,-29}}, color={192,192,192}),
+      Polygon(points={{92,-29},{70,-21},{70,-37},{92,-29}}, lineColor={192,192,192}, fillColor={192,192,192},
+        fillPattern=FillPattern.Solid),
+      Line(points={{-79,-29},{84,-29}}, color={192,192,192}),
+      Line(points={{-79,-29},{41,-29}}),
+      Line(points={{-15,-21},{1,-29},{-15,-36}}),
+      Line(points={{41,51},{41,-29}}),
+      Line(points={{33,3},{41,22},{50,3}}),
+      Line(points={{-49,51},{81,51}}),
+      Line(points={{-4,59},{-19,51},{-4,43}}),
+      Line(points={{-59,29},{-49,11},{-39,29}}),
+      Line(points={{-49,51},{-49,-29}}),
+      Text(extent={{-92,-49},{-9,-92}}, textColor={192,192,192}, textString="%uLow"),
+      Text(extent={{2,-49},{91,-92}}, textColor={192,192,192}, textString="%uHigh"),
+      Text(extent={{-150,150},{150,110}}, textColor={0,0,255}, textString="%name")}));
+end Hysteresis;

fastsmoothbuildings/modelica/FastSmoothBuildings/Controls/PI.mo

@@ -0,0 +1,39 @@
+within FastSmoothBuildings.Controls;
+model PI
+  "PI controller with limits and anti-windup (Modelica LimPID: back-calculation with Ni), its integral relaxed to
+   the reset value while disabled"
+  parameter Real k "Gain";
+  parameter Real Ti(unit="s") "Integral time";
+  parameter Real yMin = 0;
+  parameter Real yMax = 1;
+  parameter Real Ni = 0.9 "Anti-windup gain";
+  parameter Real yReset = yMin "Output after a reset";
+  parameter Real tauReset(unit="s") = 30 "Time constant of the reset while disabled";
+  parameter Real dY = 1e-3*(yMax - yMin) "Width of the smooth limits";
+  Interfaces.RealInput e "Control error"
+    annotation (Placement(transformation(extent={{-140,-20},{-100,20}})));
+  Interfaces.RealInput enable "1: integrate, 0: reset"
+    annotation (Placement(transformation(extent={{-20,-20},{20,20}}, rotation=90, origin={0,-120})));
+  Real I(start=yReset/k, fixed=true) "Integral of the error";
+  Real yUnl "Unlimited output";
+  Interfaces.RealOutput y
+    annotation (Placement(transformation(extent={{100,-20},{140,20}})));
+equation
+  yUnl = k*(e + I);
+  y = Utilities.smoothLimit(yUnl, yMin, yMax, dY);
+  der(I) = enable*(e/Ti + (y - yUnl)/(k*Ni*Ti)) + (1 - enable)*(yReset/k - e - I)/tauReset;
+  annotation (Icon(coordinateSystem(preserveAspectRatio=false, extent={{-100,-100},{100,100}}), graphics={
+      Rectangle(extent={{-100,-100},{100,100}}, lineColor={0,0,127}, fillColor={255,255,255},
+        fillPattern=FillPattern.Solid),
+      Polygon(points={{-80,82},{-88,60},{-72,60},{-80,82}}, lineColor={192,192,192}, fillColor={192,192,192},
+        fillPattern=FillPattern.Solid),
+      Line(points={{-80,68},{-80,-100}}, color={192,192,192}),
+      Line(points={{-90,-80},{70,-80}}, color={192,192,192}),
+      Polygon(points={{74,-80},{52,-72},{52,-88},{74,-80}}, lineColor={192,192,192}, fillColor={192,192,192},
+        fillPattern=FillPattern.Solid),
+      Line(points={{-80,-80},{-80,-22}}, color={0,0,0}),
+      Line(points={{-80,-22},{6,56}}, color={0,0,0}),
+      Line(points={{6,56},{68,56}}, color={0,0,0}),
+      Text(extent={{-26,-22},{74,-62}}, textColor={0,0,0}, textString="PI"),
+      Text(extent={{-150,150},{150,110}}, textColor={0,0,255}, textString="%name")}));
+end PI;

fastsmoothbuildings/modelica/FastSmoothBuildings/Controls/PartialEmissionControl.mo

@@ -0,0 +1,22 @@
+within FastSmoothBuildings.Controls;
+partial model PartialEmissionControl
+  "Emission control of a zone (trano EmissionControl): set point of its day schedule, output y to the valve or
+   the ideal emitter"
+  parameter Real schedule[:](each unit="s") = 3600*{7, 19} "Day schedule: occupied between pairs of instants";
+  parameter Real THeaSet(unit="K") = 294.15 "Set point when occupied";
+  parameter Real THeaSetBack(unit="K") = 289.15 "Set point otherwise";
+  parameter Real k = 1 "Gain";
+  parameter Real dY = 1e-3 "Width of the smooth limits of the output";
+  parameter Real dtSet(unit="s") = 60 "Duration of a change of the set point";
+  Interfaces.RealInput TZon(unit="K") "Zone air temperature"
+    annotation (Placement(transformation(extent={{-140,-20},{-100,20}})));
+  Interfaces.RealOutput y(unit="1") "Valve opening, or share of the power of an ideal emitter"
+    annotation (Placement(transformation(extent={{100,-20},{140,20}})));
+  Real TSet(unit="K") "Set point";
+equation
+  TSet = THeaSetBack + (THeaSet - THeaSetBack)*Utilities.occupancy(Utilities.timeOfDay(time), schedule, dtSet);
+  annotation (Icon(coordinateSystem(preserveAspectRatio=false, extent={{-100,-100},{100,100}}), graphics={
+      Rectangle(extent={{-100,-100},{100,100}}, lineColor={0,0,127}, fillColor={255,255,255},
+        fillPattern=FillPattern.Solid),
+      Text(extent={{-150,150},{150,110}}, textColor={0,0,255}, textString="%name")}));
+end PartialEmissionControl;

fastsmoothbuildings/modelica/FastSmoothBuildings/Controls/ThreeWayValveControl.mo

@@ -0,0 +1,22 @@
+within FastSmoothBuildings.Controls;
+model ThreeWayValveControl
+  "Three-way valve control (trano ThreeWayValveControl): P controller on the supply temperature measured
+   downstream (filtered by tauSen)"
+  parameter Real TColSet(unit="K") = 363.15 "Supply temperature set point";
+  parameter Real k = 1 "Gain";
+  parameter Real tauSen(unit="s") = 10 "Time constant of the temperature measurement";
+  parameter Real dY = 1e-3 "Width of the smooth limits of the opening";
+  Interfaces.RealInput u(unit="K") "Measured supply temperature"
+    annotation (Placement(transformation(extent={{-140,-20},{-100,20}})));
+  Interfaces.RealOutput y(unit="1") "Opening of the supply path"
+    annotation (Placement(transformation(extent={{100,-20},{140,20}})));
+  Real TMea(unit="K", start=TColSet - 30, fixed=true) "Filtered measurement";
+equation
+  tauSen*der(TMea) = u - TMea;
+  y = Utilities.smoothLimit(k*(TColSet - TMea), 0, 1, dY);
+  annotation (Icon(coordinateSystem(preserveAspectRatio=false, extent={{-100,-100},{100,100}}), graphics={
+      Rectangle(extent={{-100,-100},{100,100}}, lineColor={0,0,127}, fillColor={255,255,255},
+        fillPattern=FillPattern.Solid),
+      Text(extent={{-90,40},{90,-40}}, textColor={0,0,0}, textString="3WV"),
+      Text(extent={{-150,150},{150,110}}, textColor={0,0,255}, textString="%name")}));
+end ThreeWayValveControl;