refact: rename variables

Author: asmfstatoil

src/main/java/neqsim/MathLib/nonLinearSolver/NumericalDerivative.java

@@ -97,11 +97,11 @@ public static double fugcoefDiffPres(ComponentInterface component, PhaseInterfac
    * @param numberOfComponents a int
    * @param temperature a double
    * @param pressure a double
-   * @param phaseType the PhaseType of the phase.
+   * @param pt the PhaseType of the phase.
    * @return a double
    */
   public static double fugcoefDiffTemp(ComponentInterface component, PhaseInterface phase,
-      int numberOfComponents, double temperature, double pressure, PhaseType phaseType) {
+      int numberOfComponents, double temperature, double pressure, PhaseType pt) {
     double ans = 0.000001;
     // double errt, fac, hh, err = 0.00000000000001;
     // double h = temperature / 50;

src/main/java/neqsim/physicalProperties/interfaceProperties/surfaceTension/FirozabadiRamleyInterfaceTension.java

@@ -68,7 +68,7 @@ public double calcSurfaceTension(int interface1, int interface2) {
         - system.getPhase(interface1).getPhysicalProperties().getDensity());
     double Tr = system.getPhase(interface1).getTemperature()
         / system.getPhase(interface1).getPseudoCriticalTemperature();
-    // System.out.println("deltaDens " + deltaDens + " Tr " + Tr + " phaseType " +
+    // System.out.println("deltaDens " + deltaDens + " Tr " + Tr + " pt " +
     // system.getPhase(interface1).getType());
     double a1 = 0.0;
     double b1 = 0.0;

src/main/java/neqsim/processSimulation/processEquipment/util/Adjuster.java

@@ -70,6 +70,7 @@ public Adjuster(String name) {
    * @param adjustedEquipment a
    *        {@link neqsim.processSimulation.processEquipment.ProcessEquipmentInterface} object
    * @param adjstedVariable a {@link java.lang.String} object
+   * @param unit a string
    */
   public void setAdjustedVariable(ProcessEquipmentInterface adjustedEquipment,
       String adjstedVariable, String unit) {

src/main/java/neqsim/processSimulation/processSystem/ProcessSystem.java

@@ -100,6 +100,9 @@ public void add(ProcessEquipmentInterface operation) {
    * add.
    * </p>
    *
+   * @param position a int
+   * @param operation a {@link neqsim.processSimulation.processEquipment.ProcessEquipmentInterface}
+   *        object
    */
   public void add(int position, ProcessEquipmentInterface operation) {
     ArrayList<ProcessEquipmentInterface> units = this.getUnitOperations();

src/main/java/neqsim/thermo/component/ComponentDesmukhMather.java

@@ -60,9 +60,9 @@ public ComponentDesmukhMather(String component_name, double moles, double molesI
   /** {@inheritDoc} */
   @Override
   public double getGamma(PhaseInterface phase, int numberOfComponents, double temperature,
-      double pressure, PhaseType phaseType, double[][] HValpha, double[][] HVgij,
-      double[][] intparam, String[][] mixRule) {
-    return getGamma(phase, numberOfComponents, temperature, pressure, phaseType);
+      double pressure, PhaseType pt, double[][] HValpha, double[][] HVgij, double[][] intparam,
+      String[][] mixRule) {
+    return getGamma(phase, numberOfComponents, temperature, pressure, pt);
   }
 
   /**
@@ -74,11 +74,11 @@ public double getGamma(PhaseInterface phase, int numberOfComponents, double temp
    * @param numberOfComponents a int
    * @param temperature a double
    * @param pressure a double
-   * @param phaseType the PhaseType of the phase.
+   * @param pt the PhaseType of the phase.
    * @return a double
    */
   public double getGamma(PhaseInterface phase, int numberOfComponents, double temperature,
-      double pressure, PhaseType phaseType) {
+      double pressure, PhaseType pt) {
     double A = 1.174;
 
     double B = 3.32384e9;

src/main/java/neqsim/thermo/component/ComponentGEInterface.java

@@ -27,16 +27,16 @@ public interface ComponentGEInterface extends ComponentInterface {
    * @param numberOfComponents a int
    * @param temperature a double
    * @param pressure a double
-   * @param phaseType the PhaseType of the phase.
+   * @param pt the PhaseType of the phase.
    * @param HValpha an array of {@link double} objects
    * @param HVgij an array of {@link double} objects
    * @param intparam an array of {@link double} objects
    * @param mixRule an array of {@link java.lang.String} objects
    * @return a double
    */
   public double getGamma(PhaseInterface phase, int numberOfComponents, double temperature,
-      double pressure, PhaseType phaseType, double[][] HValpha, double[][] HVgij,
-      double[][] intparam, String[][] mixRule);
+      double pressure, PhaseType pt, double[][] HValpha, double[][] HVgij, double[][] intparam,
+      String[][] mixRule);
 
   /**
    * <p>

src/main/java/neqsim/thermo/component/ComponentGENRTLmodifiedHV.java

@@ -38,11 +38,11 @@ public ComponentGENRTLmodifiedHV(String component_name, double moles, double mol
   /** {@inheritDoc} */
   @Override
   public double getGamma(PhaseInterface phase, int numberOfComponents, double temperature,
-      double pressure, PhaseType phaseType, double[][] HValpha, double[][] HVgij,
-      double[][] intparam, String[][] mixRule) {
+      double pressure, PhaseType pt, double[][] HValpha, double[][] HVgij, double[][] intparam,
+      String[][] mixRule) {
     double[][] HVgijT = new double[numberOfComponents][numberOfComponents];
-    return getGamma(phase, numberOfComponents, temperature, pressure, phaseType, HValpha, HVgij,
-        HVgijT, intparam, mixRule);
+    return getGamma(phase, numberOfComponents, temperature, pressure, pt, HValpha, HVgij, HVgijT,
+        intparam, mixRule);
   }
 
   /**
@@ -54,7 +54,7 @@ public double getGamma(PhaseInterface phase, int numberOfComponents, double temp
    * @param numberOfComponents a int
    * @param temperature a double
    * @param pressure a double
-   * @param phaseType the PhaseType of the phase.
+   * @param pt the PhaseType of the phase.
    * @param HValpha an array of {@link double} objects
    * @param HVgij an array of {@link double} objects
    * @param HVgijT an array of {@link double} objects
@@ -63,7 +63,7 @@ public double getGamma(PhaseInterface phase, int numberOfComponents, double temp
    * @return a double
    */
   public double getGamma(PhaseInterface phase, int numberOfComponents, double temperature,
-      double pressure, PhaseType phaseType, double[][] HValpha, double[][] HVgij, double[][] HVgijT,
+      double pressure, PhaseType pt, double[][] HValpha, double[][] HVgij, double[][] HVgijT,
       double[][] intparam, String[][] mixRule) {
     int type = phase.getInitType();
     double A = 0;

src/main/java/neqsim/thermo/component/ComponentGENRTLmodifiedWS.java

@@ -44,11 +44,11 @@ public double getlnGammadn(int k) {
   /** {@inheritDoc} */
   @Override
   public double getGamma(PhaseInterface phase, int numberOfComponents, double temperature,
-      double pressure, PhaseType phaseType, double[][] WSalpha, double[][] WSgij,
-      double[][] intparam, String[][] mixRule) {
+      double pressure, PhaseType pt, double[][] WSalpha, double[][] WSgij, double[][] intparam,
+      String[][] mixRule) {
     double[][] WSgijT = new double[numberOfComponents][numberOfComponents];
-    return getGamma(phase, numberOfComponents, temperature, pressure, phaseType, WSalpha, WSgij,
-        WSgijT, intparam, mixRule);
+    return getGamma(phase, numberOfComponents, temperature, pressure, pt, WSalpha, WSgij, WSgijT,
+        intparam, mixRule);
   }
 
   /**
@@ -60,7 +60,7 @@ public double getGamma(PhaseInterface phase, int numberOfComponents, double temp
    * @param numberOfComponents a int
    * @param temperature a double
    * @param pressure a double
-   * @param phaseType the PhaseType of the phase.
+   * @param pt the PhaseType of the phase.
    * @param WSalpha an array of {@link double} objects
    * @param WSgij an array of {@link double} objects
    * @param WSgijT an array of {@link double} objects
@@ -70,7 +70,7 @@ public double getGamma(PhaseInterface phase, int numberOfComponents, double temp
    */
   @SuppressWarnings("unused")
   public double getGamma(PhaseInterface phase, int numberOfComponents, double temperature,
-      double pressure, PhaseType phaseType, double[][] WSalpha, double[][] WSgij, double[][] WSgijT,
+      double pressure, PhaseType pt, double[][] WSalpha, double[][] WSgij, double[][] WSgijT,
       double[][] intparam, String[][] mixRule) {
     double type = phase.getInitType();
     double A = 0;
@@ -245,7 +245,7 @@ public double getGamma(PhaseInterface phase, int numberOfComponents, double temp
     // dlngammadt = (lngammaold-lngamma)/0.002;
 
     // phaseny.getExcessGibbsEnergy(numberOfComponents, temperature, pressure,
-    // phaseType)
+    // pt)
     gamma = Math.exp(lngamma);
 
     // if derivates....

src/main/java/neqsim/thermo/component/ComponentGEUnifac.java

@@ -134,10 +134,9 @@ public double getR() {
   /** {@inheritDoc} */
   @Override
   public double fugcoef(PhaseInterface phase, int numberOfComponents, double temperature,
-      double pressure, PhaseType phaseType) {
-    fugacityCoefficient =
-        (this.getGamma(phase, numberOfComponents, temperature, pressure, phaseType)
-            * this.getAntoineVaporPressure(temperature) / pressure);
+      double pressure, PhaseType pt) {
+    fugacityCoefficient = (this.getGamma(phase, numberOfComponents, temperature, pressure, pt)
+        * this.getAntoineVaporPressure(temperature) / pressure);
     return fugacityCoefficient;
   }
 
@@ -190,7 +189,7 @@ public void calclnGammak(int k, PhaseInterface phase) {
   /** {@inheritDoc} */
   @Override
   public double getGamma(PhaseInterface phase, int numberOfComponents, double temperature,
-      double pressure, PhaseType phaseType) {
+      double pressure, PhaseType pt) {
     double lngammaCombinational = 0.0;
     double lngammaResidual = 0.0;
     dlngammadn = new double[numberOfComponents];
@@ -244,37 +243,35 @@ public double getGamma(PhaseInterface phase, int numberOfComponents, double temp
   /** {@inheritDoc} */
   @Override
   public double fugcoefDiffPres(PhaseInterface phase, int numberOfComponents, double temperature,
-      double pressure, PhaseType phaseType) {
-    dfugdp = (Math.log(fugcoef(phase, numberOfComponents, temperature, pressure + 0.01, phaseType))
-        - Math.log(fugcoef(phase, numberOfComponents, temperature, pressure - 0.01, phaseType)))
-        / 0.02;
+      double pressure, PhaseType pt) {
+    dfugdp = (Math.log(fugcoef(phase, numberOfComponents, temperature, pressure + 0.01, pt))
+        - Math.log(fugcoef(phase, numberOfComponents, temperature, pressure - 0.01, pt))) / 0.02;
     return dfugdp;
   }
 
   /** {@inheritDoc} */
   @Override
   public double fugcoefDiffTemp(PhaseInterface phase, int numberOfComponents, double temperature,
-      double pressure, PhaseType phaseType) {
-    dfugdt = (Math.log(fugcoef(phase, numberOfComponents, temperature + 0.01, pressure, phaseType))
-        - Math.log(fugcoef(phase, numberOfComponents, temperature - 0.01, pressure, phaseType)))
-        / 0.02;
+      double pressure, PhaseType pt) {
+    dfugdt = (Math.log(fugcoef(phase, numberOfComponents, temperature + 0.01, pressure, pt))
+        - Math.log(fugcoef(phase, numberOfComponents, temperature - 0.01, pressure, pt))) / 0.02;
     return dfugdt;
   }
 
   /*
    * public double fugcoefDiffPres(PhaseInterface phase, int numberOfComponents, double temperature,
-   * double pressure, PhaseType phaseType){ // NumericalDerivative deriv = new
-   * NumericalDerivative(); // System.out.println("dfugdP : " +
+   * double pressure, PhaseType pt){ // NumericalDerivative deriv = new NumericalDerivative(); //
+   * System.out.println("dfugdP : " + NumericalDerivative.fugcoefDiffPres(this, phase,
+   * numberOfComponents, temperature, pressure, pt)); return
    * NumericalDerivative.fugcoefDiffPres(this, phase, numberOfComponents, temperature, pressure,
-   * phaseType)); return NumericalDerivative.fugcoefDiffPres(this, phase, numberOfComponents,
-   * temperature, pressure, phaseType); }
+   * pt); }
    * 
    * public double fugcoefDiffTemp(PhaseInterface phase, int numberOfComponents, double temperature,
-   * double pressure, PhaseType phaseType){ NumericalDerivative deriv = new NumericalDerivative();
-   * // System.out.println("dfugdT : " + NumericalDerivative.fugcoefDiffTemp(this, phase,
-   * numberOfComponents, temperature, pressure, phaseType)); return
+   * double pressure, PhaseType pt){ NumericalDerivative deriv = new NumericalDerivative(); //
+   * System.out.println("dfugdT : " + NumericalDerivative.fugcoefDiffTemp(this, phase,
+   * numberOfComponents, temperature, pressure, pt)); return
    * NumericalDerivative.fugcoefDiffTemp(this, phase, numberOfComponents, temperature, pressure,
-   * phaseType);
+   * pt);
    * 
    * }
    */

src/main/java/neqsim/thermo/component/ComponentGEUnifacPSRK.java

@@ -143,7 +143,7 @@ public void calclnGammakdT(int k, PhaseInterface phase) {
   /** {@inheritDoc} */
   @Override
   public double getGamma(PhaseInterface phase, int numberOfComponents, double temperature,
-      double pressure, PhaseType phaseType) {
+      double pressure, PhaseType pt) {
     int initType = phase.getInitType();
     double lngammaCombinational = 0.0;
     double lngammaResidual = 0.0;

src/main/java/neqsim/thermo/component/ComponentGEUnifacUMRPRU.java

@@ -354,7 +354,7 @@ public void calclnGammakdTdT(int k, PhaseInterface phase) {
   /** {@inheritDoc} */
   @Override
   public double getGamma(PhaseInterface phase, int numberOfComponents, double temperature,
-      double pressure, PhaseType phaseType) {
+      double pressure, PhaseType pt) {
     int initType = phase.getInitType();
     double lngammaCombinational;
     double lngammaResidual;
@@ -520,22 +520,22 @@ public void calcUnifacGroupParamsdT(PhaseInterface phase) {
    * @param numberOfComponents a int
    * @param temperature a double
    * @param pressure a double
-   * @param phaseType the PhaseType of the phase.
+   * @param pt the PhaseType of the phase.
    */
   public void calcGammaNumericalDerivatives(PhaseInterface phase, int numberOfComponents,
-      double temperature, double pressure, PhaseType phaseType) {
+      double temperature, double pressure, PhaseType pt) {
     phase.setInitType(1);
     for (int i = 0; i < phase.getNumberOfComponents(); i++) {
       double dn = getNumberOfMolesInPhase() / 1e6;
       phase.addMoles(getComponentNumber(), dn);
       x = getNumberOfmoles() / getNumberOfMolesInPhase();
-      getGamma(phase, numberOfComponents, temperature, pressure, phaseType);
+      getGamma(phase, numberOfComponents, temperature, pressure, pt);
       double oldGamma = lngamma;
       phase.addMoles(getComponentNumber(), dn);
 
       x = getNumberOfmoles() / getNumberOfMolesInPhase();
 
-      getGamma(phase, numberOfComponents, temperature, pressure, phaseType);
+      getGamma(phase, numberOfComponents, temperature, pressure, pt);
 
       double dlnGammadn = (oldGamma - lngamma) / dn;
       // System.out.println("dlnGammadn " + dlnGammadn);

src/main/java/neqsim/thermo/component/ComponentGEUniquac.java

@@ -79,22 +79,21 @@ public ComponentGEUniquac(String component_name, double moles, double molesInPha
    * @param numberOfComponents a int
    * @param temperature a double
    * @param pressure a double
-   * @param phaseType the PhaseType of the phase.
+   * @param pt the PhaseType of the phase.
    * @return Fugacity coefficient
    */
   public double fugcoef(PhaseInterface phase, int numberOfComponents, double temperature,
-      double pressure, PhaseType phaseType) {
-    fugacityCoefficient =
-        (this.getGamma(phase, numberOfComponents, temperature, pressure, phaseType)
-            * this.getAntoineVaporPressure(temperature) / pressure);
+      double pressure, PhaseType pt) {
+    fugacityCoefficient = (this.getGamma(phase, numberOfComponents, temperature, pressure, pt)
+        * this.getAntoineVaporPressure(temperature) / pressure);
     return fugacityCoefficient;
   }
 
   /** {@inheritDoc} */
   @Override
   public double getGamma(PhaseInterface phase, int numberOfComponents, double temperature,
-      double pressure, PhaseType phaseType, double[][] HValpha, double[][] HVgij,
-      double[][] intparam, String[][] mixRule) {
+      double pressure, PhaseType pt, double[][] HValpha, double[][] HVgij, double[][] intparam,
+      String[][] mixRule) {
     return 0.0;
   }
 
@@ -107,11 +106,11 @@ public double getGamma(PhaseInterface phase, int numberOfComponents, double temp
    * @param numberOfComponents a int
    * @param temperature a double
    * @param pressure a double
-   * @param phaseType the PhaseType of the phase.
+   * @param pt the PhaseType of the phase.
    * @return a double
    */
   public double getGamma(PhaseInterface phase, int numberOfComponents, double temperature,
-      double pressure, PhaseType phaseType) {
+      double pressure, PhaseType pt) {
     /*
      * double V = 0, F = 0, a, gammaC = 0, gammaR = 0, temp1 = 0, temp2 = 0, temp3=0, temp4 = 0,
      * temp5=0, gamma; int j, k;
@@ -171,14 +170,13 @@ public double getGamma(PhaseInterface phase, int numberOfComponents, double temp
    * @param numberOfComponents a int
    * @param temperature a double
    * @param pressure a double
-   * @param phaseType the PhaseType of the phase.
+   * @param pt the PhaseType of the phase.
    * @return a double
    */
   public double fugcoefDiffPres(PhaseInterface phase, int numberOfComponents, double temperature,
-      double pressure, PhaseType phaseType) {
-    dfugdp = (Math.log(fugcoef(phase, numberOfComponents, temperature, pressure + 0.01, phaseType))
-        - Math.log(fugcoef(phase, numberOfComponents, temperature, pressure - 0.01, phaseType)))
-        / 0.02;
+      double pressure, PhaseType pt) {
+    dfugdp = (Math.log(fugcoef(phase, numberOfComponents, temperature, pressure + 0.01, pt))
+        - Math.log(fugcoef(phase, numberOfComponents, temperature, pressure - 0.01, pt))) / 0.02;
     return dfugdp;
   }
 
@@ -191,30 +189,29 @@ public double fugcoefDiffPres(PhaseInterface phase, int numberOfComponents, doub
    * @param numberOfComponents a int
    * @param temperature a double
    * @param pressure a double
-   * @param phaseType the PhaseType of the phase.
+   * @param pt the PhaseType of the phase.
    * @return a double
    */
   public double fugcoefDiffTemp(PhaseInterface phase, int numberOfComponents, double temperature,
-      double pressure, PhaseType phaseType) {
-    dfugdt = (Math.log(fugcoef(phase, numberOfComponents, temperature + 0.01, pressure, phaseType))
-        - Math.log(fugcoef(phase, numberOfComponents, temperature - 0.01, pressure, phaseType)))
-        / 0.02;
+      double pressure, PhaseType pt) {
+    dfugdt = (Math.log(fugcoef(phase, numberOfComponents, temperature + 0.01, pressure, pt))
+        - Math.log(fugcoef(phase, numberOfComponents, temperature - 0.01, pressure, pt))) / 0.02;
     return dfugdt;
   }
   /*
    * public double fugcoefDiffPres(PhaseInterface phase, int numberOfComponents, double temperature,
-   * double pressure, PhaseType phaseType){ // NumericalDerivative deriv = new
-   * NumericalDerivative(); // System.out.println("dfugdP : " +
+   * double pressure, PhaseType pt){ // NumericalDerivative deriv = new NumericalDerivative(); //
+   * System.out.println("dfugdP : " + NumericalDerivative.fugcoefDiffPres(this, phase,
+   * numberOfComponents, temperature, pressure, pt)); return
    * NumericalDerivative.fugcoefDiffPres(this, phase, numberOfComponents, temperature, pressure,
-   * phaseType)); return NumericalDerivative.fugcoefDiffPres(this, phase, numberOfComponents,
-   * temperature, pressure, phaseType); }
+   * pt); }
    * 
    * public double fugcoefDiffTemp(PhaseInterface phase, int numberOfComponents, double temperature,
-   * double pressure, PhaseType phaseType){ NumericalDerivative deriv = new NumericalDerivative();
-   * // System.out.println("dfugdT : " + NumericalDerivative.fugcoefDiffTemp(this, phase,
-   * numberOfComponents, temperature, pressure, phaseType)); return
+   * double pressure, PhaseType pt){ NumericalDerivative deriv = new NumericalDerivative(); //
+   * System.out.println("dfugdT : " + NumericalDerivative.fugcoefDiffTemp(this, phase,
+   * numberOfComponents, temperature, pressure, pt)); return
    * NumericalDerivative.fugcoefDiffTemp(this, phase, numberOfComponents, temperature, pressure,
-   * phaseType);
+   * pt);
    * 
    * }
    */