def _arguments_types(cls):
return {
'name': co.BasicOption(str, None),
'domain': co.ListOfOptions(co.BasicOption(str)),
'constr': co.ListOfOptions(co.BasicOption(str), []),
'pts': co.ListOfOptions(co.BasicOption(float), []),
}
def _arguments_types(cls):
return {'name': co.BasicOption(str, None),
'source': co.ListOfOptions(co.BasicOption(str)),
'constr': co.ListOfOptions(co.BasicOption(str), []),
'pts': co.ListOfOptions(co.Point3Option(), []),
'pts_size': co.ListOfOptions(co.BasicOption(float), []),
}
def _arguments_types(cls):
return {
'name': comopt.BasicOption(str, None),
'src': comopt.BasicOption(str),
'plist': comopt.ListOfOptions(comopt.Point2Option()),
'project_to': comopt.BasicOption(str, 'vertex')
}
def _arguments_types(cls):
'p0 - center of rotation, angle (deg) - rotation angle'
return {
'names': comopt.ListOfOptions(comopt.BasicOption(str)),
'p0': comopt.Point2Option(),
'angle': comopt.BasicOption(float)
}
def _arguments_types(cls):
return {
'name': co.BasicOption(str, None),
'area': co.ListOfOptions(co.BasicOption(float)),
'crad': co.BasicOption(float),
'strict': co.BoolOption(False),
}
def _arguments_types(cls):
return {
'names': comopt.ListOfOptions(comopt.BasicOption(str)),
'dx': comopt.BasicOption(float, 0.),
'dy': comopt.BasicOption(float, 0.),
'dz': comopt.BasicOption(float, 0.),
}
def _arguments_types(cls):
return {
'grid_name': comopt.BasicOption(str),
'cont_name': comopt.BasicOption(str, None),
'simplify': comopt.BoolOption(True),
'separate': comopt.BoolOption(False),
}
def _arguments_types(cls):
return {
'name': comopt.BasicOption(str, None),
'points': comopt.ListOfOptions(comopt.Point2Option()),
'bnds': comopt.ListOfOptions(comopt.BasicOption(int), []),
'nedges': comopt.BasicOption(int, 100),
}
def _arguments_types(cls):
return {
'name': co.BasicOption(str, None),
'vertices': co.ListOfOptions(co.Point2Option()),
'nedge': co.BasicOption(int),
'bnd': co.ListOfOptions(co.BasicOption(int), [0, 0, 0])
}
def _arguments_types(cls):
""" name - new grid name,
filename - filename
"""
return {
'name': co.BasicOption(str, None),
'filename': co.BasicOption(str),
}
def _arguments_types(cls):
return {
'name': comopt.BasicOption(str, None),
'src': comopt.ListOfOptions(comopt.BasicOption(str)),
'fix': comopt.ListOfOptions(comopt.BasicOption(int), []),
'close': comopt.BasicOption(str, 'no'),
'shiftnext': comopt.BoolOption(False)
}
def _arguments_types(cls):
return {
'names': comopt.ListOfOptions(comopt.BasicOption(str)),
'p0': comopt.Point3Option((0., 0., 0.)),
'xpc': comopt.BasicOption(float, 100.),
'ypc': comopt.BasicOption(float, 100.),
'zpc': comopt.BasicOption(float, 100.),
}
def _arguments_types(cls):
return {
'name': comopt.BasicOption(str, None),
'p0': comopt.Point2Option(),
'rad': comopt.BasicOption(float),
'na': comopt.BasicOption(int),
'bnd': comopt.BasicOption(int, 0),
}
def _arguments_types(cls):
return {
'name': comopt.BasicOption(str, None),
'c1': comopt.BasicOption(str),
'c2': comopt.BasicOption(str),
'oper': comopt.BasicOption(str),
'simplify': comopt.BoolOption(True),
}
def _arguments_types(cls):
return {
'name': comopt.BasicOption(str, None),
'p0': comopt.Point2Option(),
'p1': comopt.Point2Option(),
'bnds': comopt.ListOfOptions(comopt.BasicOption(int),
[0, 0, 0, 0]),
}
def _arguments_types(cls):
""" name - string
bdict - {bndtype: [list of edges indicies] }
btypes - btype for the whole object
"""
return {
'name': comopt.BasicOption(str),
'btypes': comopt.BoundaryPickerOption(),
'whole': comopt.NoneOr(comopt.BasicOption(int), None),
}
def _arguments_types(cls):
return {'name': co.BasicOption(str, None),
'base': co.BasicOption(str),
'p1': co.Point2Option(),
'p2': co.Point2Option(),
'phi': co.ListOfOptions(co.BasicOption(float)),
'bt1': co.BasicOption(int, 0),
'bt2': co.BasicOption(int, 0),
'center_tri': co.BoolOption(True)
}
def _arguments_types(cls):
return {
'name': co.BasicOption(str, None),
'grid': co.BasicOption(str),
'cont': co.BasicOption(str),
'gp1': co.Point2Option(),
'gp2': co.Point2Option(),
'cp1': co.NoneOr(co.Point2Option(), None),
'cp2': co.NoneOr(co.Point2Option(), None),
'algo': co.BasicOption(str, "add"),
}
def _arguments_types(cls):
""" name - new grids name,
filename - filename
gridname -
all -
"""
return {
'name': co.BasicOption(str, None),
'filename': co.BasicOption(str),
'gridname': co.BasicOption(str, ""),
'all': co.BoolOption(False)
}
def _arguments_types(cls):
""" name - new grids name,
filename - filename,
contname - specific name,
all
"""
return {
'name': co.BasicOption(str, None),
'filename': co.BasicOption(str),
'contname': co.BasicOption(str, ""),
'all': co.BoolOption(False)
}
def _arguments_types(cls):
""" name - new surface name,
filename - filename
srfname - surface name if not all
all - import all found contours?
"""
return {
'name': co.BasicOption(str, None),
'filename': co.BasicOption(str),
'srfname': co.BasicOption(str, ""),
'all': co.BoolOption(False),
}
def _arguments_types(cls):
""" partition: increasing list of floats,
tip: 'no', 'radial'
bnd: boundary for left, bottom, right, top sections
"""
return {
'name': co.BasicOption(str, None),
'source': co.BasicOption(str),
'partition': co.ListOfOptions(co.BasicOption(float)),
'tip': co.BasicOption(str, 'no'),
'bnd': co.ListOfOptions(co.BasicOption(int), [0, 0, 0, 0])
}
def _arguments_types(cls):
""" name - new grid name,
grid_name - source grid name,
cont_names - contours names,
is_inner - exclude inner (True) or outer (False) contour area
"""
return {
'name': co.BasicOption(str, None),
'grid_name': co.BasicOption(str),
'cont_names': co.ListOfOptions(co.BasicOption(str)),
'is_inner': co.BoolOption(),
}
def _arguments_types(cls):
""" name - modified grid name,
simp_bnd - angle (degree): is the maximum angles at which
two adjacent boundary edges of the same cell will be merged
(-1) ignores this procedure.
convex - angle (degree). 0 - removes all concave cell segments,
180 - only degenerate segments.
"""
return {
'name': co.BasicOption(str),
'simp_bnd': co.BasicOption(float, -1.),
'convex': co.BasicOption(float, -1.)
}
def _arguments_types(cls):
""" (int remindex, int index, str name)
removes boundary with index remindex and
sets new boundary (index, name).
remindex=None if nothing to delete.
index=None, name=None if nothing to set.
if index exists it will be overriden
if name exists it will be changed
"""
return {
'remindex': comopt.BasicOption(int, None),
'index': comopt.BasicOption(int, None),
'name': comopt.BasicOption(str, None),
}
def _arguments_types(cls):
""" name - new contour name,
filename - filename
simplify - bool
btypes - if false read (x y). (x y boundary_type_integer) otherwise
force_closed - treat contour as closed even if end points are not
equal
"""
return {
'name': co.BasicOption(str, None),
'filename': co.BasicOption(str),
'simplify': co.BoolOption(False),
'btypes': co.BoolOption(False),
'force_closed': co.BoolOption(False)
}
def _arguments_types(cls):
""" [names] - list of sources contours
[new_names] - list of names for created contours
simplify - do simplification: make all nodes non-collinear
Edges will not be splitted if they have different
boundary types.
angle - minimum acute angle between edges lines
after simplification (deg)
separate - separate contour to ones with not-connected geometry
"""
return {
'names': comopt.ListOfOptions(comopt.BasicOption(str)),
'new_names': comopt.ListOfOptions(comopt.BasicOption(str), []),
'separate': comopt.BoolOption(False),
'simplify': comopt.BoolOption(True),
'angle': comopt.BasicOption(float, 1.0),
}
def _arguments_types(cls):
""" name - name of the new grid,
fix_bnd - whether to fix all boundary points (=False)
keepsrc - whether to remove source grids (=True)
empty_holes - keep all empty zone in 2nd grid (=False)
base - name of base grid,
plus - list of UniteOptions: entries define each next imposition
"""
return {
'name': co.BasicOption(str, None),
'fix_bnd': co.BoolOption(False),
'empty_holes': co.BoolOption(False),
'base': co.BasicOption(str),
'plus': co.ListOfOptions(UniteGrids.Option()),
'angle0': co.BasicOption(float, 1.),
'filler': co.BasicOption(str, '3')
}
def _arguments_types(cls):
"""
btop, bbot are either single value array or
int array value for each 2d cell;
bside is * None if boundary should be taken from grid2;
* [single_value] if one boundary type for everything
* [ed0_0, ed0_1, ... ed0_n, ed1_0, ed1_1, ..., edm_n]:
values for each grid2 edge for each z section
starting from bottom to top
zvals is strictly increasing
"""
return {'name': co.BasicOption(str, None),
'base': co.BasicOption(str),
'zvals': co.ListOfOptions(co.BasicOption(float)),
'bbot': co.ListCompressedOption([0]),
'btop': co.ListCompressedOption([0]),
'bside': co.NoneOr(co.BasicOption(int), None)
}
def _arguments_types(cls):
return {
'name': comopt.BasicOption(str, None),
'base': comopt.BasicOption(str),
'cconts': comopt.ListOfOptions(comopt.BasicOption(str), []),
'step': comopt.BasicOption(float),
'angle0': comopt.BasicOption(float, 1.),
'infdist': comopt.BasicOption(str),
'cpts': comopt.ListOfOptions(comopt.BasicOption(float), []),
'power': comopt.BasicOption(float, 2.)
}
