def test_multiply(self): #multiplication should error for units with offsets x = PhysicalQuantity('1g') y = PhysicalQuantity('2s') z = PhysicalQuantity('1 degC') self.assertEqual( x.unit * y.unit, PhysicalUnit({ 's': 1, 'kg': 1 }, .001, _get_powers(mass=1, time=1), 0)) self.assertEqual( y.unit * x.unit, PhysicalUnit({ 's': 1, 'kg': 1 }, .001, _get_powers(mass=1, time=1), 0)) try: x.unit * z.unit except TypeError as err: self.assertEqual(str(err), "cannot multiply units with non-zero offset") else: self.fail("Expecting TypeError")
def test_neg_known_Values(self): #__neg__ should flip sign of value for physical quantity x = PhysicalQuantity('5V') self.assertEqual((-x).value, -5) x = PhysicalQuantity('-9.8m') self.assertEqual((-x).value, 9.8)
def test_pow(self): #power should error for offest units and for non-integer powers x = PhysicalQuantity('1m') y = PhysicalQuantity('1degF') z = x**3 self.assertEqual(z.unit, PhysicalQuantity('1m**3').unit) x = z**(1.0 / 3.0) #checks inverse integer units self.assertEqual(x.unit, PhysicalQuantity('1m').unit) #test offset units: try: y**17 except TypeError as err: self.assertEqual(str(err), 'cannot exponentiate units with non-zero offset') else: self.fail('Expecting TypeError') #test non-integer powers try: x**1.2 except TypeError as err: self.assertEqual( str(err), 'Only integer and inverse integer exponents allowed') else: self.fail('Expecting TypeError') try: x**(5.0 / 2.0) except TypeError as err: self.assertEqual( str(err), 'Only integer and inverse integer exponents allowed') else: self.fail('Expecting TypeError')
def test_pi(self): # Fixes issue 786 x = PhysicalQuantity('1rpm') x.convert_to_unit('rad/min') self.assertAlmostEqual(x.value, PhysicalQuantity('6.283185rad/min').value, places=3)
def test_conversion_factor_to(self): #conversion_factor_to should errror for units with different base #power, should error for units with incompativle offset w = PhysicalQuantity('1cm') x = PhysicalQuantity('1m') y = PhysicalQuantity('1degF') z1 = PhysicalQuantity('1degC') z2 = PhysicalQuantity('1degK') self.assertEqual(w.unit.conversion_factor_to(x.unit), 1 / 100.0) try: #incompatible units w.unit.conversion_factor_to(y.unit) except TypeError as err: self.assertEqual(str(err), "Incompatible units") else: self.fail("Expecting TypeError") #compatible offset units self.assertEqual(z1.unit.conversion_factor_to(z2.unit), 1.0) try: #incompatible offset units y.unit.conversion_factor_to(z2.unit) except TypeError as err: msg = "Unit conversion (degF to degK) cannot be expressed as a simple multiplicative factor" self.assertEqual(str(err), msg) else: self.fail("Expecting TypeError")
def test_division(self): #division should error when working with offset units w = PhysicalQuantity('2kg') x = PhysicalQuantity('1g') y = PhysicalQuantity('2s') z = PhysicalQuantity('1 degC') quo = w.unit/x.unit quo2 = x.unit/y.unit self.assertEqual(quo, PhysicalUnit({'kg': 1, 'g': -1}, 1000.0, _get_powers(),0)) self.assertEqual(quo2, PhysicalUnit({'s': -1, 'g': 1}, 0.001, _get_powers(mass=1, time=-1),0)) quo = y.unit/2.0 self.assertEqual(quo, PhysicalUnit({'s': 1, "2.0":-1}, .5, _get_powers(time=1), 0)) quo = 2.0/y.unit self.assertEqual(quo, PhysicalUnit({'s': -1,"2.0":1},2, _get_powers(time=-1),0)) try: x.unit / z.unit except TypeError as err: self.assertEqual(str(err),"cannot divide units with non-zero offset") else: self.fail("Expecting TypeError")
def test_pos_known_Values(self): #should retain sign for value of physical quantity x = PhysicalQuantity('5V') self.assertEqual((+x).value, 5) x = PhysicalQuantity('-9.8m') self.assertEqual((+x).value, -9.8)
def test__is_compatible__known__Values(self): #is_compatible should return True for compatible units and False for #incompatible ones testvals=(('5m', 'cm',True), ('1s', 'ms',True), ('1m', 'ms',False)) for q1, q2, bool in testvals: x = PhysicalQuantity(q1) self.assertEqual(x.is_compatible(q2), bool)
def config_changed(self, update_parent=True): """ Calculate and save our unit conversion factor. """ super(UnitConversionPComp, self).config_changed(update_parent) src = PhysicalQuantity(1.0, self._srcunits) target = self._meta['out0'].get('units') src.convert_to_unit(target) self.grad = src.get_value()
def ensure_init(self): """Make sure our inputs and outputs have been initialized. """ super(UnitConversionPComp, self).ensure_init() src = PhysicalQuantity(1.0, self._srcunits) target = self._meta['out0'].get('units') src.convert_to_unit(target) self.grad = src.get_value()
def test_abs_known_Values(self): #__abs__ should give known result with known input x = PhysicalQuantity('-5V') self.assertEqual(abs(x).unit, x.unit) self.assertEqual(abs(x).value, 5) x = PhysicalQuantity('5V') self.assertEqual(abs(x).unit, x.unit) self.assertEqual(abs(x).value, 5)
def test_prefix_plus_math(self): # From an issue: m**2 converts fine, but cm**2 does not. x1 = convert_units(1.0, 'm**2', 'cm**2') self.assertEqual(x1, 10000.0) # Let's make sure we can dclare some complicated units x = PhysicalQuantity('7200nm**3/kPa*dL') #from issue 825, make sure you can handle single characters before a / x = PhysicalQuantity('1 g/kW')
def unit_xform(node, in_units, out_units): """Transforms an ast into expr*scaler+adder where scaler and adder are from units conversion. """ inpq = PhysicalQuantity(1.0, in_units) outpq = PhysicalQuantity(1.0, out_units) try: scaler, adder = inpq.unit.conversion_tuple_to(outpq.unit) except TypeError: raise TypeError("units '%s' are incompatible with assigning units of '%s'" % (inpq.get_unit_name(), outpq.get_unit_name())) return scaler_adder_xform(node, scaler, adder)
def test_name(self): #name should return a mathematically correct representation of the unit x1 = PhysicalQuantity('1m') x2 = PhysicalQuantity('1kg') y = 1 / x1 self.assertEqual(y.unit.name(), '1/m') y = 1 / x1 / x1 self.assertEqual(y.unit.name(), '1/m**2') y = x1**2 self.assertEqual(y.unit.name(), 'm**2') y = x2 / (x1**2) self.assertEqual(y.unit.name(), 'kg/m**2')
def test_lt(self): x = PhysicalQuantity('1 d') y = PhysicalQuantity('2 d') self.assertTrue(x < y) self.assertTrue(y > x) self.assertEqual(x, x) try: x < 2 except TypeError as err: self.assertEqual("Incompatible types", str(err)) else: self.fail('Expecting TypeError')
def test_in_units_of(self): #in_units_of should return a new PhysicalQuantity with the requested #unit, leaving the old unit as it was x = PhysicalQuantity('5cm') y = x.in_units_of('m') self.assertEqual(y, PhysicalQuantity('0.05m')) self.assertEqual(x, PhysicalQuantity('5cm')) x = PhysicalQuantity('5cm') try: y = x.in_units_of('degC') except TypeError as err: self.assertEqual(str(err), 'Incompatible units') else: self.fail("TypeError expected")
def test_pow_known_Values(self): #__pow__ should give known result with known input #the unit of the power should be the power of the input units #test integer exponent x = PhysicalQuantity('5V') self.assertEqual((x**2).value, 5**2) self.assertEqual((x**2).unit, x.unit**2) #test for inverse integer exponent x = PhysicalQuantity('1m**2') y = PhysicalQuantity('1m') self.assertEqual(x**(1.0 / 2.0), y) self.assertEqual(x / y, y) #test for error from non integer exponent try: x**2.5 except TypeError as err: self.assertEqual( str(err), "Only integer and inverse integer exponents allowed") else: self.fail("Expecting TypeError") #test for error on offset units x = PhysicalQuantity('1degC') try: x**2 except TypeError as err: self.assertEqual(str(err), 'cannot exponentiate units with non-zero offset') else: self.fail("expected TypeError") #test for error if exponent is a PhysicalQuantity try: x**x except TypeError as err: self.assertEqual(str(err), 'Exponents must be dimensionless') else: self.fail("expected TypeError") try: #__rpow__ 2**x except TypeError as err: self.assertEqual(str(err), 'Exponents must be dimensionless') else: self.fail("expected TypeError")
def test_repr_str(self): #__repr__should return a string which could be used to contruct the #unit instance, __str__ should return a string with just the unit #name for str u = PhysicalQuantity('1 d') self.assertEqual(repr(u.unit), "PhysicalUnit({'d': 1},86400.0,%s,0.0)" % _get_powers(time=1)) self.assertEqual(str(u.unit), "<PhysicalUnit d>")
def test_cmp(self): #should error for incompatible units, if they are compatible then it #should cmp on their factors x = PhysicalQuantity('1 d') y = PhysicalQuantity('1 s') z = PhysicalQuantity('1 ft') self.assertTrue(x > y) self.assertEqual(x, x) self.assertTrue(y < x) try: x < z except TypeError as err: self.assertEqual(str(err), "Incompatible units") else: self.fail("Expecting TypeError")
def test_sub_known_Values(self): #subtraction should give known result with known input #__rsub__ should give the negative of __sub__ #the units of the results should be the same as the units of the calling instance known_sub_Values=(('1m', '5m',-4), ('1cm', '1cm',0), ('1cm', '5m',-499.0), ('7km', '1m',6.999)) for q1,q2, sum in known_sub_Values: x = PhysicalQuantity(q1) y = PhysicalQuantity(q2) self.assertEqual((x-y).value, sum) self.assertEqual((x-y).unit, x.unit) self.assertEqual(x.__rsub__(y).value, -sum) self.assertEqual(x.__rsub__(y).unit, x.unit) #test for error if incompatible units q1 = PhysicalQuantity('1cm') q2 = PhysicalQuantity('1kg') try: q1 - q2 except TypeError as err: self.assertEqual(str(err), "Incompatible units") else: self.fail("expecting TypeError") #test offset units q1 = PhysicalQuantity('1degK') q2 = PhysicalQuantity('1degR') q3 = PhysicalQuantity('1degC') result = q1 - q2 self.assertAlmostEqual(result.value, .444,3) self.assertEqual(result.unit, q1.unit) try: q3 - q2 except TypeError as err: msg = "Unit conversion (degR to degC) cannot be expressed as a simple multiplicative factor" self.assertEqual(str(err), msg) else: self.fail('expecting TypeError')
def test_div_known_Values(self): #__div__ should give known result with known input #the unit of the product should be the product of the units #scalar division x = PhysicalQuantity('1cm') y = 12.3 z = 1/12.3 self.assertAlmostEqual((x/y).value, PhysicalQuantity('%f cm'%z).value, 4) self.assertEqual((x/y).unit, PhysicalQuantity('%f cm'%z).unit) self.assertEqual(y/x, PhysicalQuantity('12.3cm**-1')) #unitless result x = PhysicalQuantity('1.0m') y = PhysicalQuantity('5m') quo = 1.0/5 # if quotient is unit-less (that is, x and y are additively compatible) # re-arranges x & y in terms of the known quotient and __rdiv__ and checks for consistency self.assertEqual((x/y), quo) self.assertEqual(x.__rdiv__(y), 1/quo) self.assertEqual(type(x/y), float) x = PhysicalQuantity('3cm') y = PhysicalQuantity('5s') quo = 3.0/5 # if quotient has a unit (x and y are additively incompatible) # re-arranges x & y in terms of the known quotient and __rdiv__ and checks for consistency self.assertEqual((x/y).value, quo) self.assertEqual(x.__rdiv__(y).value, 1/quo) self.assertEqual((x/y).unit, x.unit/y.unit) self.assertEqual(x.__rdiv__(y).unit, y.unit/x.unit) self.assertEqual(str(x/y), '0.6 cm/s')
def test_init(self): #__init__ should have the same result regardless of the #constructor calling pattern x = PhysicalQuantity('1m') y = PhysicalQuantity(1, 'm') self.assertEqual(x.value, y.value) self.assertEqual(x.unit, y.unit) z = PhysicalQuantity('1dam') #check for two letter prefixes #error for improper init argument try: x = PhysicalQuantity('m') except TypeError as err: self.assertEqual(str(err), "No number found in input argument: 'm'") else: self.fail("Expecting TypeError") try: x = PhysicalQuantity('1in') except ValueError as err: self.assertEqual(str(err), "no unit named 'in' is defined") else: self.fail("Expecting ValueError") try: x = PhysicalQuantity(1, None) except TypeError as err: self.assertEqual(str(err), "None is not a unit") else: self.fail("Expecting TypeError")
def test_convert_to_unit(self): #convert_to_unit should change the unit of the calling instance to the requested new unit x = PhysicalQuantity('5cm') x.convert_to_unit('m') self.assertEqual(x, PhysicalQuantity('0.05m')) #Test for no compatible units x = PhysicalQuantity('5cm') try: x.convert_to_unit('kg') except TypeError as err: self.assertEqual(str(err), 'Incompatible units') else: self.fail("TypeError expected") x = PhysicalQuantity('1.0psi') x.convert_to_unit('psf') self.assertEqual(x, PhysicalQuantity('144.0psf'))
def test_sub_known_Values(self): #subtraction should give known result with known input #__rsub__ should give the negative of __sub__ #the units of the results should be the same as the units of the calling instance known_sub_Values = (('1m', '5m', -4), ('1cm', '1cm', 0), ('1cm', '5m', -499.0), ('7km', '1m', 6.999)) for q1, q2, sum in known_sub_Values: x = PhysicalQuantity(q1) y = PhysicalQuantity(q2) self.assertEqual((x - y).value, sum) self.assertEqual((x - y).unit, x.unit) self.assertEqual(x.__rsub__(y).value, -sum) self.assertEqual(x.__rsub__(y).unit, x.unit) #test for error if incompatible units q1 = PhysicalQuantity('1cm') q2 = PhysicalQuantity('1kg') try: q1 - q2 except TypeError as err: self.assertEqual(str(err), "Incompatible units") else: self.fail("expecting TypeError") #test offset units q1 = PhysicalQuantity('1degK') q2 = PhysicalQuantity('1degR') q3 = PhysicalQuantity('1degC') result = q1 - q2 self.assertAlmostEqual(result.value, .444, 3) self.assertEqual(result.unit, q1.unit) try: q3 - q2 except TypeError as err: msg = "Unit conversion (degR to degC) cannot be expressed as a simple multiplicative factor" self.assertEqual(str(err), msg) else: self.fail('expecting TypeError')
def test_conversion_tuple_to(self): #test_conversion_tuple_to shoudl error when units have different power lists w = PhysicalQuantity('1cm') x = PhysicalQuantity('1m') y = PhysicalQuantity('1degF') z1 = PhysicalQuantity('1degC') z2 = PhysicalQuantity('1degK') #check for non offset units self.assertEqual(w.unit.conversion_tuple_to(x.unit), (1 / 100.0, 0)) #check for offset units result = y.unit.conversion_tuple_to(z1.unit) self.assertAlmostEqual(result[0], 0.556, 3) self.assertAlmostEqual(result[1], -32.0, 3) #check for incompatible units try: x.unit.conversion_tuple_to(z1.unit) except TypeError as err: self.assertEqual(str(err), "Incompatible units") else: self.fail("Expecting TypeError")
def test_mul_known_Values(self): #multiplication should give known result with known input #the unit of the product should be the product of the units #PhysicalQuanity * scalar x = PhysicalQuantity('1cm') y = 12.3 self.assertEqual(x * y, PhysicalQuantity('12.3cm')) self.assertEqual(y * x, PhysicalQuantity('12.3cm')) #PhysicalQuantity * PhysicalQuantity x = PhysicalQuantity('1cm') y = PhysicalQuantity('1cm') z = PhysicalQuantity('1cm**-1') self.assertEqual((x * y).value, 1) self.assertEqual((x * y).unit, x.unit * y.unit) self.assertEqual(str(x * y), '1.0 cm**2') #multiplication where the result is dimensionless self.assertEqual((x * z), 1.0) self.assertEqual(type(x * z), float) self.assertEqual(str(x * z), '1.0') x = PhysicalQuantity('7kg') y = PhysicalQuantity('10.5m') self.assertEqual((x * y).value, 73.5) self.assertEqual((x * y).unit, x.unit * y.unit) self.assertEqual(str(x * y), '73.5 kg*m') #test for error from offset units z = PhysicalQuantity('1degC') try: x * z except TypeError as err: self.assertEqual(str(err), "cannot multiply units with non-zero offset") else: self.fail("TypeError expected")
def unit_xform(node, in_units, out_units): """Transforms an ast into expr*scaler+adder where scaler and adder are from units conversion. """ inpq = PhysicalQuantity(1.0, in_units) outpq = PhysicalQuantity(1.0, out_units) try: scaler, adder = inpq.unit.conversion_tuple_to(outpq.unit) except TypeError: raise TypeError( "units '%s' are incompatible with assigning units of '%s'" % (inpq.get_unit_name(), outpq.get_unit_name())) return scaler_adder_xform(node, scaler, adder)
def test_in_base_units(self): #in_base_units() should return a new PhysicalQuantity instance #using the base units, leaving the original instance intact x = PhysicalQuantity(1, '1/h') y = x.in_base_units() self.assertEqual(y, PhysicalQuantity(1/3600.0, '1/s')) self.assertEqual(x, PhysicalQuantity(1, '1/h')) x = PhysicalQuantity(1, 'ft**-3') y = x.in_base_units() self.assertEqual(y, PhysicalQuantity(35.314666721488585, '1/m**3')) x = PhysicalQuantity(1, 'ft**3') y = x.in_base_units() self.assertEqual(y, PhysicalQuantity(0.028316846592000004, 'm**3')) x = PhysicalQuantity('5cm') y = x.in_base_units() self.assertEqual(y, PhysicalQuantity('0.05m')) self.assertEqual(x, PhysicalQuantity('5cm'))
def test_add_known_Values(self): #addition should give known result with known input. #he resulting unit should be the same as the unit of the calling instance #The units of the results should be the same as the units of the calling instance #test addition function for allowed addition values known_add_values = (('1m', '5m', 6), ('1cm', '1cm', 2), ('1cm', '1ft', 31.48)) for q1, q2, result in known_add_values: x = PhysicalQuantity(q1) y = PhysicalQuantity(q2) sum = x + y self.assertEqual(sum.value, result) self.assertEqual(sum.unit, x.unit) #test for error if incompatible units q1 = PhysicalQuantity('1cm') q2 = PhysicalQuantity('1kg') try: q1 + q2 except TypeError as err: self.assertEqual(str(err), "Incompatible units") else: self.fail("expecting TypeError") #test offset units q1 = PhysicalQuantity('1degK') q2 = PhysicalQuantity('1degR') q3 = PhysicalQuantity('1degC') result = q1 + q2 self.assertAlmostEqual(result.value, 1.556, 3) self.assertEqual(result.unit, q1.unit) try: q3 + q2 except TypeError as err: msg = "Unit conversion (degR to degC) cannot be expressed as a simple multiplicative factor" self.assertEqual(str(err), msg) else: self.fail('expecting TypeError')
def test_sin_cos_tan_known_Values(self): #__sin__ should give known result with known input x = PhysicalQuantity('0 rad') x.sin() self.assertEqual(x.sin(), math.sin(x.value)) self.assertEqual(x.cos(), math.cos(x.value)) self.assertEqual(x.tan(), math.tan(x.value)) x = PhysicalQuantity('1m') try: x.sin() except TypeError as err: self.assertEqual(str(err),"Argument of sin must be an angle") else: self.fail("TypeError expected") try: x.cos() except TypeError as err: self.assertEqual(str(err),"Argument of cos must be an angle") else: self.fail("TypeError expected") try: x.tan() except TypeError as err: self.assertEqual(str(err),"Argument of tan must be an angle") else: self.fail("TypeError expected")
def test_nonzero(self): #__nonzero__ should return true in a boolean test x = PhysicalQuantity('1degK') self.assertTrue(x)
def test_sin_cos_tan_known_Values(self): #__sin__ should give known result with known input x = PhysicalQuantity('0 rad') x.sin() self.assertEqual(x.sin(), math.sin(x.value)) self.assertEqual(x.cos(), math.cos(x.value)) self.assertEqual(x.tan(), math.tan(x.value)) x = PhysicalQuantity('1m') try: x.sin() except TypeError as err: self.assertEqual(str(err), "Argument of sin must be an angle") else: self.fail("TypeError expected") try: x.cos() except TypeError as err: self.assertEqual(str(err), "Argument of cos must be an angle") else: self.fail("TypeError expected") try: x.tan() except TypeError as err: self.assertEqual(str(err), "Argument of tan must be an angle") else: self.fail("TypeError expected")
def test_new_units(self): # Hour added to test problem in Classic OpenMDAO Ticket 466 # knot, rev, month added to test problem in Issue 804 x = PhysicalQuantity('7200s') x.convert_to_unit('h') self.assertEqual(x, PhysicalQuantity('2h')) x = PhysicalQuantity('5knot') x.convert_to_unit('nm/h') self.assertEqual(x, PhysicalQuantity('5nmi/h')) x = PhysicalQuantity('33rev/min') x.convert_to_unit('rpm') self.assertEqual(x, PhysicalQuantity('33rpm')) x = PhysicalQuantity('12mo') x.convert_to_unit('yr') self.assertEqual(x, PhysicalQuantity('1yr')) x = PhysicalQuantity('1Mibyte') x.convert_to_unit('Kibyte') self.assertEqual(x, PhysicalQuantity('1024Kibyte'))
def _corrected_massflow(domain, surface, weights, reference_state): """ Returns corrected mass flow for a mesh surface as a :class:`PhysicalQuantity`. """ zone_name, imin, imax, jmin, jmax, kmin, kmax = surface zone = getattr(domain, zone_name) grid = zone.grid_coordinates flow = zone.flow_solution cylindrical = zone.coordinate_system == CYLINDRICAL cell_center = flow.grid_location == CELL_CENTER if cylindrical: c1 = grid.z.item c2 = grid.r.item c3 = grid.t.item else: c1 = grid.x.item c2 = grid.y.item c3 = grid.z.item try: density = flow.density.item if cylindrical: mom_c1 = flow.momentum.z.item mom_c2 = flow.momentum.r.item mom_c3 = flow.momentum.t.item else: mom_c1 = flow.momentum.x.item mom_c2 = flow.momentum.y.item mom_c3 = flow.momentum.z.item pressure = flow.pressure.item except AttributeError: vnames = ('density', 'momentum', 'pressure') raise AttributeError('For corrected mass flow, zone %s is missing' ' one or more of %s.' % (zone_name, vnames)) try: gam = flow.gamma.item except AttributeError: gam = None # Use passed-in scalar gamma. if imin == imax: imax += 1 # Ensure range() returns face index. face_normal = _iface_normal face_value = _iface_cell_value if cell_center else _iface_node_value elif jmin == jmax: jmax += 1 face_normal = _jface_normal face_value = _jface_cell_value if cell_center else _jface_node_value else: kmax += 1 face_normal = _kface_normal face_value = _kface_cell_value if cell_center else _kface_node_value try: lref = reference_state['length_reference'] pref = reference_state['pressure_reference'] rgas = reference_state['ideal_gas_constant'] tref = reference_state['temperature_reference'] if gam is None: gamma = reference_state['specific_heat_ratio'].value except KeyError: vals = ('length_reference', 'pressure_reference', 'ideal_gas_constant', 'temperature_reference', 'specific_heat_ratio') raise AttributeError('For corrected mass flow, reference_state is' ' missing one or more of %s.' % (vals,)) rhoref = pref / rgas / tref vref = (rgas * tref).sqrt() momref = rhoref * vref wref = momref * lref * lref pstd = PhysicalQuantity(14.696, 'psi') pstd.convert_to_unit(pref.get_unit_name()) tstd = PhysicalQuantity(518.67, 'degR') tstd.convert_to_unit(tref.get_unit_name()) lref = lref.value pref = pref.value rgas = rgas.value rhoref = rhoref.value momref = momref.value pstd = pstd.value tstd = tstd.value total = 0. for i in range(imin, imax): ip1 = i + 1 for j in range(jmin, jmax): jp1 = j + 1 for k in range(kmin, kmax): kp1 = k + 1 rho = face_value(density, ip1, jp1, kp1) * rhoref rvu = face_value(mom_c1, ip1, jp1, kp1) * momref rvv = face_value(mom_c2, ip1, jp1, kp1) * momref rvw = face_value(mom_c3, ip1, jp1, kp1) * momref ps = face_value(pressure, ip1, jp1, kp1) * pref if gam is not None: gamma = face_value(gam, ip1, jp1, kp1) sc1, sc2, sc3 = face_normal(c1, c2, c3, i, j, k, cylindrical, lref) w = rvu*sc1 + rvv*sc2 + rvw*sc3 u2 = (rvu*rvu + rvv*rvv + rvw*rvw) / (rho*rho) a2 = (gamma * ps) / rho mach2 = u2 / a2 ts = ps / (rho * rgas) tt = ts * (1. + (gamma-1.)/2. * mach2) pt = ps * pow(1. + (gamma-1.)/2. * mach2, gamma/(gamma-1.)) wc = w * sqrt(tt/tstd) / (pt/pstd) total += wc return PhysicalQuantity(total, wref.get_unit_name())
def execute(self): self.c = PhysicalQuantity(self.a + self.b, 'inch').in_units_of('ft').value self.d = PhysicalQuantity(self.a - self.b, 'inch').in_units_of('ft').value
def test_in_base_units(self): #in_base_units() should return a new PhysicalQuantity instance #using the base units, leaving the original instance intact x = PhysicalQuantity(1, '1/h') y = x.in_base_units() self.assertEqual(y, PhysicalQuantity(1 / 3600.0, '1/s')) self.assertEqual(x, PhysicalQuantity(1, '1/h')) x = PhysicalQuantity(1, 'ft**-3') y = x.in_base_units() self.assertEqual(y, PhysicalQuantity(35.314666721488585, '1/m**3')) x = PhysicalQuantity(1, 'ft**3') y = x.in_base_units() self.assertEqual(y, PhysicalQuantity(0.028316846592000004, 'm**3')) x = PhysicalQuantity('5cm') y = x.in_base_units() self.assertEqual(y, PhysicalQuantity('0.05m')) self.assertEqual(x, PhysicalQuantity('5cm'))
def __init__(self, zone, zone_name, reference_state): flow = zone.flow_solution cylindrical = zone.coordinate_system == CYLINDRICAL # 'pressure' required until we can determine dimensionalized # static pressure from 'Q' variables. try: self.density = flow.density.item momentum = flow.momentum self.pressure = flow.pressure.item except AttributeError: vnames = ('density', 'momentum', 'pressure') raise AttributeError('For corrected_mass_flow, zone %s is missing' ' one or more of %s.' % (zone_name, vnames)) try: self.gam = flow.gamma.item except AttributeError: self.gam = None # Use passed-in scalar gamma. if reference_state is None: raise ValueError('corrected_mass_flow must have units specified') try: lref = reference_state['length_reference'] pref = reference_state['pressure_reference'] rgas = reference_state['ideal_gas_constant'] tref = reference_state['temperature_reference'] if self.gam is None: self.gamma = reference_state['specific_heat_ratio'].value except KeyError: vals = ('length_reference', 'pressure_reference', 'ideal_gas_constant', 'temperature_reference', 'specific_heat_ratio') raise AttributeError('For corrected_mass_flow, reference_state is' ' missing one or more of %s.' % (vals,)) rhoref = pref / rgas / tref vref = (rgas * tref).sqrt() momref = rhoref * vref self.wref = momref * lref * lref pstd = PhysicalQuantity(14.696, 'psi') pstd.convert_to_unit(pref.get_unit_name()) tstd = PhysicalQuantity(518.67, 'degR') tstd.convert_to_unit(tref.get_unit_name()) aref = lref * lref self.aref = aref.value self.pref = pref.value self.rgas = rgas.value self.rhoref = rhoref.value self.momref = momref.value self.pstd = pstd.value self.tstd = tstd.value if cylindrical: self.mom_c1 = None if momentum.z is None else momentum.z.item self.mom_c2 = momentum.r.item self.mom_c3 = momentum.t.item else: self.mom_c1 = momentum.x.item self.mom_c2 = None if momentum.y is None else momentum.y.item self.mom_c3 = None if momentum.z is None else momentum.z.item
def test_integers_in_unit_definition(self): x = PhysicalQuantity('10 1/min') self.assertEqual(x.unit.factor, 1 / 60.0) self.assertEqual(x.unit.powers, _get_powers(time=-1))