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")
