processpi 0.0.0__py3-none-any.whl

processpi/pipelines/pumps.py

@@ -0,0 +1,83 @@
+from typing import Optional, Dict, Union
+from .base import PipelineBase
+from ..units import Power, Pressure
+from .standards import PUMP_EFFICIENCIES
+
+
+class Pump(PipelineBase):
+    """
+    Represents a pump in a pipeline system.
+
+    Attributes:
+        pump_type (str): Type of pump (e.g., 'centrifugal', 'positive_displacement').
+        flow_rate (float): Volumetric flow rate (m³/s).
+        head (float): Pump head (m), calculated automatically from pressures if provided.
+        density (float): Fluid density (kg/m³). Default = 1000 (water).
+        efficiency (float): Pump efficiency (0 < η ≤ 1). Loaded from standards if available.
+        inlet_pressure (Pressure): Inlet pressure to the pump.
+        outlet_pressure (Pressure): Outlet pressure from the pump.
+    """
+
+    def __init__(
+        self,
+        pump_type: str,
+        flow_rate: float,
+        head: Optional[float] = None,
+        density: float = 1000,
+        efficiency: Optional[float] = None,
+        inlet_pressure: Optional[Pressure] = None,
+        outlet_pressure: Optional[Pressure] = None,
+    ):
+        self.pump_type = pump_type
+        self.flow_rate = flow_rate
+        self.density = density
+        self.inlet_pressure = inlet_pressure
+        self.outlet_pressure = outlet_pressure
+
+        # Calculate head from pressure difference if available
+        if outlet_pressure and inlet_pressure:
+            dp_pa = (outlet_pressure.to("Pa").value - inlet_pressure.to("Pa").value)
+            self.head = dp_pa / (density * 9.81)
+        else:
+            self.head = head or 0.0  # Default head to 0 if neither pressures nor head provided
+
+        self.efficiency = efficiency or PUMP_EFFICIENCIES.get(pump_type, 0.7)
+
+    def hydraulic_power(self) -> float:
+        """
+        Calculate the hydraulic power required by the pump.
+        Formula:
+            P_h = ρ * g * Q * H   (W)
+        """
+        g = 9.81  # m/s²
+        return self.density * g * self.flow_rate * self.head
+
+    def brake_power(self) -> float:
+        """
+        Calculate the brake power required considering efficiency.
+        Formula:
+            P_b = P_h / η   (W)
+        """
+        return self.hydraulic_power() / self.efficiency if self.efficiency > 0 else 0.0
+
+    def to_dict(self) -> Dict[str, Union[str, float]]:
+        """
+        Export pump properties and calculations as a dictionary.
+        """
+        return {
+            "pump_type": self.pump_type,
+            "flow_rate_m3s": self.flow_rate,
+            "density_kgm3": self.density,
+            "efficiency": self.efficiency,
+            "head_m": self.head,
+            "hydraulic_power_W": self.hydraulic_power(),
+            "brake_power_W": self.brake_power(),
+            "inlet_pressure_Pa": self.inlet_pressure.to("Pa").value if self.inlet_pressure else None,
+            "outlet_pressure_Pa": self.outlet_pressure.to("Pa").value if self.outlet_pressure else None,
+        }
+
+    def calculate(self):
+        """
+        Perform calculations and return results.
+        """
+        return self.to_dict()

processpi/pipelines/selection.py

@@ -0,0 +1,89 @@
+# processpi/pipelines/selection.py
+
+"""
+Pipeline Material Selection Module
+
+This module provides logic for selecting appropriate
+pipeline materials based on design conditions such as
+temperature, pressure, and corrosion requirements.
+
+Uses data from materials.py
+"""
+
+from typing import Dict, Any, List
+from .materials import MATERIAL_PROPERTIES
+
+
+class MaterialSelector:
+    """
+    Class for selecting suitable pipeline materials.
+    """
+
+    def __init__(self, design_temp: float, design_pressure: float, corrosive: bool = False):
+        """
+        Initialize material selector with design parameters.
+
+        Args:
+            design_temp (float): Design temperature in °C.
+            design_pressure (float): Design pressure in bar.
+            corrosive (bool): Whether the fluid is corrosive.
+        """
+        self.design_temp = design_temp
+        self.design_pressure = design_pressure
+        self.corrosive = corrosive
+
+    def filter_materials(self) -> List[str]:
+        """
+        Filter materials that can withstand design conditions.
+
+        Returns:
+            list: Suitable material codes.
+        """
+        suitable = []
+        for material, props in MATERIAL_PROPERTIES.items():
+            max_temp = props.get("max_temp", 0)
+            allowable_stress = props.get("allowable_stress", 0)
+
+            # Simple selection logic
+            if self.design_temp <= max_temp:
+                # Convert MPa stress to bar (1 MPa = 10 bar approx)
+                if self.design_pressure <= allowable_stress * 10:
+                    if self.corrosive:
+                        if "SS" in material or material in ["HDPE", "CPVC"]:
+                            suitable.append(material)
+                    else:
+                        suitable.append(material)
+        return suitable
+
+    def recommend_material(self) -> Dict[str, Any]:
+        """
+        Recommend the most suitable material based on design conditions.
+
+        Returns:
+            dict: Recommended material data.
+        """
+        suitable = self.filter_materials()
+
+        if not suitable:
+            return {"message": "No suitable material found for given conditions."}
+
+        # Prefer stainless steel in corrosive service
+        if self.corrosive:
+            for pref in ["SS316", "SS304", "HDPE", "CPVC"]:
+                if pref in suitable:
+                    return {"material": pref, **MATERIAL_PROPERTIES[pref]}
+
+        # Otherwise pick carbon steel first if allowed
+        if "CS" in suitable:
+            return {"material": "CS", **MATERIAL_PROPERTIES["CS"]}
+
+        # Fallback: return the first suitable option
+        mat = suitable[0]
+        return {"material": mat, **MATERIAL_PROPERTIES[mat]}
+
+
+# Example usage
+if __name__ == "__main__":
+    selector = MaterialSelector(design_temp=150, design_pressure=15, corrosive=True)
+    recommendation = selector.recommend_material()
+    print("Recommended Material:", recommendation)

processpi/pipelines/standards.py

@@ -0,0 +1,279 @@
+# processpi/pipelines/standards.py
+from ..units import *
+
+"""
+Pipeline Standards Module
+-------------------------
+Contains standard reference data for process pipelines:
+- Pipe nominal sizes
+- Schedules and wall thickness
+- Internal diameter lookup
+- Material roughness values
+- Recommended fluid velocities
+"""
+
+from typing import Dict, Tuple, Optional, Union, List
+
+# --------------------------
+# 🔹 Roughness (mm)
+# --------------------------
+ROUGHNESS: Dict[str, float] = {
+    "CS": 0.045,        # Carbon Steel
+    "SS": 0.015,        # Stainless Steel
+    "PVC": 0.0015,      # Polyvinyl Chloride
+    "Copper": 0.0015,
+    "Concrete": 0.3,
+    "Glass": 0.001,
+    "Other": 0.05,      # Default
+}
+
+# --------------------------
+# 🔹 Pipe Standard Sizes (in)
+# --------------------------
+
+STANDARD_SIZES = [Diameter(0.25,"in"),
+                  Diameter(0.5,"in"),
+                  Diameter(0.75,"in"),
+                  Diameter(1,"in"),
+                  Diameter(1.5,"in"),
+                  Diameter(2,"in"),
+                  Diameter(2.5,"in"),
+                  Diameter(3,"in"),
+                  Diameter(4,"in"),
+                  Diameter(5,"in"),
+                  Diameter(6,"in"),
+                  Diameter(8,"in"),
+                  Diameter(10,"in"),
+                  Diameter(12,"in"),
+                  Diameter(14,"in"),
+                  Diameter(15,"in"),
+                  Diameter(20,"in"),
+                  Diameter(25,"in"),
+                  Diameter(30,"in"),
+                  Diameter(35,"in"),
+                  Diameter(40,"in"),
+                  Diameter(45,"in"),
+                  Diameter(50,"in")]
+
+# --------------------------
+# 🔹 Pipe Size Database
+# Nominal Diameter (mm) → { Schedule → (Wall Thickness mm, ID mm) }
+# --------------------------
+PIPE_SCHEDULES: Dict[Diameter, Dict[str, Tuple[Length, Diameter]]] = {
+    Diameter(0.25,"in"): {  # 1/4"
+        "40": (Length(2.77,"mm"), Diameter(6.35,"mm")),
+        "80": (Length(3.02,"mm"), Diameter(5.49,"mm")),
+    },
+    Diameter(0.5,"in"): {  # 1/2"
+        "40": (Length(2.77,"mm"), Diameter(15.8,"mm")),
+        "80": (Length(3.73,"mm"), Diameter(13.8,"mm")),
+    },
+    Diameter(0.75,"in"): {  # 3/4"
+        "40": (Length(2.87,"mm"), Diameter(20.9,"mm")),
+        "80": (Length(3.91,"mm"), Diameter(18.8,"mm")),
+    },
+    Diameter(1,"in"): {  # 1"
+        "40": (Length(3.38,"mm"), Diameter(26.6,"mm")),
+        "80": (Length(4.55,"mm"), Diameter(24.3,"mm")),
+    },
+    Diameter(1.5,"in"): {  # 1-1/2"
+        "40": (Length(3.68,"mm"), Diameter(40.9,"mm")),
+        "80": (Length(5.08,"mm"), Diameter(37.5,"mm")),
+    },
+    Diameter(2,"in"): {  # 2"
+        "40": (Length(3.91,"mm"), Diameter(52.5,"mm")),
+        "80": (Length(5.54,"mm"), Diameter(49.3,"mm")),
+    },
+    Diameter(2.5,"in"): {  # 2-1/2"
+        "40": (Length(5.16,"mm"), Diameter(62.7,"mm")),
+        "80": (Length(7.01,"mm"), Diameter(59.5,"mm")),
+    },
+    Diameter(3,"in"): {  # 3"
+        "40": (Length(5.49,"mm"), Diameter(77.9,"mm")),
+        "80": (Length(7.62,"mm"), Diameter(73.7,"mm")),
+    },
+    Diameter(4,"in"): {  # 4"
+        "40": (Length(6.02,"mm"), Diameter(102.3,"mm")),
+        "80": (Length(8.56,"mm"), Diameter(97.2,"mm")),
+    },
+    Diameter(5,"in"): {  # 5"
+        "40": (Length(6.55,"mm"), Diameter(127.3,"mm")),
+        "80": (Length(9.53,"mm"), Diameter(121.9,"mm")),
+    },
+    Diameter(6,"in"): {  # 6"
+        "40": (Length(7.11,"mm"), Diameter(154.1,"mm")),
+        "80": (Length(10.97,"mm"), Diameter(146.3,"mm")),
+    },
+    Diameter(8,"in"): {  # 8"
+        "40": (Length(8.18,"mm"), Diameter(202.7,"mm")),
+        "80": (Length(12.70,"mm"), Diameter(193.7,"mm")),
+    },
+    Diameter(10,"in"): {  # 10"
+        "40": (Length(9.27,"mm"), Diameter(254.5,"mm")),
+        "80": (Length(15.09,"mm"), Diameter(242.8,"mm")),
+    },
+    Diameter(12,"in"): {  # 12"
+        "40": (Length(10.31,"mm"), Diameter(303.2,"mm")),
+        "80": (Length(17.48,"mm"), Diameter(289.1,"mm")),
+    },
+    Diameter(14,"in"): {  # 14"
+        "40": (Length(11.13,"mm"), Diameter(333.4,"mm")),
+        "80": (Length(19.05,"mm"), Diameter(318.5,"mm")),
+    },
+    Diameter(15,"in"): {  # 15"
+        "40": (Length(11.91,"mm"), Diameter(359.1,"mm")),
+        "80": (Length(19.05,"mm"), Diameter(338.9,"mm")),
+    },
+    Diameter(20,"in"): {  # 20"
+        "40": (Length(12.70,"mm"), Diameter(508.0,"mm")),
+        "80": (Length(23.01,"mm"), Diameter(482.6,"mm")),
+    },
+    Diameter(25,"in"): {  # 25"
+        "40": (Length(15.88,"mm"), Diameter(635.0,"mm")),
+        "80": (Length(24.61,"mm"), Diameter(584.2,"mm")),
+    },
+    Diameter(30,"in"): {  # 30"
+        "40": (Length(15.88,"mm"), Diameter(762.0,"mm")),
+        "80": (Length(27.78,"mm"), Diameter(730.0,"mm")),
+    },
+    Diameter(35,"in"): {  # 35"
+        "40": (Length(19.05,"mm"), Diameter(889.0,"mm")),
+        "80": (Length(28.58,"mm"), Diameter(850.0,"mm")),
+    },
+    Diameter(40,"in"): {  # 40"
+        "40": (Length(19.05,"mm"), Diameter(1016.0,"mm")),
+        "80": (Length(31.75,"mm"), Diameter(965.0,"mm")),
+    },
+    Diameter(45,"in"): {  # 45"
+        "40": (Length(19.05,"mm"), Diameter(1143.0,"mm")),
+        "80": (Length(31.75,"mm"), Diameter(1092.0,"mm")),
+    },
+    Diameter(50,"in"): {  # 50"
+        "40": (Length(19.05,"mm"), Diameter(1270.0,"mm")),
+        "80": (Length(31.75,"mm"), Diameter(1219.0,"mm")),
+    },
+}
+
+
+# --------------------------
+# 🔹 Recommended Fluid Velocities (m/s)
+# --------------------------
+RECOMMENDED_VELOCITIES: Dict[str, Union[Tuple[float, float], float]] = {
+    "Water - Pump suction": (0.3, 1.5),
+    "Water - Pump discharge": (2.0, 3.0),
+    "Water - Average service": (1.0, 2.5),
+
+    "Steam - 0 to 2 atm g, saturated": (20, 30),
+    "Steam - 2 to 10 atm g, saturated": (30, 50),
+    "Steam - Superheated <10 atm g": (20, 50),
+    "Steam - Superheated >10 atm g": (30, 75),
+
+    "Vacuum lines": (100, 125),
+
+    "Air - 0 to 2 atm g": 20,
+    "Air - >2 atm g or above": 30,
+
+    "Ammonia - Liquid": 1.8,
+    "Ammonia - Gas": 30,
+
+    "Organic liquids and oils": (1.8, 2.0),
+    "Natural gas": (25, 35),
+
+    "Chlorine - Liquid": 1.5,
+    "Chlorine - Gas": (10, 25),
+
+    "Hydrochloric acid - Liquid": 1.5,
+    "Hydrochloric acid - Gas": 10,
+
+    "Inorganic liquids": (1.2, 1.8),
+    "Inorganic gases and vapours": (15, 30),
+}
+# --------------------------
+# 🔹 Equivalent Lengths Equivalent Length / Diameter
+# --------------------------
+
+EQUIVALENT_LENGTHS = {
+    "gate_valve_open": (7, 10),          # fully open
+    "gate_valve_3_4_closed": (800, 1100),
+    "gate_valve_half_closed": (190, 290),
+    "globe_valve_open": (330, 480),
+    "angle_valve_open": (165, 220),
+    "plug_valve_open": 18,
+    "elbow_90_standard": 30,
+    "elbow_45_long": 5.8,
+    "elbow_45_short": 8.0,
+    "return_bend_medium": (39, 56),
+    "coupling_union": 0,                 # negligible
+    "tee_straight": 22,
+}
+# --------------------------
+# 🔹 K Factors
+# --------------------------
+
+K_FACTORS = {
+    "gate_valve_open": 0.15,            # fully open
+    "gate_valve_3_4_closed": 17.0,
+    "gate_valve_half_closed": 9.5,
+    "globe_valve_open": 10.0,
+    "angle_valve_open": 5.0,
+    "plug_valve_open": 0.4,
+    "elbow_90_standard": 0.9,
+    "elbow_45_long": 0.35,
+    "elbow_45_short": 0.4,
+    "return_bend_medium": 2.2,
+    "coupling_union": 0.08,
+    "tee_straight": 0.6,
+    "tee_branch": 1.8,                  # flow through branch
+    "sudden_contraction": 0.42,
+    "sudden_expansion": 1.0,            # (1 - (d/D)^2)^2, here avg
+    "entrance_sharp": 0.5,
+    "entrance_rounded": 0.04,
+    "exit": 1.0,
+}
+
+# --------------------------
+# 🔹 Utility Functions
+# --------------------------
+def get_internal_diameter(
+    nominal_diameter: Diameter, schedule: str
+):
+    """Returns internal diameter for a given nominal diameter and schedule."""
+    if nominal_diameter not in PIPE_SCHEDULES:
+        return None
+    return PIPE_SCHEDULES[nominal_diameter].get(schedule, (None, None))[1]
+
+
+def get_thickness(
+    nominal_diameter: int, schedule: str
+) -> Optional[float]:
+    """Returns wall thickness for a given nominal diameter and schedule."""
+    if nominal_diameter not in PIPE_SCHEDULES:
+        return None
+    return PIPE_SCHEDULES[nominal_diameter].get(schedule, (None, None))[0]
+
+
+def get_roughness(material: str) -> float:
+    """Returns roughness for given material. Defaults if not found."""
+    return ROUGHNESS.get(material, ROUGHNESS["Other"])
+
+
+def get_recommended_velocity(service: str) -> Optional[Union[float, Tuple[float, float]]]:
+    """
+    Returns recommended velocity (m/s) for a given service type.
+    Can be a single value or a range (tuple).
+    """
+    return RECOMMENDED_VELOCITIES.get(service, None)
+
+def get_nearest_diameter(calculated_diameter: Diameter) -> Diameter:
+    """
+    Returns the nearest standard diameter for a given calculated diameter.
+    if calculated_diameter not in STANDARD_SIZES:
+        return calculated_diameter
+
+    """
+    
+    # Find the nearest standard diameter
+    nearest = min(STANDARD_SIZES, key=lambda x: abs(x.value - calculated_diameter.value))
+    #print(f"Nearest standard diameter for {calculated_diameter.value} mm is {nearest.value} mm")
+    #print(type(nearest))
+    return nearest

processpi/pipelines/vessel.py

@@ -0,0 +1,34 @@
+# processpi/pipelines/vessel.py
+
+class Vessel:
+    """
+    Vessel represents a storage or process vessel in the pipeline network.
+    It can have one or multiple inlet and outlet connections.
+    """
+    def __init__(self, name: str, volume: float = 0.0, pressure: float = 0.0, temperature: float = 0.0):
+        """
+        Initialize a Vessel.
+        
+        Args:
+            name (str): Name of the vessel.
+            volume (float): Vessel capacity (m³), optional.
+            pressure (float): Internal pressure (bar), optional.
+            temperature (float): Internal temperature (°C), optional.
+        """
+        self.name = name
+        self.volume = volume
+        self.pressure = pressure
+        self.temperature = temperature
+        self.inlet_nodes = []
+        self.outlet_nodes = []
+
+    def add_inlet(self, node):
+        """Attach an inlet node to the vessel."""
+        self.inlet_nodes.append(node)
+
+    def add_outlet(self, node):
+        """Attach an outlet node to the vessel."""
+        self.outlet_nodes.append(node)
+
+    def __repr__(self):
+        return f"Vessel({self.name}, Volume={self.volume} m³, P={self.pressure} bar, T={self.temperature}°C)"

processpi/units/__init__.py

@@ -0,0 +1,38 @@
+from .length import Length
+from .velocity import Velocity
+from .density import Density
+from .viscosity import Viscosity
+from .temperature import Temperature
+from .dimensionless import Dimensionless
+from .volumetric_flowrate import VolumetricFlowRate
+from .mass_flowrate import MassFlowRate
+from .diameter import Diameter
+from .pressure import Pressure
+from .volume import Volume
+from .area import Area  
+from .mass import Mass
+from .specific_heat import SpecificHeat
+from .thermal_conductivity import ThermalConductivity
+from .heat_transfer_coefficient import HeatTransferCoefficient
+from .thermal_resistance import ThermalResistance
+from .heat_flux import HeatFlux
+from .heat_of_vaporization import HeatOfVaporization
+__all__ = ["Length", 
+           "Velocity", 
+           "Density", 
+           "Viscosity", 
+           "Temperature", 
+           "VolumetricFlowRate", 
+           "MassFlowRate", 
+           "Diameter", 
+           "Pressure", 
+           "Volume", 
+           "Area", 
+           "Mass", 
+           "SpecificHeat", 
+           "ThermalConductivity", 
+           "HeatTransferCoefficient", 
+           "ThermalResistance", 
+           "HeatFlux", 
+           "HeatOfVaporization",
+           "Dimensionless"]

processpi/units/area.py

@@ -0,0 +1,51 @@
+from .base import Variable
+
+class Area(Variable):
+    """
+    Represents an Area quantity.
+    Default SI unit: Square Meter (m2).
+
+    Example:
+    a1 = Area(100, "cm2")
+    a2 = Area(0.5, "m2")
+    """
+
+    _conversion = {
+        "m2": 1,
+        "cm2": 0.0001,
+        "mm2": 0.000001,
+        "km2": 1_000_000,
+        "in2": 0.00064516,
+        "ft2": 0.092903,
+        "yd2": 0.836127,
+        "acre": 4046.86,
+        "ha": 10000
+    }
+
+    def __init__(self, value, units="m2"):
+        if value < 0:
+            raise ValueError("Area must be non-negative")
+        if units not in self._conversion:
+            raise TypeError(f"{units} is not a valid unit for Area")
+        base_value = round(value * self._conversion[units], 6)
+        super().__init__(base_value, "m2")
+        self.original_value = value
+        self.original_unit = units
+
+    def to(self, target_unit):
+        if target_unit not in self._conversion:
+            raise TypeError(f"{target_unit} is not a valid unit for Area")
+        converted_value = self.value / self._conversion[target_unit]
+        return Area(round(converted_value, 6), target_unit)
+
+    def __add__(self, other):
+        if not isinstance(other, Area):
+            raise TypeError("Addition only supported between Area instances")
+        total = self.value + other.value
+        return Area(round(total, 6), "m2")
+
+    def __eq__(self, other):
+        return isinstance(other, Area) and self.value == other.value
+
+    def __repr__(self):
+        return f"{self.original_value} {self.original_unit}"

processpi/units/base.py

@@ -0,0 +1,57 @@
+class Variable:
+    """
+    A generic physical variable with value and units.
+    Should be subclassed for specific physical types.
+    """
+
+    def __init__(self, value: float, units: str):
+        self.value = value
+        self.units = units
+
+    def __str__(self):
+        return f"{self.value} {self.units}"
+
+    def __repr__(self):
+        return f"<{self.__class__.__name__}: {self.value} {self.units}>"
+
+    def __eq__(self, other):
+        return (
+            isinstance(other, self.__class__) and
+            self.to_base() == other.to_base()
+        )
+
+    def __ne__(self, other):
+        return not self.__eq__(other)
+
+    def __lt__(self, other):
+        if not isinstance(other, self.__class__):
+            return NotImplemented
+        return self.to_base() < other.to_base()
+
+    def __le__(self, other):
+        if not isinstance(other, self.__class__):
+            return NotImplemented
+        return self.to_base() <= other.to_base()
+
+    def __gt__(self, other):
+        if not isinstance(other, self.__class__):
+            return NotImplemented
+        return self.to_base() > other.to_base()
+
+    def __ge__(self, other):
+        if not isinstance(other, self.__class__):
+            return NotImplemented
+        return self.to_base() >= other.to_base()
+
+    def __hash__(self):
+        # Use tuple of class name + normalized value (in base units) for immutability
+        return hash((self.__class__.__name__, self.to_base()))
+
+    def to(self, target_units: str):
+        raise NotImplementedError("Override this method in subclass.")
+
+    def to_base(self):
+        raise NotImplementedError("Override this method in subclass.")
+
+    def from_base(self, base_value: float, target_units: str):
+        raise NotImplementedError("Override this method in subclass.")

processpi/units/density.py

@@ -0,0 +1,47 @@
+from .base import Variable
+
+class Density(Variable):
+    """
+    Represents a Density quantity.
+    Default SI unit: kilograms per cubic meter (kg/m³).
+    
+    Example:
+    d1 = Density(1000)             # 1000 kg/m³
+    d2 = Density(1, "g/cm³")       # 1 gram per cubic centimeter
+    """
+
+    _conversion = {
+        "kg/m3": 1,
+        "g/cm3": 1000,
+        "g/mL": 1000,
+        "lb/ft3": 16.0185,
+        "lb/in3": 27679.9
+    }
+
+    def __init__(self, value, units="kg/m3"):
+        if value < 0:
+            raise ValueError("Density must be a non-negative value")
+        if units not in self._conversion:
+            raise ValueError(f"{units} is not a valid unit for Density")
+        base_value = round(value * self._conversion[units], 6)
+        super().__init__(base_value, "kg/m3")  # Always store as base unit (kg/m³)
+        self.original_value = value
+        self.original_unit = units
+
+    def to(self, target_unit):
+        if target_unit not in self._conversion:
+            raise ValueError(f"{target_unit} is not a valid unit for Density")
+        converted_value = self.value / self._conversion[target_unit]
+        return Density(converted_value, target_unit)
+
+    def __add__(self, other):
+        if not isinstance(other, Density):
+            raise TypeError("Addition only allowed between Density objects")
+        result_in_base = self.value + other.value
+        return Density(result_in_base / self._conversion[self.original_unit], self.original_unit)
+
+    def __eq__(self, other):
+        return isinstance(other, Density) and self.value == other.value
+
+    def __repr__(self):
+        return f"{self.original_value} {self.original_unit}"