def pebi_fill(domain, constr=[], pts=[]):
"""Builds perpendicular bisector cells in given domain.
:param domain: single or list of closed contours
representing bounding domain
:param constr: single or list of contours representing
meshing constraints
:param pts: set of points in ``[len0, [x0, y0], ...]``
format where ``x, y`` are coordinates of internal vertices
which should be embedded into the resulting grid,
``len`` - size of adjacent cells
:return: grid identifier
A contour tree will be built using all closed contours
passed as **domain** parameter. Only the interior parts
of this tree will be meshed. Contours passed by **domain**
should not intersect each other, but could intersect **constr**
contours.
Routine can produce concave cells (as a result of bad size
control or near the concave domain boundary vertices).
Use :func:`heal_grid` routine with ``convex_cells`` option to fix this.
See details in :ref:`unstructured-meshing`.
"""
icheck(0, UListOr1(ACont2D()))
icheck(1, UListOr1(ACont2D()))
icheck(2, CompoundList(Float(grthan=0.0), Point2D()))
return _triquad(domain, constr, pts, 'pebi')
def export3d_grid_msh(gid, fname, periodic_pairs=[]):
"""Exports 3D grid to fluent msh ascii format.
:param gid: 3D grid file identifier or list of identifiers
:param str grid: filename for output
:param list periodic_pairs:
``[periodic-0, shadow-0, periodic-point-0, shadow-point-0,
periodic-1, shadow-1, periodic-point-1, ...]``
Each periodic pair is defined by four values:
* ``periodic`` - boundary identifier for periodic surface
* ``shadow`` - boundary identifier for shadow surface
* ``periodic-point`` - point in [x, y, z] format on periodic contour
* ``shadow-point`` - point in [x, y, z] format on shadow contour
Given points will be projected to closest vertex on the boundaries
of respective subsurfaces.
Periodic and shadow subsurfaces should be singly connected and
topologically equivalent with respect to given points.
For surface 2D topology definition periodic/shadow surfaces are taken
with outside/inside normals respectively.
"""
icheck(0, UListOr1(Grid3D()))
icheck(1, String())
icheck(2, CompoundList(ZType(), ZType(), Point3D(), Point3D()))
cb = flow.interface.ask_for_callback()
grid = _grid3_from_id(gid)
bt = flow.receiver.get_zone_types()
fluent_export.grid3(fname, grid, bt, periodic_pairs, cb)
def export_contour_hmc(cid, fname, fmt="ascii"):
"""Exports contours to native format.
:param cid: contour identifier or list of identifiers,
:param str fname: output filename
:param str fmt: output data format:
* ``'ascii'`` - all fields will be saved as text fields,
* ``'bin'`` - all fields will be saved in binary section,
* ``'fbin'`` - only floating point fields will be saved
in binary section.
:returns: None
See :ref:`contour2d-file` for format description.
"""
if fmt == "binary":
fmt = "bin"
elif fmt == "fbinary":
fmt = "fbin"
icheck(0, UListOr1(ACont2D()))
icheck(1, String())
icheck(2, OneOf('ascii', 'bin', 'fbin'))
names = cid if isinstance(cid, list) else [cid]
conts = [_cont2_from_id(n) for n in names]
cb = flow.interface.ask_for_callback()
native_export.cont2_tofile(fname, conts, names, fmt, cb)
def export3d_surface_hmc(sid, fname, fmt="ascii"):
"""Exports 3d surface to hybmesh native format.
:param sid: single or list of surface identifiers
:param str fname: output filename
:param str fmt: output data format:
* ``'ascii'`` - all fields will be saved as text fields,
* ``'bin'`` - all fields will be saved in binary section,
* ``'fbin'`` - only floating point fields will be saved
in binary section.
See :ref:`surface3d-file` for format description.
"""
if fmt == "binary":
fmt = "bin"
elif fmt == "fbinary":
fmt = "fbin"
icheck(0, UListOr1(ASurf3D()))
icheck(1, String())
icheck(2, OneOf('ascii', 'bin', 'fbin'))
names = sid if isinstance(sid, list) else [sid]
surfs = [_surf3_from_id(n) for n in names]
cb = flow.interface.ask_for_callback()
native_export.surf3_tofile(fname, surfs, names, fmt, cb)
def export3d_grid_vtk(gid, fname_grid=None, fname_surface=None):
"""Exports 3D grid and its surface to vtk ascii format.
:param gid: 3D grid file identifier or list of identifiers
:param str-or-None fname_grid: filename for grid output.
:param str-or-None fname_surface: filename for surface output.
Only hexahedron, prism, wedge and tetrahedron cells could be exported
as a grid. Surface export takes arbitrary grid.
If a filename is *None* then respective export will be omitted.
Boundary types are exported as a field called ``boundary_types`` to
surface output file.
"""
icheck(0, UListOr1(Grid3D()))
icheck(1, NoneOr(String()))
icheck(2, NoneOr(String()))
if not fname_grid:
fname_grid = None
if not fname_surface:
fname_surface = None
cb = flow.interface.ask_for_callback()
grid = _grid3_from_id(gid)
if fname_grid is not None:
vtk_export.grid3(fname_grid, grid, cb)
if fname_surface is not None:
vtk_export.grid3_surface(fname_surface, grid, cb)
def export_grid_msh(gid, fname, periodic_pairs=[]):
"""Exports grid to fluent msh format.
:param gid: 2d grid file identifier or list of identifiers.
:param str fname: output filename
:param list periodic_pairs:
``[b-periodic0, b-shadow0, is_reversed0, b-periodic1,
b-shadow1, is_reversed1, ...]`` list defining periodic boundaries.
Each periodic condition is defined by three values:
* ``b-periodic`` - boundary identifier for periodic contour segment
* ``b-shadow`` - boundary identifier for shadow contour segment
* ``is_reversed`` - boolean which defines whether shadow contour segment
should be reversed so that first point of periodic segment be
equivalent to last point of shadow segment
Periodic and shadow boundary segments should be singly connected and
topologically equivalent.
:returns: None
Only grids with triangle/quadrangle cells could be exported.
"""
icheck(0, UListOr1(Grid2D()))
icheck(1, String())
icheck(2, CompoundList(ZType(), ZType(), Bool()))
cb = flow.interface.ask_for_callback()
grid = _grid2_from_id(gid)
bt = flow.receiver.get_zone_types()
fluent_export.grid2(fname, grid, bt, periodic_pairs, cb)
def tetrahedral_fill(domain):
""" Fills 3D domain with tetrahedral mesh
:param domain: surface/3d grid identifier (or list of identifiers)
:returns: 3d grid identifier
Domain is defined by any number of closed surfaces passed in **domain**
argument. Internal nesting procedure
will be executed to built target domain out of given surfaces.
Boundary surface could possibly contain faces built
by any number of vertices.
However if boundary face is not a triangle than a n-side pyramid
will be built at its site. Hence resulting grid will not be strictly
tetrahedral.
.. note::
By now program uses simplified bounding box based nesting
algorithm. It could give improper results for complicated
surface structures. Be sure that passed surface list nesting equals
nesting of respective surface bounding boxes.
"""
icheck(0, UListOr1(ASurf3D()))
if not isinstance(domain, list):
domain = [domain]
c = com.grid3dcom.TetrahedralFill({"source": domain})
flow.exec_command(c)
return c.added_grids3()[0]
def remove_geom(objs):
""" Completely removes object or list of objects
:param objs: identifier or list of identifiers of removing objects
:returns: None
"""
icheck(0, UListOr1(AObject()))
ob = objs if isinstance(objs, list) else [objs]
c = com.objcom.RemoveGeom({"names": ob})
flow.exec_command(c)
def export3d_grid_hmg(gid, fname, fmt="ascii", afields=[]):
"""Exports 3d grid to hybmesh native format.
:param gid: single or list of grid identifiers
:param str fname: output filename
:param str fmt: output data format:
* ``'ascii'`` - all fields will be saved as text fields,
* ``'bin'`` - all fields will be saved in binary section,
* ``'fbin'`` - only floating point fields will be saved
in binary section.
:param list-of-str afields: additional data which should be placed
to output file.
To save additional data into grid file
:ref:`user defined fields <udef-fields>`
place any of these strings into **afields** list:
* ``'face-vertices'`` - face vertex ordered connectivity,
* ``'cell-faces'`` - cell face connectivity,
* ``'cell-vertices'`` - cell vertex connectivity,
* ``'linfem'`` - tries to write cells-vertex connectivity
for cell types most widely used in linear fem solvers.
Supported cell types are: tetrahedron (4 nodes), hexahedron (8),
prism(6), pyramid(5).
Record for each of those cells contains points in order prescribed
by vtk file format. If a cell is not of one of those types
then a zero length connectivity list will be written for it.
.. figure:: vtk_cells3d.png
:width: 500 px
See :ref:`grid3d-file` for format description.
"""
if fmt == "binary":
fmt = "bin"
if fmt == "fbinary":
fmt = "fbin"
icheck(0, UListOr1(Grid3D()))
icheck(1, String())
icheck(2, OneOf('ascii', 'bin', 'fbin'))
icheck(
3,
UList(OneOf('face-vertices', 'cell-faces', 'cell-vertices', 'linfem')))
names = gid if isinstance(gid, list) else [gid]
grids = map(flow.receiver.get_grid3, names)
cb = flow.interface.ask_for_callback()
native_export.grid3_tofile(fname, grids, names, fmt, afields, cb)
def export_contour_vtk(cid, fname):
"""Exports contour to vtk format.
:param cid: contour identifier or list of identifiers,
:param str fname: output filename.
:return: None
"""
icheck(0, UListOr1(ACont2D()))
icheck(1, String())
cont = _cont2_from_id(cid)
cb = flow.interface.ask_for_callback()
vtk_export.cont2(fname, cont, cb)
def triangulate_domain(domain, constr=[], pts=[], fill='3'):
"""Builds constrained triangulation within given domain
:param domain: single or list of closed contours
representing bounding domain
:param constr: single or list of contours representing
triangulation constraints
:param pts: set of points in ``[len0, [x0, y0], ...]``
format where ``x, y`` are coordinates of internal vertices
which should be embedded into the resulting grid,
``len`` - size of adjacent cells
:param str fill: if '3' then triangulates area; '4' runs
recombination algorithm to make mostly quadrangular mesh
:return: grid identifier
A contour tree will be built using all closed contours
passed as **domain** parameter. Only the interior parts
of this tree will be meshed. Contours passed by **domain**
should not intersect each other, but could intersect **constr**
contours.
**constr** could contain any set of closed and open contours.
See details in :ref:`unstructured-meshing`.
"""
icheck(0, UListOr1(ACont2D()))
icheck(1, UListOr1(ACont2D()))
icheck(2, CompoundList(Float(grthan=0.0), Point2D()))
icheck(3, OneOf('3', '4'))
if fill == '3':
return _triquad(domain, constr, pts, '3')
elif fill == '4':
return _triquad(domain, constr, pts, '4')
def export_grid_vtk(gid, fname):
""" Exports 2d grid to vtk format
:param gid: single or list of 2d grid identifiers
:param str fname: output filename
:returns: None
"""
icheck(0, UListOr1(Grid2D()))
icheck(1, String())
grid = _grid2_from_id(gid)
cb = flow.interface.ask_for_callback()
vtk_export.grid2(fname, grid, cb)
def remove_all_but(objs):
""" Removes all geometry objects except for listed ones
:param objs: identifier or list of identifiers of objects
which should NOT be removed
:returns: None
"""
icheck(0, UListOr1(AObject()))
if not isinstance(objs, list):
objs = [objs]
all_obj = flow.receiver.get_names()
all_obj = [x for x in all_obj if x not in objs]
remove_geom(all_obj)
def rotate_geom(objs, angle, pc=[0.0, 0.0]):
""" Rotates group of 2d objects
:param objs: identifier or list of identifiers of rotating 2d objects
:param float angle: degree of rotation. Positive angle corresponds to
counterclockwise rotation
:param list-of-float pc: center of rotation
:returns: None
"""
icheck(0, UListOr1(ACont2D()))
icheck(1, Float())
icheck(2, Point2D())
ob = objs if isinstance(objs, list) else [objs]
c = com.objcom.RotateGeom({"names": ob, "angle": angle, "p0": pc})
flow.exec_command(c)
def export_grid_hmg(gid, fname, fmt='ascii', afields=[]):
"""Exports 2d grid to hybmesh native format.
:param gid: single or list of grid identifiers
:param str fname: output filename
:param str fmt: output data format:
* ``'ascii'`` - all fields will be saved as text fields,
* ``'bin'`` - all fields will be saved in binary section,
* ``'fbin'`` - only floating point fields will be saved
in binary section.
:param list-of-str afields: additional data which should be placed
to output file.
:returns: None
To save additional data into grid file
:ref:`user defined fields <udef-fields>`
place any of these strings into **afields** list:
* ``'cell-vertices'`` -- cell vertex connectivity. All vertices will
be written in counterclockwise direction;
* ``'cell-edges'`` -- cell edge connectivity. All edges will be written
in counterclockwise direction.
See :ref:`grid2d-file` for format description.
"""
if fmt == "binary":
fmt = "bin"
if fmt == "fbinary":
fmt = "fbin"
icheck(0, UListOr1(Grid2D()))
icheck(1, String())
icheck(2, OneOf('ascii', 'bin', 'fbin'))
icheck(3, UList(OneOf('cell-vertices', 'cell-edges')))
names = gid if isinstance(gid, list) else [gid]
grids = map(flow.receiver.get_grid2, names)
cb = flow.interface.ask_for_callback()
native_export.grid2_tofile(fname, grids, names, fmt, afields, cb)
def reflect_geom(objs, pnt1, pnt2):
""" Makes a reflection of 2d geometry objects over a given line
:param objs: identifier or list of identifiers of 2d objects to reflect
:param list-of-float pnt1:
:param list-of-float pnt2: points in [x, y] format which define a line
to reflect over
:returns: None
"""
icheck(0, UListOr1(ACont2D()))
icheck(1, Point2D())
icheck(2, Point2D(noteq=[pnt1]))
ob = objs if isinstance(objs, list) else [objs]
c = com.objcom.ReflectGeom({"names": ob, "p1": pnt1, "p2": pnt2})
flow.exec_command(c)
def export3d_grid_tecplot(gid, fname):
"""Exports 3D grid to tecplot ascii format.
:param gid: 3D grid file identifier or list of identifiers
:param str grid: filename for output
A grid zone and zones for each boundary surface defined by boundary type
will be created in the output file.
All 3D cells will be saved as FEPOLYHEDRON elements.
"""
icheck(0, UListOr1(Grid3D()))
icheck(1, String())
cb = flow.interface.ask_for_callback()
grid = _grid3_from_id(gid)
bt = flow.receiver.get_zone_types()
tecplot_export.grid3(fname, grid, bt, cb)
def export_grid_tecplot(gid, fname):
"""Exports grid to tecplot ascii format.
:param gid: grid identifier or list of identifiers
:param fname: output filename
:returns: None
All cells will be saved as FEPolygon elements.
Boundary segments with same boundary type will be converted
to separate zones.
"""
icheck(0, UListOr1(Grid2D()))
icheck(1, String())
cb = flow.interface.ask_for_callback()
grid = _grid2_from_id(gid)
bt = flow.receiver.get_zone_types()
tecplot_export.grid2(fname, grid, bt, cb)
def export_contour_tecplot(cid, fname):
"""Exports contour to tecplot ascii format.
:param cid: contour identifier or list of identifiers,
:param str fname: output filename.
:returns: None
All contour segments will be saved to a zone called "Contour".
Additional zones will be created for all segments with same
boundary type.
"""
icheck(0, UListOr1(ACont2D()))
icheck(1, String())
cb = flow.interface.ask_for_callback()
cont = _cont2_from_id(cid)
bt = flow.receiver.get_zone_types()
tecplot_export.cont2(fname, cont, bt, cb)
def export3d_grid_gmsh(gid, fname):
"""Exports 3D grid to gmsh ascii format.
:param gid: grid identifier or list of identifiers
:param str fname: output filename.
Only grids with tetrahedral/hexahedral/prism/pyramid cells
could be exported.
Boundary edges will be exported as Elements of triangle/quadrangle type.
All boundary types which present in grid will be exported as
Physical Groups with an id identical to boundary index and
respective Physical Name.
"""
icheck(0, UListOr1(Grid3D()))
icheck(1, String())
cb = flow.interface.ask_for_callback()
grid = _grid3_from_id(gid)
bt = flow.receiver.get_zone_types()
gmsh_export.grid3(fname, grid, bt, cb)
def scale_geom(objs, xpc=100., ypc=100., zpc=100., refp=[0.0, 0.0, 0.0]):
""" Scales objects
:param objs: identifier or list of identifiers of scaling objects
:param float xpc:
:param float ypc:
:param float zpc: percentages of scaling in x, y and z directions
:param list-of-float refp: reference point as ``[x, y, z]`` which stays
fixed after transformation
:returns: None
if **objs** contains only 2d objects **zpc** is ignored and could be
ommitted, **refp** could by given as ``[x, y]``.
"""
icheck(0, UListOr1(AObject()))
icheck(1, Float(grthan=0.))
icheck(2, Float(grthan=0.))
icheck(3, Float(grthan=0.))
icheck(4, APoint())
# for backward compatibility check if zpc was omitted
if isinstance(zpc, list):
refp = zpc
zpc = 100.
if len(refp) == 2:
refp = [refp[0], refp[1], 0.]
ob = objs if isinstance(objs, list) else [objs]
c = com.objcom.ScaleGeom({
"names": ob,
"xpc": xpc,
"ypc": ypc,
"zpc": zpc,
"p0": refp
})
flow.exec_command(c)
def move_geom(objs, dx, dy, dz=0.):
""" Moves a list of objects
:param objs: identifier or list of identifiers of moving objects
:param float dx:
:param float dy:
:param float dz: shifts in x, y and z direction. Z moves take place only
for 3d objects
:returns: None
"""
icheck(0, UListOr1(AObject()))
icheck(1, Float())
icheck(2, Float())
icheck(3, Float())
ob = objs if isinstance(objs, list) else [objs]
c = com.objcom.MoveGeom({"names": ob, "dx": dx, "dy": dy, "dz": dz})
flow.exec_command(c)
def export_grid_gmsh(gid, fname):
""" Exports grid to gmsh ascii format.
:param gid: single or list of grid identifiers
:param fname: output filename
:returns: None
Only grids with triangle/quadrangle cells could be exported.
Boundary edges will be exported as Elements of "Line" type.
All boundary types which present in grid will be exported as
Physical Groups with an id
identical to boundary index and a respective Physical Name.
"""
icheck(0, UListOr1(Grid2D()))
icheck(1, String())
cb = flow.interface.ask_for_callback()
grid = _grid2_from_id(gid)
bt = flow.receiver.get_zone_types()
gmsh_export.grid2(fname, grid, bt, cb)
