def createMg(self, forest, nlevels=2, order=3):
# Create the forest
forest.balance(1)
forest.repartition()
forest.setMeshOrder(order)
# Create the forests
forests = [forest]
assemblers = [self.createTACS(forest)]
if order == 3:
forests.append(forests[-1].duplicate())
forests[-1].balance(1)
forests[-1].repartition()
forests[-1].setMeshOrder(2)
assemblers.append(self.createTACS(forests[-1]))
for i in range(nlevels - 1):
forests.append(forests[-1].coarsen())
forests[-1].balance(1)
forests[-1].repartition()
forests[-1].setMeshOrder(2)
assemblers.append(self.createTACS(forests[-1]))
# Create the multigrid object
mg = TMR.createMg(assemblers, forests)
return assemblers[0], mg
def createTopoProblem(props,
forest,
order=2,
nlevels=2,
Xscale=1.0,
ordering=TACS.PY_MULTICOLOR_ORDER):
# Create the forest
forests = []
filters = []
assemblers = []
varmaps = []
vecindices = []
# Create the trees, rebalance the elements and repartition
forest.balance(1)
forest.repartition()
forests.append(forest)
# Create the filter
filtr = forest.coarsen()
filtr.balance(1)
filters.append(filtr)
# Make the creator class
creator = CreateMe(bcs, filters[-1], props)
assemblers.append(
creator.createTACS(forest, scale=Xscale, ordering=ordering))
varmaps.append(creator.getMap())
vecindices.append(creator.getIndices())
for i in range(nlevels - 1):
forest = forests[-1].coarsen()
forest.balance(1)
forest.repartition()
forests.append(forest)
# Create the filter
filtr = forest.coarsen()
filtr.balance(1)
filters.append(filtr)
# Make the creator class
creator = CreateMe(bcs, filters[-1], props)
assemblers.append(
creator.createTACS(forest, scale=Xscale, ordering=ordering))
varmaps.append(creator.getMap())
vecindices.append(creator.getIndices())
# Create the multigrid object
mg = TMR.createMg(assemblers, forests)
# Create the topology optimization problem
vars_per_node = 1
nmats = props.getNumMaterials()
if nmats > 1:
vars_per_node = nmats + 1
problem = TMR.TopoProblem(assemblers, filters, varmaps, vecindices, mg,
vars_per_node)
return assemblers[0], problem, filters[0], varmaps[0]
def createProblem(forest,
bcs,
ordering,
mesh_order=2,
nlevels=2,
pttype=TMR.GAUSS_LOBATTO_POINTS):
# Create the forest
forests = []
assemblers = []
# Create the trees, rebalance the elements and repartition
forest.balance(1)
forest.setMeshOrder(mesh_order, pttype)
forest.repartition()
forests.append(forest)
# Make the creator class
creator = CreateMe(bcs)
assemblers.append(creator.createTACS(forest, ordering))
while mesh_order > 2:
mesh_order = mesh_order - 1
forest = forests[-1].duplicate()
forest.balance(1)
forest.setMeshOrder(mesh_order, pttype)
forests.append(forest)
# Make the creator class
creator = CreateMe(bcs)
assemblers.append(creator.createTACS(forest, ordering))
for i in range(nlevels - 1):
forest = forests[-1].coarsen()
forest.setMeshOrder(2, pttype)
forest.balance(1)
forest.repartition()
forests.append(forest)
# Make the creator class
creator = CreateMe(bcs)
assemblers.append(creator.createTACS(forest, ordering))
# Create the multigrid object
mg = TMR.createMg(assemblers,
forests,
use_coarse_direct_solve=True,
use_chebyshev_smoother=False)
return assemblers[0], mg
def createTopoProblem(forest, order=2, nlevels=2):
# Create the forest
forests = []
filters = []
assemblers = []
varmaps = []
vecindices = []
# Create the trees, rebalance the elements and repartition
forest.balance(1)
forest.repartition()
forests.append(forest)
# Create the filter
filtr = forest.coarsen()
filtr.balance(1)
filters.append(filtr)
# Make the creator class
creator = CreateMe(bcs, filters[-1])
assemblers.append(creator.createTACS(order, forest))
varmaps.append(creator.getMap())
vecindices.append(creator.getIndices())
for i in range(nlevels - 1):
forest = forests[-1].coarsen()
forest.balance(1)
forest.repartition()
forests.append(forest)
# Create the filter
filtr = forest.coarsen()
filtr.balance(1)
filters.append(filtr)
# Make the creator class
creator = CreateMe(bcs, filters[-1])
assemblers.append(creator.createTACS(order, forest))
varmaps.append(creator.getMap())
vecindices.append(creator.getIndices())
# Create the multigrid object
mg = TMR.createMg(assemblers, forests)
# Create the topology optimization problem
problem = TMR.TopoProblem(assemblers, filters, varmaps, vecindices, mg)
return assemblers[0], problem, filters[0], varmaps[0]
def createProblemMg(topo,
elem_dict,
forest,
bcs,
ordering,
order=2,
nlevels=2,
pttype=TMR.UNIFORM_POINTS):
# Create the forest
forests = []
assemblers = []
# Create the trees, rebalance the elements and repartition
forest.balance(1)
forest.setMeshOrder(order, pttype)
forest.repartition()
forests.append(forest)
# Make the creator class
creator = CreateMe(bcs, topo, elem_dict)
assemblers.append(creator.createTACS(forest, ordering))
while order > 2:
order = order - 1
forest = forests[-1].duplicate()
forest.setMeshOrder(order, pttype)
forest.balance(1)
forests.append(forest)
# Make the creator class
creator = CreateMe(bcs, topo, elem_dict)
assemblers.append(creator.createTACS(forest, ordering))
# Create the multigrid object
mg = TMR.createMg(assemblers, forests, omega=0.5)
return assemblers[0], mg
# Make the creator class
creator = CreateMe(bcs, forest.getTopology(), case=case)
assemblers.append(creator.createTACS(forest, ordering))
for i in range(nlevels - 1):
forest = forests[-1].coarsen()
forest.setMeshOrder(2, pttype)
forest.balance(1)
forests.append(forest)
# Make the creator class
creator = CreateMe(bcs, forest.getTopology(), case=case)
assemblers.append(creator.createTACS(forest, ordering))
# Create the multigrid object
mg = TMR.createMg(assemblers, forests, omega=0.5)
return assemblers[0], mg
# Set the communicator
comm = MPI.COMM_WORLD
# Create an argument parser to read in arguments from the commnad line
p = argparse.ArgumentParser()
p.add_argument('--case', type=str, default='disk')
p.add_argument('--functional', type=str, default='ks')
p.add_argument('--steps', type=int, default=5)
p.add_argument('--htarget', type=float, default=10.0)
p.add_argument('--ordering', type=str, default='multicolor')
p.add_argument('--order', type=int, default=2)
forests = [forest]
assemblers = [creator.createTACS(order, forest)]
if order == 3:
order = 2
forests.append(forests[-1].duplicate())
forests[-1].balance(1)
assemblers.append(creator.createTACS(order, forests[-1]))
for i in range(nlevels - 1):
forests.append(forests[-1].coarsen())
forests[-1].balance(1)
assemblers.append(creator.createTACS(order, forests[-1]))
# Create the multigrid object
mg = TMR.createMg(assemblers, forests)
# Create a solution vector
ans = assemblers[0].createVec()
res = assemblers[0].createVec()
alpha = 1.0
beta = 0.0
gamma = 0.0
mg.assembleJacobian(alpha, beta, gamma, res)
# Factor the preconditioner
mg.factor()
# Set up a arbitrary load
v = res.getArray()
v[2::6] += 1.0
def createTopoProblem(forest,
callback,
filter_type,
nlevels=2,
repartition=True,
design_vars_per_node=1,
s=2.0,
N=10,
r0=0.05,
lowest_order=2,
ordering=TACS.PY_MULTICOLOR_ORDER,
scale_coordinate_factor=1.0):
"""
Create a topology optimization problem instance and a hierarchy of meshes.
This code takes in the OctForest or QuadForest on the finest mesh level
and creates a series of coarser meshes for analysis and optimization.
The discretization at each level is created via a callback function that
generates the appropriate TACSCreator object and its associated filter (the
QuadForest or OctForest on which the design parametrization is defined.)
The code then creates a TMRTopoFilter class which stores information about
the design parametrization and hierarchy. It creates a multigrid object and
finally a TMRTopoProblem instance for optimization.
The callback function takes in a forest object, corresponding to the finite-
element discretization and returns a creator object and a filter object in
the following form:
creator, filter = callback(forest)
Args:
callback: A callback function that takes in the forest and
returns the filter and the associated creator class
filter_type (str): Type of filter to create
forest (TMROctForest or TMRQuadForest): Forest type
repartition (bool): Repartition the mesh
design_vars_per_node (int): number of design variables for each node
s (float): Matrix filter smoothing parameter
N (int): Matrix filter approximation parameter
r0 (float): Helmholtz filter radius
lowest_order (int): Lowest order mesh to create
ordering: TACS Assembler ordering type
scale_coordinate_factor (float): Scale all coordinates by this factor
Returns:
problem (TopoProblem): The allocated topology optimization problem
"""
# Store data
forests = []
filters = []
assemblers = []
varmaps = []
vecindices = []
# Balance the forest and repartition across processors
forest.balance(1)
if repartition:
forest.repartition()
# Create the forest object
creator, filtr = callback(forest)
forests.append(forest)
filters.append(filtr)
assemblers.append(creator.createTACS(forest, ordering))
if filter_type == 'lagrange':
varmaps.append(creator.getMap())
vecindices.append(creator.getIndices())
for i in range(nlevels - 1):
order = forests[-1].getMeshOrder()
interp = forests[-1].getInterpType()
if order > lowest_order:
forest = forests[-1].duplicate()
order = order - 1
forest.setMeshOrder(order, interp)
else:
forest = forests[-1].coarsen()
forest.setMeshOrder(order, interp)
# Balance and repartition if needed
forest.balance(1)
if repartition:
forest.repartition()
# Create the forest object
creator, filtr = callback(forest)
forests.append(forest)
filters.append(filtr)
assemblers.append(creator.createTACS(forest, ordering))
if filter_type == 'lagrange':
varmaps.append(creator.getMap())
vecindices.append(creator.getIndices())
# Scale the coordinates by scale_coordinates factor if it is != 1.0
if scale_coordinate_factor != 1.0:
for assembler in assemblers:
X = assembler.createNodeVec()
assembler.getNodes(X)
X.scale(scale_coordinate_factor)
assembler.setNodes(X)
# Create the multigrid object
mg = TMR.createMg(assemblers, forests)
# Create the TMRTopoFilter object
filter_obj = None
if filter_type == 'lagrange':
filter_obj = TMR.LagrangeFilter(assemblers,
filters,
varmaps,
vecindices,
vars_per_node=design_vars_per_node)
elif filter_type == 'matrix':
filter_obj = TMR.MatrixFilter(s,
N,
assemblers,
forests,
vars_per_node=design_vars_per_node)
elif filter_type == 'conform':
filter_obj = TMR.ConformFilter(assemblers,
filters,
vars_per_node=design_vars_per_node)
elif filter_type == 'helmholtz':
filter_obj = TMR.HelmholtzFiler(r0,
assemblers,
filters,
vars_per_node=design_vars_per_node)
problem = TMR.TopoProblem(filter_obj, mg)
return problem
