def __init__(self, info:dict, msg:str) -> None:

list.__init__(self)

for key in info:

item = info[key]

shape = item["shape"] if "shape" in item else None

if shape is None: raise Exception("No shape specified for {}, {}".format(key, msg))

if shape == "cylinder":

self.append(Cylinder(key, item, msg))

else:

raise Exception("Unrecognized shape, {}, in {}, {}".format(shape, key, msg))

def dryVolume(self):

volume = 0

for item in self: volume += item.qDry * item.volume

return volume

def wetVolume(self):

volume = 0

for item in self: volume += (not item.qDry) * item.volume

""" API specification """

def __init__(self, name:str) -> None:

self.name = name # Name of the shape

def grid(self, rotation:R=None, offset:np.array=None) -> np.array:

""" Return the grid points, possibly rotated and offset """

position = self.position

if rotation is not None:

# Rotate from body to grid

position = rotation.apply(position, inverse=True)

if offset is not None: position = np.add(position, offset)

return position

def integrate(self, force:np.array, rotation:R=None) -> np.array:

""" Return surface integral over force """

surface = self.surface

if rotation is not None:

surface = rotation.apply(surface, inverse=True)

# integral of dot product

return \

np.sum(surface[:,0] * force[:,0]) + \

np.sum(surface[:,1] * force[:,1]) + \

np.sum(surface[:,2] * force[:,2])

@staticmethod

def mkRotation(angles:list) -> R:

return R.from_euler("ZYX", angles, degrees=True)

@staticmethod

def strRotation(r:R) -> list:

return r.as_euler("ZYX", degrees=True)

# Plotting methods for a shape

@staticmethod

def plotShow(ax=None) -> None:

if ax is not None:

import matplotlib.pyplot as plt

plt.show()

def plotInit(self, ax=None):

if ax is None:

import matplotlib.pyplot as plt

fig = plt.figure()

ax = fig.add_subplot(111, projection="3d")

ax.set_xlabel("X")

ax.set_ylabel("Y")

ax.set_zlabel("Z")

return ax

def plotScatter(self, ax, pos:np.array=None, sz=5):

if pos is None: pos = self.position

ax = self.plotInit(ax)

ax.scatter(pos[:,0], pos[:,1], pos[:,2], s=sz)

return ax

def plotWireFrame(self, ax, pos:np.array=None, rstride=1, cstride=1, color:str=None):

if pos is None: pos = self.position

(x,y,z) = self.wireFrame(pos)

ax = self.plotInit(ax)

ax.plot_wireframe(x, y, z, rstride=rstride, cstride=cstride, color=color)

return ax

def plot(self, ax=None):

""" Cylindrical part of a cylinder with outward pointing normals to surface """

def __init__(self, name:str, info:dict, msg:str) -> None:

Base.__init__(self, name + "::cylinder")

for key in ["length", "radius", "offset", "rotation", "nRadial", "nLength"]:

if key not in info:

raise Exception("Field {} not in {}, {}".format(key, name, msg))

self.__info = info

radius = info["radius"] # Radius of the cylinder

length = info["length"] # Length of cylinder

self.__radius = radius

self.qDry = info["qDry"] if "qDry" in info else False

self.volume = np.pi * radius * radius * length # Volume of cylinder

dTheta = (2 * np.pi) / info["nRadial"] # Step size in theta

dZ = length / info["nLength"] # Step size along axis

self.__area = dZ * self.__radius * dTheta # Area of each element

# Angle to center of each segment

theta = np.arange(dTheta/2, 2 * np.pi, dTheta) # (0, 2pi)

# z of center of each segment

zMax = info["length"] / 2

z = np.arange(-zMax + dZ/2, zMax, dZ) # (-zMax, zMax)

(gTheta, gZ) = np.meshgrid(theta, z) # Grid of all possible theta/z pairs

gTheta = gTheta.ravel() # Change from 2D to 1D without copying

gZ = gZ.ravel() # Change from 2D to 1D without copying

nx = np.cos(gTheta) # x component of outward pointing unit normal vector

ny = np.sin(gTheta) # y component of outward pointing unit normal vector

unitNorm = np.column_stack((nx, ny, np.zeros(nx.shape))) # Outward pointing unit normal

position = np.column_stack((radius * nx, radius * ny, gZ)) # center of each element

# Rotate the cylinder

self.__rotation = self.mkRotation(info["rotation"])

unitNorm = self.__rotation.apply(unitNorm) # Rotate outward pointing normals

position = self.__rotation.apply(position) # Rotate positions of centers

# Offset the cylinder, the unit norm does not change

self.__offset = info["offset"]

self.position = np.add(position, self.__offset) # Position of each surface element

self.surface = self.__area * unitNorm # outward pointing surface vector

def __repr__(self) -> str:

msg = self.name + \

" radius {} area {:.4g} n {} qDry {} volume {:.4g}".format(

self.__radius, self.__area, self.position.shape[0],

self.qDry, self.volume)

msg+= "\n" + self.name + \

" rotation {}".format(self.strRotation(self.__rotation))

msg+= "\n" + self.name + " offset {}".format(self.__offset)

msg+= "\n" + self.name + " area={}".format(self.integrate(self.surface / self.__area))

return msg

def wireFrame(self, position:np.array=None) -> tuple:

""" Return x,y,z for use in plotting a wire frame """

if position is None: position = self.position

nTheta = self.__info["nRadial"]

nZ = self.__info["nLength"]

x = position[:,0].reshape(nTheta, nZ)

y = position[:,1].reshape(nTheta, nZ)

z = position[:,2].reshape(nTheta, nZ)