def __init__(self): self.__name = "Unknown" #Model name, please read doc self.__type = "Unknown" self.__oil_capacity = 0 self.__oil_consume = 0 self.__entire_dimension = Dimension() self.__trunk_dimension = Dimension() #In here dim refer to capacity
def __init__(self, w: int = None, d: int = None, h: int = None, typeName=None): Dimension.__init__(self, w, d, h) self.boxType = typeName
def parseDimensions(self, logging=None): if logging is None: logging = Logger().getLogger() if self.viewType == 'VIEW' or self.viewType == 'PDT' or self.viewType == 'NDT' or self.viewType == 'EXTENDED': viewDimensions = [] viewMeasures = [] viewDimensionGroups = [] if 'dimensions' in self.parsedView: viewDimensions = self.parsedView['dimensions'] logging.info("Dimensions in parsed View") logging.info(viewDimensions) if 'measures' in self.parsedView: viewMeasures = self.parsedView['measures'] logging.info("Dimensions in parsed View") logging.info(viewMeasures) if 'dimension_groups' in self.parsedView: viewDimensionGroups = self.parsedView['dimension_groups'] logging.info("Dimension Groups in parsed View") logging.info(viewDimensionGroups) self.parsedDimensions = Dimension().processDimensions( viewDimensions, viewMeasures, viewDimensionGroups, logging) msg = """ View : {} Info : Parsed Dimensions """.format(self.name) logging.info(msg) for dim in self.parsedDimensions: logging.info(dim)
def test_get_available_units(self): """Test that I can get the available units.""" self.assertEqual(set(PhysicalQuantity(Dimension()).get_available_units()), set(["1"])) # test only whether it's a subset, so it doesn't fail as I add more units self.assertTrue(set(["kg", "kilogram", "g", "gram"]) <= set(PhysicalQuantity(Dimension(M = 1)).get_available_units())) self.assertTrue(set(["m/s", "meters/second", "miles/hour", "mi/hr"]) <= set(Speed().get_available_units()))
def test_add_subtract_dimension(self): """Add and subtract dimensions doesn't change anything.""" d1 = Dimension(L=1, T=-1) d2 = Dimension(d1) d3 = d1 + d2 self.assertTrue(d3 == d1) d4 = d1 - d2 self.assertTrue(d4 == d1)
def test_create_from_other_dimension(self): """Create dimensions from other dimensions.""" d1 = Dimension(L=1, T=-1) d2 = Dimension(d1) self.assertEqual(d2.M, 0) self.assertEqual(d2.L, 1) self.assertEqual(d2.T, -1) self.assertEqual(d2.Q, 0) self.assertEqual(d2.Theta, 0)
def test_repr(self): """Test that I can use repr() to recreate a Dimension object.""" d1 = Dimension() d2 = eval(repr(d1)) self.assertEqual(d1, d2) # a time with a long representation d1 = Dimension(T=1 / 3) d2 = eval(repr(d1)) self.assertEqual(d1, d2)
def test_for_equality(self): """Equality is based on dimension content.""" d1 = Dimension() d2 = Dimension(L=1, T=-1) self.assertTrue(d1 != d2) self.assertFalse(d1 == d2) d3 = Dimension(L=0) self.assertTrue(d1 == d3) self.assertFalse(d1 != d3)
def processNDTColumns(self, exploreSourceView, columns, logging=None): if logging is None: logging = Logger().getLogger() columns_ = [] column = [] for column_ in columns: logging.ino("Processing Column.") logging.info(column_) print(column_) if column_.columnType == 'COLUMN': fieldName = column_.transformExploreField( self.exploreSourceName, column_.field) dimension_temp = Dimension() dimension_temp = dimension_temp.getDimensionByName( fieldName, exploreSourceView.allDimensions) if dimension_temp is not None: column_.sql = dimension_temp.sql column_.dimensionType = dimension_temp.dimensionType() for column_ in columns: if column_.columnType == 'DERIVED_COLUMN': processedSQL = column_.sql possibleColumns = column_.sql.split(' ') isMeasure = False for possibleColumn in possibleColumns: baseColumn = column_.getColumnByName( possibleColumn, columns) if baseColumn: if baseColumn.dimensionType == "MEASURE": isMeasure = True processedSQL = processedSQL.replace( baseColumn.name, baseColumn.sql) column_.sql = processedSQL if isMeasure: column_.dimensionType = "MEASURE" else: column_.dimensionType = "DIMENSION" print(column_) for dimension_ in self.allDimensions: logging.info(dimension_) print(dimension_) column_ = Column().getColumnByName(dimension_.name, columns) if column_ is not None: dimension_.sql = column_.sql dimension_.dimensionType = column_.dimensionType
def display(self, image, boundingBox=(800, 800), title='Image'): #stopwatch.pause() if boundingBox: maxDimension = Dimension(boundingBox[0], boundingBox[1]) displayDimension = Dimension(image.shape[1], image.shape[0]) displayDimension.fitInside(maxDimension) print("Display Dimmension: ", tuple(displayDimension)) image = cv2.resize(image, tuple(displayDimension)) cv2.namedWindow(title, cv2.WINDOW_AUTOSIZE) cv2.imshow(title, image) cv2.waitKey()
def test_for_primitive_dimension(self): """Some dimensions may be 'primitive'.""" # Primitive dimensions self.assertTrue(Dimension().is_primitive() ) # convention: dimensionless is primitive self.assertTrue(Dimension(M=1).is_primitive()) self.assertTrue(Dimension(L=1).is_primitive()) self.assertTrue(Dimension(T=1).is_primitive()) self.assertTrue(Dimension(Q=1).is_primitive()) self.assertTrue(Dimension(Theta=1).is_primitive()) # Derived dimensions self.assertFalse(Dimension(M=2).is_primitive()) self.assertFalse(Dimension(L=1, T=1).is_primitive()) self.assertFalse(Dimension(L=1, T=-1).is_primitive()) self.assertFalse(Dimension(T=-1).is_primitive())
def display(self, image, boundingBox=(800,800), title='Image'): stopwatch.pause() if boundingBox: maxDimension = Dimension(boundingBox[0], boundingBox[1]) displayDimension = Dimension(image.shape[1], image.shape[0]) displayDimension.fitInside(maxDimension) image = cv2.resize(image, tuple(displayDimension)) cv2.namedWindow(title, cv2.CV_WINDOW_AUTOSIZE) cv2.imshow(title, image) cv2.waitKey() stopwatch.unpause()
def __init__(self, dimension=Dimension(), value=None): """Initialization value may be either a string (to be parsed) or another object of the same dimensions.""" if type(dimension) != Dimension: raise PhysicalQuantityError self.dimension = dimension # create the parser if it doesn't exist already. Index by string representation dimension_str = dimension.str() if dimension_str not in PhysicalQuantity._parsers: PhysicalQuantity._parsers[ dimension_str] = PhysicalQuantityStringParser( dimension, PhysicalQuantity._primitive_units) self._parser = PhysicalQuantity._parsers[dimension_str] # choose default units for printing and store if they're not stored already if dimension_str not in PhysicalQuantity._default_units: # choose basic units (something that gives a conversion of 1) and the shortest representation candidates = [ k for (k, v) in self._parser.flat_units_dictionary.iteritems() if v == 1 ] PhysicalQuantity._default_units[dimension_str] = min(candidates, key=len) self._default_unit_for_printing = PhysicalQuantity._default_units[ dimension_str] self._amount_in_basic_units = None if value is not None: if type(value) == str: self._amount_in_basic_units = self._parser(value) else: if self.dimension != value.dimension: raise IncompatibleUnitsError self._amount_in_basic_units = value._amount_in_basic_units
def test_multiply_and_divide_dimensions(self): """Multiply and divide dimensions.""" d1 = Dimension(L=4, T=-1) d2 = Dimension(L=1, M=2, T=1) d3 = d1 * d2 self.assertEqual(d3.M, 2) self.assertEqual(d3.L, 5) self.assertEqual(d3.T, 0) self.assertEqual(d3.Q, 0) self.assertEqual(d3.Theta, 0) d4 = d1 / d2 self.assertEqual(d4.M, -2) self.assertEqual(d4.L, 3) self.assertEqual(d4.T, -2) self.assertEqual(d4.Q, 0) self.assertEqual(d4.Theta, 0)
def __rtruediv__(self, other): if isinstance(other, Number): other = PhysicalQuantity(Dimension(), "%s" % other) new_dimension = other.dimension / self.dimension result = PhysicalQuantityFactory().new(new_dimension) result._amount_in_basic_units = other._amount_in_basic_units / self._amount_in_basic_units return result
def test_create_dimension(self): """Simple Dimension objects.""" # default: dimensionless d1 = Dimension() self.assertEqual(d1.M, 0) # mass self.assertEqual(d1.L, 0) # length self.assertEqual(d1.T, 0) # time self.assertEqual(d1.Q, 0) # electric charge self.assertEqual(d1.Theta, 0) # absolute temperature # any omitted dimensions are zero d2 = Dimension(L=1, T=2, M=-1) self.assertEqual(d2.M, -1) self.assertEqual(d2.L, 1) self.assertEqual(d2.T, 2) self.assertEqual(d2.Q, 0) self.assertEqual(d2.Theta, 0)
class Energy(PhysicalQuantity): """Energy: Need to define additional synonyms.""" _dim = Dimension(M=1, L=2, T=-2) _Btu_2_J = 1055.05585 def __init__(self, value=None): super(Energy, self).__init__(Energy._dim, value) def __getitem__(self, key): if key == 'J': return self._amount_in_basic_units / self._parser.flat_units_dictionary[ 'kgm^2/s^2'] elif key == 'Btu': return self._amount_in_basic_units / self._parser.flat_units_dictionary[ 'kgm^2/s^2'] / self._Btu_2_J else: return super(Energy, self).__getitem__(key) def __setitem__(self, key, value): if key == 'J': self._amount_in_basic_units = value * self._parser.flat_units_dictionary[ 'kgm^2/s^2'] elif key == 'Btu': self._amount_in_basic_units = value / self._parser.flat_units_dictionary[ 'kgm^2/s^2'] * self._Btu_2_J else: super(Energy, self).__setitem__(key, value)
def test_str(self): """str() prints a reasonable form for the quantity.""" # dimensionless case p = PhysicalQuantity(Dimension(), "2.1e2") self.assertEqual(str(p), "210") # For quantities that are NOT dimensionless we use the "basic unit" (whatever has a unit conversion # factor, so it's SI in our case) with the shortest string representation. # Also, in both the numerator and denominator the order followed is M L T Q Theta p = Speed("60 km/min") self.assertEqual(str(p), "1000 m/s") p = PhysicalQuantity(Dimension(Q = 1), "4 coulomb") self.assertEqual(str(p), "4 C") p = Temperature("4 kelvin") self.assertEqual(str(p), "4 K") p = Speed("30m/s")/Time("2s")/PhysicalQuantity(Dimension(M = 1), "3kg") self.assertEqual(str(p), "5 m/kgs^2")
class Temperature(PhysicalQuantity): """Temperature: need to add some conversions that are not just factors.""" _dim = Dimension(Theta=1) def __init__(self, value=None): super(Temperature, self).__init__(Temperature._dim, value) def __getitem__(self, key): if key == 'C': K = self._amount_in_basic_units / self._parser.flat_units_dictionary[ 'K'] return K - 273.15 elif key == 'F': C = self._amount_in_basic_units / self._parser.flat_units_dictionary[ 'K'] - 273.15 return C * 9 / 5 + 32 else: return super(Temperature, self).__getitem__(key) def __setitem__(self, key, value): if key == 'C': self._amount_in_basic_units = ( value + 273.15) * self._parser.flat_units_dictionary['K'] elif key == 'F': self._amount_in_basic_units = ( (value - 32) * 5 / 9 + 273.15) / self._parser.flat_units_dictionary['K'] else: super(Temperature, self).__setitem__(key, value)
def test_comparisons(self): """All comparisons should be available between quantities of the same type.""" p1 = PhysicalQuantity(Dimension(L = 1), "2m") p2 = PhysicalQuantity(Dimension(L = 1), "2m") self.assertTrue(p1 == p2) self.assertTrue(p1 >= p2) self.assertTrue(p1 <= p2) self.assertFalse(p1 != p2) self.assertFalse(p1 < p2) self.assertFalse(p1 > p2) p2['km'] = 1 self.assertFalse(p1 == p2) self.assertFalse(p1 >= p2) self.assertTrue(p1 <= p2) self.assertTrue(p1 != p2) self.assertFalse(p1 > p2) self.assertTrue(p1 < p2)
def test_create_simple_distances(self): """Simple distances.""" # Check consistency for unit,meters in self.meters_in.iteritems(): d = Distance('1' + unit) # create "1x" where x is the unit self.assertEqual(d['m'], meters) # the meters should be correct # Check creating from other distances d1 = Distance("1 m") d2 = Distance(d1) self.assertEqual(d1['m'], d2['m']) # Check creating from another quantity with same dimensions d1 = PhysicalQuantity(Dimension(L = 1), "1 m") d2 = Distance(d1) self.assertEqual(d1['m'], d2['m']) # Check creating from another quantity with different dimensions d1 = PhysicalQuantity(Dimension(T = 1), "1 s") self.assertRaises(IncompatibleUnitsError, Distance, d1)
def test_create_simple_masses(self): """Simple masses.""" # Check consistency for unit,kilograms in self.kilograms_in.iteritems(): m = Mass('1' + unit) # create "1x" where x is the unit self.assertEqual(m['kg'], kilograms) # the kilograms should be correct # Check creating from other distances m1 = Mass("1 kg") m2 = Mass(m1) self.assertEqual(m1['kg'], m2['kg']) # Check creating from another quantity with same dimensions m1 = PhysicalQuantity(Dimension(M = 1), "1 kg") m2 = Mass(m1) self.assertEqual(m1['kg'], m2['kg']) # Check creating from another quantity with different dimensions t = PhysicalQuantity(Dimension(T = 1), "1 s") self.assertRaises(IncompatibleUnitsError, Mass, t)
def test_repr(self): """repr() should give something that can be used to recreate the object.""" p1 = PhysicalQuantity(Dimension(L = 1), "2m") p2 = eval(repr(p1)) self.assertEqual(p1, p2) # special case: dimensionless quantities p1 = PhysicalQuantity(Dimension(), "2") p2 = eval(repr(p1)) self.assertEqual(p1, p2) # derived quantities should also work t1 = Time("3 min") t2 = eval(repr(t1)) self.assertEqual(t1, t2) # a more complicated case p1 = Speed("30m/s")/Time("2s")/PhysicalQuantity(Dimension(M = 1), "3kg") p2 = eval(repr(p1)) self.assertEqual(p1, p2)
def __rsub__(self, other): if isinstance(other, Number): other = PhysicalQuantity(Dimension(), "%s" % other) if self.dimension != other.dimension: raise IncompatibleUnitsError result = PhysicalQuantityFactory().new(self.dimension) result._amount_in_basic_units = other._amount_in_basic_units - self._amount_in_basic_units return result
def read_params(filename): with open(filename) as csvfile: db = csv.DictReader(csvfile) for row in db: D = Dimension(row['D']) E = Dimension(row['E']) A = Dimension(row['A']) L = Dimension(row['L']) family = row["family"].upper() parms = Params(D,E,A,L,family, modelName = ("%s%dX%dX%dL%d" % (family, int(D.nom*100), int(E.nom*100), int(A.max*100), int(L.nom*100)) ), rotation = 0 ) all_params[parms.modelName] = parms
class Speed(PhysicalQuantity): _dim = Dimension(L=1, T=-1) def __init__(self, value=None): super(Speed, self).__init__(Speed._dim, value) def pace(self, distance): """Return time to cover given distance.""" return distance / self
def SetMachineType(self, type: str) -> bool: if type == 'M1': dim_1 = Dimension() dim_1.SetDimension(120, 40, 90, 100) self.__dimension = dim_1 if type == 'M2': dim_2 = Dimension() dim_2.SetDimension(90, 30, 80, 140) self.__dimension = dim_2 if type == 'M3': dim_3 = Dimension() dim_3.SetDimension(70, 60, 110, 150) self.__dimension = dim_3
def test_create_with_bad_input(self): """Create dimensions with bad inputs.""" d1 = Dimension(L=1, T=-1) # too many arguments self.assertRaises(DimensionError, Dimension, d1, d1) # if only one positional argument, it should be a dimension self.assertRaises(DimensionError, Dimension, 4) # if dimension given, nothing else should be there self.assertRaises(DimensionError, Dimension, d1, L=1) # Keyword arguments should only be in L,M,T,Q,Theta self.assertRaises(DimensionError, Dimension, L=1, s=2)
def test_type_guessing_in_general(self): """The library should find the proper type depending on dimensions.""" d = Distance("10m") t = Time("5s") self.assertEqual(type(d/t), Speed) v = Speed("10mi/hr") self.assertEqual(type(v*t), Distance) # charge density rho = PhysicalQuantity(Dimension(L = -3, Q = 1), "4C/m^3") q = rho*d*d*d self.assertEqual(type(q), Charge) self.assertEqual(q['C'], 4000) # Note: this doesn't work for a quantity explicitly defined as a PhysicalQuantity T1 = Temperature("3 K") T2 = PhysicalQuantity(Dimension(Theta = 1), "3 K") self.assertEqual(T1, T2) self.assertEqual(type(T1), Temperature) self.assertEqual(type(T2), PhysicalQuantity) # But a multiplication or division by a dimensionless quantity should fix that T3 = T2/PhysicalQuantity(Dimension(), "1") self.assertEqual(type(T3), Temperature)
def test_create_simply_physical_quantity(self): """Simple physical quantities.""" d = Dimension(L = 1) p = PhysicalQuantity(d, "3m") self.assertEqual(p['m'], 3) self.assertEqual(p['meters'], 3) self.assertEqual(p['km'], 0.003) self.assertEqual(p['kilometers'], 0.003) p['km'] = 2 self.assertEqual(p['m'], 2000) self.assertEqual(p['meters'], 2000) self.assertEqual(p['km'], 2) self.assertEqual(p['kilometers'], 2)
def test_dimensionless_quantity(self): """Test dimensionless quantities.""" d = Dimension() # creating p = PhysicalQuantity(d) # assigning & getting the value. The "unit" is "1": need a better interface. p["1"] = 4 self.assertEqual(p["1"], 4) # creating from a string p = PhysicalQuantity(d, "7") self.assertEqual(p["1"], 7) # creating from a string: trying to use "1" as unit in the string fails self.assertRaises(BadInputError, PhysicalQuantity, d, "7 1")