ansys-pyensight-core 0.7.7__py3-none-any.whl → 0.7.9__py3-none-any.whl

ansys/pyensight/core/utils/variables.py

@@ -7,6 +7,7 @@ import math
 import os
 from typing import TYPE_CHECKING, Dict, List, Optional, Union
 
+from ansys.api.pyensight.calc_funcs import ens_calculator
 from ansys.pyensight.core.utils.parts import convert_variable
 import numpy as np
 
@@ -49,6 +50,12 @@ class Variables:
 
     def __init__(self, ensight: Union["ensight_api.ensight", "ensight"]):
         self.ensight = ensight
+        self._calculator = ens_calculator(self.ensight)
+
+    @property
+    def calculator(self) -> "ens_calculator":
+        """Return the instance of the calculator functions class"""
+        return self._calculator
 
     def _check_for_var_elem(
         self, var_name: str, pobj_list: List["ENS_PART"]
@@ -77,8 +84,8 @@ class Variables:
             #   within the list of parts used to calc var
             #   if NOT then return None
             for prt in pobj_list:
-                if prt not in var.PARTS:
-                    return None
+                if prt not in var.PARTS:  # pragma: no cover
+                    return None  # pragma: no cover
             return var
         return None
 
@@ -153,11 +160,11 @@ class Variables:
         err = -1
         if not pobj_list or not calc_string:
             return False
-        if len(calc_string) > 0 and len(pobj_list) > 0:
+        if len(calc_string) > 0 and len(pobj_list) > 0:  # pragma: no cover
             self.ensight.utils.parts.select_parts(pobj_list)
             err = self.ensight.variables.evaluate(calc_string)  # ,record=1)
-            if err != 0:
-                err_string = "Error calculating " + calc_string
+            if err != 0:  # pragma: no cover
+                err_string = "Error calculating " + calc_string  # pragma: no cover
                 raise RuntimeError(err_string)  # pragma: no cover
         return err == 0
 
@@ -250,15 +257,15 @@ class Variables:
         #
         _pobj_list: List["ENS_PART"]
         _pobj_list = self.ensight.utils.parts.select_parts(pobj_list)
-        if not _pobj_list:
-            return False
+        if not _pobj_list:  # pragma: no cover
+            return False  # pragma: no cover
         #
         # can be using shear force or shear stress
         #
-        if shear_or_force_flag == "Shear stress":
+        if shear_or_force_flag == "Shear stress":  # pragma: no cover
             stemp_string = "Stress"
-        else:
-            stemp_string = "Force"
+        else:  # pragma: no cover
+            stemp_string = "Force"  # pragma: no cover
         # create a surface normal vector variable using the
         # "Normal" function in the variable calculator.
         #
@@ -271,14 +278,14 @@ class Variables:
         #
         new_shear_var_obj: "ENS_VAR"
         shear_var_name: str
-        if _shear_var_obj.LOCATION != self.ensight.objs.enums.ENS_VAR_ELEM:
+        if _shear_var_obj.LOCATION != self.ensight.objs.enums.ENS_VAR_ELEM:  # pragma: no cover
             # tricks for mypy
             values = self._move_var_to_elem(_pobj_list, _shear_var_obj)
             ensvar_values = [v for v in values]
             new_shear_var_obj = ensvar_values[0]
             shear_var_name = new_shear_var_obj.DESCRIPTION
-        else:
-            shear_var_name = _shear_var_obj.DESCRIPTION
+        else:  # pragma: no cover
+            shear_var_name = _shear_var_obj.DESCRIPTION  # pragma: no cover
 
         #
         # Compute the Dot product of the Vector Normal and the FluidShearVector
@@ -357,7 +364,7 @@ class Variables:
         #
         # Calculate the Tangential Shear stress forces by multiplying each of the
         # Components of the Tangential Shear stress with Element Size scalar.
-        if shear_or_force_flag == "Shear stress":
+        if shear_or_force_flag == "Shear stress":  # pragma: no cover
             #
             # Calculate the element area Scalar using the "EleSize function in the Variable Calculator
             #
@@ -390,19 +397,19 @@ class Variables:
                 return False  # pragma: no cover
 
         else:
-            temp_string = (
+            temp_string = (  # pragma: no cover
                 "ENS_Force_Tan_ShearForce_X = ENS_Force_TangentialShear" + stemp_string + "_X"
             )
             if not self._calc_var(_pobj_list, temp_string):  # pragma: no cover
                 return False  # pragma: no cover
 
-            temp_string = (
+            temp_string = (  # pragma: no cover
                 "ENS_Force_Tan_ShearForce_Y = ENS_Force_TangentialShear" + stemp_string + "_Y"
             )
             if not self._calc_var(_pobj_list, temp_string):  # pragma: no cover
                 return False  # pragma: no cover
 
-            temp_string = (
+            temp_string = (  # pragma: no cover
                 "ENS_Force_Tan_ShearForce_Z = ENS_Force_TangentialShear" + stemp_string + "_Z"
             )
             if not self._calc_var(_pobj_list, temp_string):  # pragma: no cover
@@ -508,38 +515,38 @@ class Variables:
         Fy: List[float] = []
         Fz: List[float] = []
         val = self.get_const_val("ENS_Force_Net_Tan_ShearForce_X", pobj_list)
-        if not val:
-            return None
+        if not val:  # pragma: no cover
+            return None  # pragma: no cover
         if val:
             if isinstance(val, list):
                 for v in val:
-                    if not v:
-                        return None
+                    if not v:  # pragma: no cover
+                        return None  # pragma: no cover
                     Fx.append(v)
             else:
                 return None
         val = self.get_const_val("ENS_Force_Net_Tan_ShearForce_Y", pobj_list)
-        if not val:
-            return None
+        if not val:  # pragma: no cover
+            return None  # pragma: no cover
         if val:
             if isinstance(val, list):
                 for v in val:
-                    if not v:
-                        return None
+                    if not v:  # pragma: no cover
+                        return None  # pragma: no cover
                     Fy.append(v)
             else:
                 return None
         val = self.get_const_val("ENS_Force_Net_Tan_ShearForce_Z", pobj_list)
-        if not val:
-            return None
+        if not val:  # pragma: no cover
+            return None  # pragma: no cover
         if val:
             if isinstance(val, list):
                 for v in val:
-                    if not v:
-                        return None
+                    if not v:  # pragma: no cover
+                        return None  # pragma: no cover
                     Fz.append(v)
             else:
-                return None
+                return None  # pragma: no cover
         #
         # Calculate the Total Shear force X, Y, and Z , 10.2.0(d) now case constant variable
         #  Totals are a case constants. We don't do anything with these vars
@@ -621,38 +628,38 @@ class Variables:
             Ft: List[float] = []
             Fa: List[float] = []
             val = self.get_const_val("ENS_Force_Net_Tan_ShearForce_R", pobj_list)
-            if not val:
-                return None
+            if not val:  # pragma: no cover
+                return None  # pragma: no cover
             if val:
                 if isinstance(val, list):
                     for v in val:
-                        if not v:
-                            return None
+                        if not v:  # pragma: no cover
+                            return None  # pragma: no cover
                         Fr.append(v)
                 else:
-                    return None
+                    return None  # pragma: no cover
             val = self.get_const_val("ENS_Force_Net_Tan_ShearForce_T", pobj_list)
             if not val:
-                return None
+                return None  # pragma: no cover
             if val:
                 if isinstance(val, list):
                     for v in val:
-                        if not v:
-                            return None
+                        if not v:  # pragma: no cover
+                            return None  # pragma: no cover
                         Ft.append(v)
                 else:
                     return None
             val = self.get_const_val("ENS_Force_Net_Tan_ShearForce_A", pobj_list)
-            if not val:
-                return None
+            if not val:  # pragma: no cover
+                return None  # pragma: no cover
             if val:
                 if isinstance(val, list):
                     for v in val:
-                        if not v:
-                            return None
+                        if not v:  # pragma: no cover
+                            return None  # pragma: no cover
                         Fa.append(v)
                 else:
-                    return None
+                    return None  # pragma: no cover
             if all([Fr, Fa, Ft, Fx, Fy, Fz]):
                 ret_val = []
                 for ii in range(len(pobj_list)):
@@ -795,8 +802,8 @@ class Variables:
         self.ensight.variables.activate(const_name)  # bug fixed 10.1.6(c)
 
         if const_type == self.ensight.objs.enums.ENS_VAR_CONSTANT_PER_PART:  # new in 10.2
-            if not part_list:
-                part_list = self.ensight.objs.core.PARTS
+            if not part_list:  # pragma: no cover
+                part_list = self.ensight.objs.core.PARTS  # pragma: no cover
 
             plist = self.ensight.utils.parts.get_part_id_obj_name(part_list, "obj")
             ret_val: List[Optional[float]] = []
@@ -804,12 +811,12 @@ class Variables:
             for prt in plist:
                 if isinstance(prt, self.ensight.objs.ENS_PART):
                     val_dict = prt.get_values([const_name])
-                    if val_dict:
+                    if val_dict:  # pragma: no cover
                         val = float(val_dict[const_name][0])
                         if undef_none and np.isclose(
                             val, self.ensight.Undefined, rtol=1e-6, atol=1e-16
                         ):
-                            ret_val.append(None)
+                            ret_val.append(None)  # pragma: no cover
                         else:
                             ret_val.append(val)
                 else:  # pragma: no cover
@@ -827,8 +834,10 @@ class Variables:
         #             scope will be >= 0 if a command language global
         #             (0 if command language global and >0 if local to a file or loop)
         if scope_val == -1 and type_val == 1:  # EnSight constant and float
-            if undef_none and np.isclose(val, self.ensight.Undefined, rtol=1e-6, atol=1e-16):
-                return None
+            if undef_none and np.isclose(
+                val, self.ensight.Undefined, rtol=1e-6, atol=1e-16
+            ):  # pragma: no cover
+                return None  # pragma: no cover
             else:
                 return val
         else:  # pragma: no cover
@@ -926,21 +935,21 @@ class Variables:
         #
         _pobj_list: List["ENS_PART"]
         _pobj_list = self.ensight.utils.parts.select_parts(pobj_list)
-        if not _pobj_list:
-            return False
+        if not _pobj_list:  # pragma: no cover
+            return False  # pragma: no cover
         #
         # makes a new elem var if input var is nodal
         #
         new_pres_var_obj: "ENS_VAR"
         press_var_name: str
-        if _press_var_obj.LOCATION != self.ensight.objs.enums.ENS_VAR_ELEM:
+        if _press_var_obj.LOCATION != self.ensight.objs.enums.ENS_VAR_ELEM:  # pragma: no cover
             # tricks for mypy
             values = self._move_var_to_elem(_pobj_list, _press_var_obj)
             ensvar_values = [v for v in values]
             new_pres_var_obj = ensvar_values[0]
             press_var_name = new_pres_var_obj.DESCRIPTION
         else:
-            press_var_name = _press_var_obj.DESCRIPTION
+            press_var_name = _press_var_obj.DESCRIPTION  # pragma: no cover
 
         #
         # Calculate the Force vector
@@ -1069,38 +1078,38 @@ class Variables:
         Fy: List[float] = []
         Fz: List[float] = []
         val = self.get_const_val("ENS_Force_Net_press_X", pobj_list)
-        if not val:
-            return None
+        if not val:  # pragma: no cover
+            return None  # pragma: no cover
         if val:
             if isinstance(val, list):
                 for v in val:
-                    if not v:
-                        return None
+                    if not v:  # pragma: no cover
+                        return None  # pragma: no cover
                     Fx.append(v)
             else:
-                return None
+                return None  # pragma: no cover
         val = self.get_const_val("ENS_Force_Net_press_Y", pobj_list)
-        if not val:
-            return None
+        if not val:  # pragma: no cover
+            return None  # pragma: no cover
         if val:
             if isinstance(val, list):
                 for v in val:
-                    if not v:
-                        return None
+                    if not v:  # pragma: no cover
+                        return None  # pragma: no cover
                     Fy.append(v)
             else:
-                return None
+                return None  # pragma: no cover
         val = self.get_const_val("ENS_Force_Net_press_Z", pobj_list)
-        if not val:
-            return None
+        if not val:  # pragma: no cover
+            return None  # pragma: no cover
         if val:
             if isinstance(val, list):
                 for v in val:
-                    if not v:
-                        return None
+                    if not v:  # pragma: no cover
+                        return None  # pragma: no cover
                     Fz.append(v)
             else:
-                return None
+                return None  # pragma: no cover
         #
         #
         # Fr, Ft, Fa
@@ -1158,38 +1167,38 @@ class Variables:
             Ft: List[float] = []
             Fa: List[float] = []
             val = self.get_const_val("ENS_Force_Net_press_R", pobj_list)
-            if not val:
-                return None
+            if not val:  # pragma: no cover
+                return None  # pragma: no cover
             if val:
                 if isinstance(val, list):
                     for v in val:
-                        if not v:
-                            return None
+                        if not v:  # pragma: no cover
+                            return None  # pragma: no cover
                         Fr.append(v)
                 else:
-                    return None
+                    return None  # pragma: no cover
             val = self.get_const_val("ENS_Force_Net_press_T", pobj_list)
-            if not val:
-                return None
+            if not val:  # pragma: no cover
+                return None  # pragma: no cover
             if val:
                 if isinstance(val, list):
                     for v in val:
-                        if not v:
-                            return None
+                        if not v:  # pragma: no cover
+                            return None  # pragma: no cover
                         Ft.append(v)
                 else:
-                    return None
+                    return None  # pragma: no cover
             val = self.get_const_val("ENS_Force_Net_press_A", pobj_list)
-            if not val:
-                return None
+            if not val:  # pragma: no cover
+                return None  # pragma: no cover
             if val:
                 if isinstance(val, list):
                     for v in val:
-                        if not v:
-                            return None
+                        if not v:  # pragma: no cover
+                            return None  # pragma: no cover
                         Fa.append(v)
                 else:
-                    return None
+                    return None  # pragma: no cover
             #
             if all([Fr, Ft, Fz, Fx, Fy, Fz]):
                 ret_val = []
@@ -1207,7 +1216,7 @@ class Variables:
                 return ret_val
             else:  # pragma: no cover
                 err_string = "Error getting Fx, Fy, and/or Fz Pressure Net force per part constant values"  # pragma: no cover  # pragma: no cover
-                raise RuntimeError(err_string)
+                raise RuntimeError(err_string)  # pragma: no cover
 
     def _write_out_force_data(
         self,
@@ -1266,6 +1275,7 @@ class Variables:
         """
         frames = (
             self.ensight.objs.core.FRAMES is not None
+            and len(self.ensight.objs.core.FRAMES) > 0
             and "frame_index" in params
             and int(params["frame_index"]) > 0
         )
@@ -1325,7 +1335,7 @@ class Variables:
                         fp.write(
                             ", Pressure Force Radial , Pressure Force Theta , Pressure Force Axial, Total Cyl Pressure Force "
                         )
-                    if shear_force_list:
+                    if shear_force_list:  # pragma: no cover
                         fp.write(
                             ", Shear Force X , Shear Force Y , Shear Force Z , Total Shear Force "
                         )
@@ -1340,7 +1350,7 @@ class Variables:
                             fp.write(
                                 ", Press + Shear Force Radial , Press + Shear Force Theta , Press + Shear Force Axial , Total Press + Shear Force "
                             )
-                    if press_coeff_list:
+                    if press_coeff_list:  # pragma: no cover
                         fp.write(
                             ", Coeff Press X , Coeff Press Y , Coeff Press Z , Total Coeff Press "
                         )
@@ -1348,7 +1358,7 @@ class Variables:
                             fp.write(
                                 ", Coeff Press Radial , Coeff Press Theta , Coeff Press Axial , Total Coeff Press "
                             )
-                    if shear_coeff_list:
+                    if shear_coeff_list:  # pragma: no cover
                         fp.write(
                             ", Coeff Shear X , Coeff Shear Y , Coeff Shear Z , Total Coeff Shear ,"
                         )
@@ -1363,20 +1373,20 @@ class Variables:
                             fp.write(
                                 ", Coeff Press + Shear Radial , Coeff Press + Shear Theta , Coeff Press + Shear Axial , Total Coeff Press + Shear"
                             )
-                    if press_LDS_force_list:
+                    if press_LDS_force_list:  # pragma: no cover
                         fp.write(", Lift Force , Drag Force , Side Force , Total Pressure Force ")
-                    if shear_LDS_force_list:
+                    if shear_LDS_force_list:  # pragma: no cover
                         fp.write(
                             ", Shear Force L , Shear Force D , Shear Force Side , Total Shear Force LDS "
                         )
                         fp.write(
                             ", Press + Shear Force L , Press + Shear Force D , Press + Shear Force Side , Total Press + Shear Force LDS "
                         )
-                    if press_LDS_coeff_list:
+                    if press_LDS_coeff_list:  # pragma: no cover
                         fp.write(
                             ", Lift Coeff Press  , Drag Coeff Press , Side Coeff Press , Total Coeff Press "
                         )
-                    if shear_LDS_coeff_list:
+                    if shear_LDS_coeff_list:  # pragma: no cover
                         fp.write(
                             ", Lift Coeff Shear  , Drag Coeff Shear , Side Coeff Shear , Coeff Shear LDS Total,"
                         )
@@ -1412,7 +1422,7 @@ class Variables:
                         #
                         # shear force components then magnitude
                         #
-                        if shear_force_list:
+                        if shear_force_list:  # pragma: no cover
                             fp.write(" , ")
                             for jj in range(3):
                                 fp.write(str(shear_force_list[ii][jj]))
@@ -1444,7 +1454,7 @@ class Variables:
                         #
                         # Coefficient of pressure force components then magnitude
                         #
-                        if press_coeff_list:
+                        if press_coeff_list:  # pragma: no cover
                             fp.write(" , ")
                             for jj in range(3):
                                 fp.write(str(press_coeff_list[ii][jj]))
@@ -1459,92 +1469,112 @@ class Variables:
                         #
                         # Coefficient shear force components then magnitude
                         #
-                        if shear_coeff_list is not None and press_coeff_list is not None:
-                            fp.write(" , ")
-                            for jj in range(3):
-                                fp.write(str(shear_coeff_list[ii][jj]))
+                        if (
+                            shear_coeff_list is not None and press_coeff_list is not None
+                        ):  # pragma: no cover
+                            if (
+                                len(shear_coeff_list) > 0 and len(press_coeff_list) > 0
+                            ):  # pragma: no cover
                                 fp.write(" , ")
-                            fp.write(str(vec_mag(shear_coeff_list[ii][:3])))
-                            fp.write(" , ")
-                            if frames:
                                 for jj in range(3):
-                                    fp.write(str(shear_coeff_list[ii][jj + 3]))
+                                    fp.write(str(shear_coeff_list[ii][jj]))
                                     fp.write(" , ")
-                                fp.write(str(vec_mag(shear_coeff_list[ii][3:])))
-                                fp.write(" , ")
-                            # sum of pressure and shear Coefficient components then magnitude
-                            for jj in range(3):
-                                temp_list[jj] = press_coeff_list[ii][jj] + shear_coeff_list[ii][jj]
-                                fp.write(str(temp_list[jj]))
-                                fp.write(" , ")
-                            fp.write(str(vec_mag(temp_list)))
-                            if frames:
+                                fp.write(str(vec_mag(shear_coeff_list[ii][:3])))
                                 fp.write(" , ")
+                                if frames:
+                                    for jj in range(3):
+                                        fp.write(str(shear_coeff_list[ii][jj + 3]))
+                                        fp.write(" , ")
+                                    fp.write(str(vec_mag(shear_coeff_list[ii][3:])))
+                                    fp.write(" , ")
+                                # sum of pressure and shear Coefficient components then magnitude
                                 for jj in range(3):
                                     temp_list[jj] = (
-                                        press_coeff_list[ii][jj + 3] + shear_coeff_list[ii][jj + 3]
+                                        press_coeff_list[ii][jj] + shear_coeff_list[ii][jj]
                                     )
                                     fp.write(str(temp_list[jj]))
                                     fp.write(" , ")
                                 fp.write(str(vec_mag(temp_list)))
-                            fp.write(" , ")
+                                if frames:
+                                    fp.write(" , ")
+                                    for jj in range(3):
+                                        temp_list[jj] = (
+                                            press_coeff_list[ii][jj + 3]
+                                            + shear_coeff_list[ii][jj + 3]
+                                        )
+                                        fp.write(str(temp_list[jj]))
+                                        fp.write(" , ")
+                                    fp.write(str(vec_mag(temp_list)))
+                                fp.write(" , ")
                         #
                         # Lift, Drag and Side Force
                         # No cylindrical stuff here
                         # LDS pressure force components then magnitude
                         #
-                        if press_LDS_force_list:
+                        if press_LDS_force_list:  # pragma: no cover
                             for jj in range(3):
                                 fp.write(str(press_LDS_force_list[ii][jj]))
                                 fp.write(" , ")
                             fp.write(str(vec_mag(press_LDS_force_list[ii][:3])))
                             fp.write(" , ")
                         # LDS shear force components then magnitude
-                        if shear_LDS_force_list is not None and press_LDS_force_list is not None:
-                            for jj in range(3):
-                                fp.write(str(shear_LDS_force_list[ii][jj]))
-                                fp.write(" , ")
-                            fp.write(str(vec_mag(shear_LDS_force_list[ii][:3])))
-                            fp.write(" , ")
-                            # LDS sum of pressure and shear forces components then magnitude
-                            for jj in range(3):
-                                temp_list[jj] = (
-                                    press_LDS_force_list[ii][jj] + shear_LDS_force_list[ii][jj]
-                                )
-                                fp.write(str(temp_list[jj]))
-                                fp.write(" , ")
-                            fp.write(str(vec_mag(temp_list)))
-                            fp.write(" , ")
-                        # LDS Coefficient of pressure force components then magnitude
-                        if press_LDS_coeff_list:
-                            for jj in range(3):
-                                fp.write(str(press_LDS_coeff_list[ii][jj]))
+                        if (
+                            shear_LDS_force_list is not None and press_LDS_force_list is not None
+                        ):  # pragma: no cover
+                            if (
+                                len(shear_LDS_force_list) > 0 and len(press_LDS_force_list) > 0
+                            ):  # pragma: no cover
+                                for jj in range(3):
+                                    fp.write(str(shear_LDS_force_list[ii][jj]))
+                                    fp.write(" , ")
+                                fp.write(str(vec_mag(shear_LDS_force_list[ii][:3])))
                                 fp.write(" , ")
-                            fp.write(str(vec_mag(press_LDS_coeff_list[ii][:3])))
-                            fp.write(" , ")
-                        # LDS Coefficient shear force components then magnitude
-                        if shear_LDS_coeff_list is not None and press_LDS_coeff_list is not None:
-                            for jj in range(3):
-                                fp.write(str(shear_LDS_coeff_list[ii][jj]))
+                                # LDS sum of pressure and shear forces components then magnitude
+                                for jj in range(3):
+                                    temp_list[jj] = (
+                                        press_LDS_force_list[ii][jj] + shear_LDS_force_list[ii][jj]
+                                    )
+                                    fp.write(str(temp_list[jj]))
+                                    fp.write(" , ")
+                                fp.write(str(vec_mag(temp_list)))
                                 fp.write(" , ")
-                            fp.write(str(vec_mag(shear_LDS_coeff_list[ii][:3])))
-                            fp.write(" , ")
-                            # LDS sum of pressure and shear Coefficient components then magnitude
-                            for jj in range(3):
-                                temp_list[jj] = (
-                                    press_LDS_coeff_list[ii][jj] + shear_LDS_coeff_list[ii][jj]
-                                )
-                                fp.write(str(temp_list[jj]))
+                            # LDS Coefficient of pressure force components then magnitude
+                            if press_LDS_coeff_list:  # pragma: no cover
+                                for jj in range(3):
+                                    fp.write(str(press_LDS_coeff_list[ii][jj]))
+                                    fp.write(" , ")
+                                fp.write(str(vec_mag(press_LDS_coeff_list[ii][:3])))
                                 fp.write(" , ")
-                            fp.write(str(vec_mag(temp_list)))
-                        fp.write("\n")
+                            # LDS Coefficient shear force components then magnitude
+                            if (  # pragma: no cover
+                                shear_LDS_coeff_list is not None
+                                and press_LDS_coeff_list is not None
+                            ):
+                                if (
+                                    len(shear_LDS_coeff_list) > 0 and len(press_LDS_coeff_list) > 0
+                                ):  # pragma: no cover
+                                    for jj in range(3):
+                                        fp.write(str(shear_LDS_coeff_list[ii][jj]))
+                                        fp.write(" , ")
+                                    fp.write(str(vec_mag(shear_LDS_coeff_list[ii][:3])))
+                                    fp.write(" , ")
+                                    # LDS sum of pressure and shear Coefficient components then magnitude
+                                    for jj in range(3):
+                                        temp_list[jj] = (
+                                            press_LDS_coeff_list[ii][jj]
+                                            + shear_LDS_coeff_list[ii][jj]
+                                        )
+                                        fp.write(str(temp_list[jj]))
+                                        fp.write(" , ")
+                                    fp.write(str(vec_mag(temp_list)))
+                                fp.write("\n")
                     #  FIX ME keep track of and write out totals here when loop is done on last line?
                     fp.close()
                     return True
             except IOError:  # pragma: no cover
                 raise RuntimeError(  # pragma: no cover
                     "Error Failed to open output csv filename for writing '" + filename + "'"
-                )  # pragma: no cover
+                )
         raise RuntimeError("Error no pressure force list to write out")  # pragma: no cover
 
     @staticmethod
@@ -1572,15 +1602,15 @@ class Variables:
         """
         coeffs = []
         qS = area_ref * vel_ref * vel_ref * dens_ref / 2.0
-        if qS > 0:
+        if qS > 0:  # pragma: no cover
             for ff in Forces:
                 coeffs.append(ff / qS)
         else:
-            coeffs = [0.0, 0.0, 0.0, 0.0, 0.0, 0.0]
+            coeffs = [0.0, 0.0, 0.0, 0.0, 0.0, 0.0]  # pragma: no cover
         return coeffs
 
     @staticmethod
-    def _get_up_vec(up_str: str) -> np.array:
+    def _get_up_vec(up_str: str) -> np.array:  # pragma: no cover
         """
         Convert the up_vector string to the actual components
 
@@ -1742,14 +1772,14 @@ class Variables:
         """
         if not frame_index:
             frame_index = 0
-        if not shear_var_type:
+        if not shear_var_type:  # pragma: no cover
             shear_var_type = self.SHEAR_VAR_TYPE_STRESS
         shear_map = {
             self.SHEAR_VAR_TYPE_STRESS: "Shear stress",
             self.SHEAR_VAR_TYPE_FORCE: "Shear force",
         }
-        if not up_vector:
-            up_vector = self.UP_VECTOR_PLUS_Z
+        if not up_vector:  # pragma: no cover
+            up_vector = self.UP_VECTOR_PLUS_Z  # pragma: no cover
         _pobj_list = self.ensight.utils.parts.select_parts(pobj_list)
         computed_press_forces: List[List[float]] = []
         computed_shear_forces: List[List[float]] = []
@@ -1759,15 +1789,15 @@ class Variables:
         computed_shear_forces_lds: List[List[float]] = []
         computed_press_forces_lds_coeffs: List[List[float]] = []
         computed_shear_forces_lds_coeffs: List[List[float]] = []
-        if press_var_obj:
+        if press_var_obj:  # pragma: no cover
             success = self._press_force_xyz_rtz(
                 pobj_list=pobj_list, press_var_obj=press_var_obj, frame_index=frame_index
             )
-            if not success:
-                return None
+            if not success:  # pragma: no cover
+                return None  # pragma: no cover
             temp = self._sum_pressure_forces_xyz_rtz(pobj_list=pobj_list, frame_index=frame_index)
-            if not temp:
-                return None
+            if not temp:  # pragma: no cover
+                return None  # pragma: no cover
             computed_press_forces = temp.copy()
         if shear_var_obj:
             success = self._shear_force_xyz_rtz(
@@ -1789,7 +1819,7 @@ class Variables:
             ]
         )
         # Just making mypy happy
-        if (
+        if (  # pragma: no cover
             coeffs_computation
             and velocity_x_ref is not None
             and velocity_y_ref is not None
@@ -1799,12 +1829,12 @@ class Variables:
         ):
             _vec_mag = vec_mag([velocity_x_ref, velocity_y_ref, velocity_z_ref])
             # We need to compute the force coeffs
-            if computed_press_forces:
+            if computed_press_forces:  # pragma: no cover
                 for part_force in computed_press_forces:
                     computed_press_force_coeffs.append(
                         self._force_coeffs(part_force, area_ref, _vec_mag, density_ref)
                     )
-            if computed_shear_forces:
+            if computed_shear_forces:  # pragma: no cover
                 for part_force in computed_shear_forces:
                     computed_shear_force_coeffs.append(
                         self._force_coeffs(part_force, area_ref, _vec_mag, density_ref)
@@ -1812,7 +1842,7 @@ class Variables:
         lds = all(
             [x is not None for x in [up_vector, velocity_x_ref, velocity_y_ref, velocity_z_ref]]
         )
-        if lds:
+        if lds:  # pragma: no cover
             temp_np_vec = np.array([velocity_x_ref, velocity_y_ref, velocity_z_ref])
             drag_vec = temp_np_vec / np.sqrt(np.dot(temp_np_vec, temp_np_vec))
             up_vec = self._get_up_vec(up_vector)
@@ -1821,83 +1851,84 @@ class Variables:
             # Lift vec normalized
             temp_np_vec = np.cross(side_vec, drag_vec)
             lift_vec = temp_np_vec / np.sqrt(np.dot(temp_np_vec, temp_np_vec))
-            if computed_press_forces:
+            if computed_press_forces:  # pragma: no cover
                 for part_force in computed_press_forces:
                     computed_press_forces_lds.append(
                         self._lds_forces(np.array(part_force), lift_vec, drag_vec, side_vec)
                     )
-            if computed_shear_forces:
+            if computed_shear_forces:  # pragma: no cover
                 for part_force in computed_shear_forces:
                     computed_shear_forces_lds.append(
                         self._lds_forces(np.array(part_force), lift_vec, drag_vec, side_vec)
                     )
-            if coeffs_computation:
-                if computed_press_force_coeffs:
+            if coeffs_computation:  # pragma: no cover
+                if computed_press_force_coeffs:  # pragma: no cover
                     for part_force in computed_press_force_coeffs:
                         computed_press_forces_lds_coeffs.append(
                             self._lds_forces(np.array(part_force), lift_vec, drag_vec, side_vec)
                         )
-                if computed_shear_force_coeffs:
+                if computed_shear_force_coeffs:  # pragma: no cover
                     for part_force in computed_shear_force_coeffs:
                         computed_shear_forces_lds_coeffs.append(
                             self._lds_forces(np.array(part_force), lift_vec, drag_vec, side_vec)
                         )
-        if export_filename is not None and pobj_list is not None:
-            press_varname = None
-            shear_varname = None
-            if press_var_obj:
-                _press_var_id = convert_variable(self.ensight, press_var_obj)
-                if _press_var_id:
-                    press_varnames = [
-                        v for v in self.ensight.objs.core.VARIABLES if v.ID == _press_var_id
-                    ]
-                    if press_varnames:
-                        press_varname = str(press_varnames[0].DESCRIPTION)
-            if shear_var_obj:
-                _shear_var_id = convert_variable(self.ensight, shear_var_obj)
-                if _shear_var_id:
-                    shear_varnames = [
-                        v for v in self.ensight.objs.core.VARIABLES if v.ID == _press_var_id
-                    ]
-                    if shear_varnames:
-                        shear_varname = str(shear_varnames[0].DESCRIPTION)
-            params = {}
-            if press_varname:
-                params["press_varname"] = press_varname
-            if shear_varname:
-                params["shear_varname"] = shear_varname
-            if shear_var_type is not None:
-                value = shear_map.get(shear_var_type)
-                if value:
-                    params["shear_vartype"] = value
-            if area_ref:
-                params["Area_ref"] = str(area_ref)
-            if density_ref:
-                params["Dens_ref"] = str(density_ref)
-            if velocity_x_ref:
-                params["Vx_ref"] = str(velocity_x_ref)
-            if velocity_y_ref:
-                params["Vy_ref"] = str(velocity_y_ref)
-            if velocity_z_ref:
-                params["Vz_ref"] = str(velocity_z_ref)
-            if up_vector:
-                params["up_vector"] = up_vector
-            if frame_index > 0:
-                params["frame_index"] = str(frame_index)
-
-            self._write_out_force_data(
-                export_filename,
-                _pobj_list,
-                params=params,
-                press_force_list=computed_press_forces,
-                shear_force_list=computed_shear_forces,
-                press_coeff_list=computed_press_force_coeffs,
-                shear_coeff_list=computed_shear_force_coeffs,
-                press_LDS_force_list=computed_press_forces_lds,
-                shear_LDS_force_list=computed_shear_forces_lds,
-                press_LDS_coeff_list=computed_press_forces_lds_coeffs,
-                shear_LDS_coeff_list=computed_shear_forces_lds_coeffs,
-            )
+        if export_filename is not None and pobj_list is not None:  # pragma: no cover
+            if len(pobj_list) > 0:  # pragma: no cover
+                press_varname = None
+                shear_varname = None
+                if press_var_obj:  # pragma: no cover
+                    _press_var_id = convert_variable(self.ensight, press_var_obj)
+                    if _press_var_id:  # pragma: no cover
+                        press_varnames = [
+                            v for v in self.ensight.objs.core.VARIABLES if v.ID == _press_var_id
+                        ]
+                        if press_varnames:
+                            press_varname = str(press_varnames[0].DESCRIPTION)
+                if shear_var_obj:  # pragma: no cover
+                    _shear_var_id = convert_variable(self.ensight, shear_var_obj)
+                    if _shear_var_id:  # pragma: no cover
+                        shear_varnames = [
+                            v for v in self.ensight.objs.core.VARIABLES if v.ID == _press_var_id
+                        ]
+                        if shear_varnames:  # pragma: no cover
+                            shear_varname = str(shear_varnames[0].DESCRIPTION)
+                params = {}
+                if press_varname:  # pragma: no cover
+                    params["press_varname"] = press_varname
+                if shear_varname:  # pragma: no cover
+                    params["shear_varname"] = shear_varname
+                if shear_var_type is not None:  # pragma: no cover
+                    value = shear_map.get(shear_var_type)
+                    if value:  # pragma: no cover
+                        params["shear_vartype"] = value
+                if area_ref is not None:  # pragma: no cover
+                    params["Area_ref"] = str(area_ref)
+                if density_ref is not None:  # pragma: no cover
+                    params["Dens_ref"] = str(density_ref)
+                if velocity_x_ref is not None:  # pragma: no cover
+                    params["Vx_ref"] = str(velocity_x_ref)
+                if velocity_y_ref is not None:  # pragma: no cover
+                    params["Vy_ref"] = str(velocity_y_ref)
+                if velocity_z_ref is not None:  # pragma: no cover
+                    params["Vz_ref"] = str(velocity_z_ref)
+                if up_vector is not None:  # pragma: no cover
+                    params["up_vector"] = up_vector
+                if frame_index > 0:
+                    params["frame_index"] = str(frame_index)
+
+                self._write_out_force_data(
+                    export_filename,
+                    _pobj_list,
+                    params=params,
+                    press_force_list=computed_press_forces,
+                    shear_force_list=computed_shear_forces,
+                    press_coeff_list=computed_press_force_coeffs,
+                    shear_coeff_list=computed_shear_force_coeffs,
+                    press_LDS_force_list=computed_press_forces_lds,
+                    shear_LDS_force_list=computed_shear_forces_lds,
+                    press_LDS_coeff_list=computed_press_forces_lds_coeffs,
+                    shear_LDS_coeff_list=computed_shear_forces_lds_coeffs,
+                )
         return {
             "pressure_forces": {
                 p.DESCRIPTION: computed_press_forces[idx]