added test for temperatures (#984)

Author: EvenSol

src/main/java/neqsim/thermo/system/SystemThermo.java

@@ -5021,11 +5021,20 @@ public final void setTemperature(double newTemperature, int phase) {
   public void setTemperature(double newTemperature, String unit) {
     for (int i = 0; i < getMaxNumberOfPhases(); i++) {
       if (unit.equals("K")) {
+        // Direct setting as Kelvin
         getPhases()[i].setTemperature(newTemperature);
       } else if (unit.equals("C")) {
+        // Convert Celsius to Kelvin
         getPhases()[i].setTemperature(newTemperature + 273.15);
+      } else if (unit.equals("F")) {
+        // Convert Fahrenheit to Kelvin
+        getPhases()[i].setTemperature((newTemperature - 32) * 5.0 / 9.0 + 273.15);
+      } else if (unit.equals("R")) {
+        // Convert Rankine to Kelvin
+        getPhases()[i].setTemperature(newTemperature * 5.0 / 9.0);
       } else {
-        throw new RuntimeException("unit not supported " + unit);
+        // Exception for unsupported units
+        throw new RuntimeException("Unit not supported: " + unit);
       }
     }
   }

src/main/java/neqsim/util/unit/TemperatureUnit.java

@@ -24,46 +24,89 @@ public TemperatureUnit(double value, String name) {
   }
 
   /**
-   * <p>
-   * getConversionFactor.
-   * </p>
+   * Get conversion factor for temperature unit conversions to Kelvin. Note: This is primarily for
+   * understanding scale, not for direct conversions including offsets.
    *
-   * @param name a {@link java.lang.String} object
-   * @return a double
+   * @param name a {@link java.lang.String} object representing the temperature unit
+   * @return a double representing the conversion factor relative to Kelvin
    */
   public double getConversionFactor(String name) {
-    double conversionFactor = 1.0;
     switch (name) {
       case "K":
-        conversionFactor = 1.0;
-        break;
-      case "R":
-        conversionFactor = 5.0 / 9.0;
-        break;
+        return 1.0;
+      case "C":
+        return 1.0; // Same scale as Kelvin
       case "F":
-        conversionFactor = 5.0 / 9.0;
-        break;
+        return 5.0 / 9.0; // Scale factor for Fahrenheit to Kelvin
+      case "R":
+        return 5.0 / 9.0; // Scale factor for Rankine to Kelvin
+      default:
+        throw new IllegalArgumentException("Unknown unit: " + name);
     }
-    return conversionFactor;
   }
 
-  /** {@inheritDoc} */
+  /**
+   * Convert a value from one temperature unit to another.
+   *
+   * @param value the temperature value to convert
+   * @param fromUnit the unit of the input temperature
+   * @param toUnit the unit to convert the temperature to
+   * @return the converted temperature value
+   */
   @Override
-  public double getValue(double val, String fromunit, String tounit) {
-    invalue = val;
-    return getConversionFactor(fromunit) / getConversionFactor(tounit) * invalue;
+  public double getValue(double value, String fromUnit, String toUnit) {
+    if (fromUnit.equals(toUnit)) {
+      return value;
+    }
+
+    // Convert input to Kelvin first
+    double tempInKelvin = value;
+    if (fromUnit.equals("C")) {
+      tempInKelvin += 273.15;
+    } else if (fromUnit.equals("F")) {
+      tempInKelvin = (value - 32) * 5.0 / 9.0 + 273.15;
+    } else if (fromUnit.equals("R")) {
+      tempInKelvin = value * 5.0 / 9.0;
+    }
+
+    // Convert from Kelvin to target unit
+    if (toUnit.equals("K")) {
+      return tempInKelvin;
+    } else if (toUnit.equals("C")) {
+      return tempInKelvin - 273.15;
+    } else if (toUnit.equals("F")) {
+      return (tempInKelvin - 273.15) * 9.0 / 5.0 + 32;
+    } else if (toUnit.equals("R")) {
+      return tempInKelvin * 9.0 / 5.0;
+    }
+
+    throw new IllegalArgumentException("Unsupported unit: " + toUnit);
   }
 
-  /** {@inheritDoc} */
+  /**
+   * Convert a given temperature value from Kelvin to a specified unit.
+   *
+   * @param toUnit the target unit to convert the temperature to ("C", "F", "R")
+   * @return the converted temperature value in the target unit
+   */
   @Override
-  public double getValue(String tounit) {
-    if (tounit.equals("C")) {
-      return getConversionFactor(inunit) / getConversionFactor("K") * invalue - 273.15;
-    }
-    if (tounit.equals("F")) {
-      return (getConversionFactor(inunit) / getConversionFactor("K") * invalue - 273.15) * 1.8
-          + 32.0;
+  public double getValue(String toUnit) {
+    switch (toUnit) {
+      case "K":
+        // Convert from Kelvin to Kelvin
+        return invalue;
+      case "C":
+        // Convert from Kelvin to Celsius
+        return invalue - 273.15;
+      case "F":
+        // Convert from Kelvin to Fahrenheit
+        return invalue * 9.0/5.0 - 459.67;
+      case "R":
+        // Convert from Kelvin to Rankine
+        return invalue * 9.0 / 5.0;
+      default:
+        // Handle unsupported units
+        throw new IllegalArgumentException("Unsupported conversion unit: " + toUnit);
     }
-    return getConversionFactor(inunit) / getConversionFactor(tounit) * invalue;
   }
 }

src/test/java/neqsim/processSimulation/processSystem/MLA_bug_test.java

@@ -348,5 +348,6 @@ public void runProcessTEG() throws InterruptedException {
     } catch (Exception ex) {
       logger.error("Something failed");
     }
+    System.out.println("water in gas "+ dehydratedGas.getFluid().getComponent("water").getx());
   }
 }

src/test/java/neqsim/util/unit/TemperatureUnitTest.java

@@ -0,0 +1,54 @@
+package neqsim.util.unit;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import org.junit.jupiter.api.Test;
+import neqsim.thermo.ThermodynamicConstantsInterface;
+import neqsim.thermodynamicOperations.ThermodynamicOperations;
+
+class TemperatureUnitTest extends neqsim.NeqSimTest {
+  /**
+   * <p>
+   * testSetPressure
+   * </p>
+   */
+  @Test
+  public void testSetTemperature() {
+    neqsim.thermo.system.SystemPrEos fluid = new neqsim.thermo.system.SystemPrEos(298.0, 10.0);
+    fluid.addComponent("nitrogen", 10.0);
+    fluid.addComponent("nC10", 10.0);
+    fluid.setPressure(0.0, "barg");
+
+    ThermodynamicOperations testOps = new ThermodynamicOperations(fluid);
+    testOps.TPflash();
+    fluid.initProperties();
+
+    assertEquals(ThermodynamicConstantsInterface.referencePressure, fluid.getPressure("bara"),
+        1e-4);
+    assertEquals(24.850000000000, fluid.getTemperature("C"), 1e-4);
+    assertEquals(76.7300000, fluid.getTemperature("F"), 1e-4);
+    assertEquals(536.4, fluid.getTemperature("R"), 1e-4);
+
+    fluid.setTemperature(11.0, "F");
+    testOps.TPflash();
+
+    assertEquals(470.67, fluid.getTemperature("R"), 1e-4);
+    assertEquals(-11.6666666666, fluid.getTemperature("C"), 1e-4);
+    assertEquals(261.483333333, fluid.getTemperature("K"), 1e-4);
+
+    fluid.setTemperature(527.67, "R");
+    testOps.TPflash();
+
+    assertEquals(68.0, fluid.getTemperature("F"), 1e-4);
+    assertEquals(20.0, fluid.getTemperature("C"), 1e-4);
+    assertEquals(293.15, fluid.getTemperature("K"), 1e-4);
+
+    fluid.setTemperature(25.25, "C");
+    testOps.TPflash();
+
+    assertEquals(77.4499999999, fluid.getTemperature("F"), 1e-4);
+    assertEquals(537.12, fluid.getTemperature("R"), 1e-4);
+    assertEquals(298.4, fluid.getTemperature("K"), 1e-4);
+
+  }
+}
+