Functions
def	check_working_dir (wdir)

def	createObject (doc, name, proxy, viewProxy=None)

def	get_beside_base (obj)

def	get_beside_dir (obj)

def	get_custom_base (solver)

def	get_custom_dir (obj)

def	get_part_to_mesh (mesh_obj)

def	get_pref_working_dir (solver_obj)

def	get_refshape_type (fem_doc_object)

def	get_temp_dir (obj=None)

def	getBoundBoxOfAllDocumentShapes (doc)

def	getSelectedFace (selectionex)

def	is_derived_from (obj, t)

def	is_of_type (obj, ty)

def	pydecode (bytestring)

def	type_of_obj (obj)

Function Documentation

◆ check_working_dir()

def femtools.femutils.check_working_dir ( wdir )

◆ createObject()

def femtools.femutils.createObject	(	doc,
		name,
		proxy,
		viewProxy = `None`
	)

Add python object to document using python type string.

Add a document object suitable for the *proxy* and the *viewProxy* to *doc*
and attach it to the *proxy* and the *viewProxy*. This function can only be
used with python proxies that specify their C++ type via the BaseType class
member (e.g. Cube.BaseType). If there already exists a object with *name* a
suitable unique name is generated. To auto generate a name pass ``""``.

:param doc:         document object to which the object is added
:param name:        string of the name of new object in *doc*, use
                    ``""`` to generate a name
:param proxy:       python proxy for new object
:param viewProxy:   view proxy for new object

:returns:           reference to new object

◆ get_beside_base()

def femtools.femutils.get_beside_base ( obj )

References femtools.femutils.get_temp_dir().

Referenced by femtools.femutils.get_beside_dir().

◆ get_beside_dir()

def femtools.femutils.get_beside_dir ( obj )

References femtools.femutils.get_beside_base().

Referenced by femtools.femutils.get_pref_working_dir().

◆ get_custom_base()

def femtools.femutils.get_custom_base ( solver )

References femtools.femutils.get_custom_dir(), and femtools.femutils.get_temp_dir().

Referenced by femtools.femutils.get_custom_dir().

◆ get_custom_dir()

def femtools.femutils.get_custom_dir ( obj )

References femtools.femutils.get_custom_base().

Referenced by femtools.femutils.get_custom_base(), and femtools.femutils.get_pref_working_dir().

◆ get_part_to_mesh()

def femtools.femutils.get_part_to_mesh ( mesh_obj )

gmsh mesh object: the Attribute is Part
netgen mesh object: the Attribute is Shape
other mesh objects: do not have a Attribute which holds the part to mesh

References femtools.femutils.is_derived_from().

◆ get_pref_working_dir()

def femtools.femutils.get_pref_working_dir ( solver_obj )

Return working directory for solver honoring user settings.

:throws femtools.errors.MustSaveError:
 If user setting is set to BESIDE and the document isn't saved.

:note:
 Not working correctly for most cases because this circumvents directory
 caching of the solver framework. For solver use getMachine from run.py
 instead.

References femtools.femutils.get_beside_dir(), femtools.femutils.get_custom_dir(), and femtools.femutils.get_temp_dir().

◆ get_refshape_type()

def femtools.femutils.get_refshape_type ( fem_doc_object )

Return shape type the constraints references.

Determine single shape type of references of *fem_doc_object* which must be
a constraint (=have a *References* property). All references must be of the
same type which is than returned as a string. A type can be "Vertex",
"Edge", "Face" or "Solid".

:param fem_doc_object:
 A constraint object with a *References* property.

:returns:
 A string representing the shape type ("Vertex", "Edge", "Face" or
 "Solid"). If *fem_doc_object* isn't a constraint ``""`` is returned.

:note:
 Undefined behaviour if the type of the references of one object are
 not all the same.

:note:
 Undefined behaviour if constraint contains no references (empty list).

◆ get_temp_dir()

def femtools.femutils.get_temp_dir ( obj = None )

Referenced by femtools.femutils.get_beside_base(), femtools.femutils.get_custom_base(), and femtools.femutils.get_pref_working_dir().

◆ getBoundBoxOfAllDocumentShapes()

def femtools.femutils.getBoundBoxOfAllDocumentShapes ( doc )

Calculate bounding box containing all objects inside *doc*.

:returns:
 A bounding box containing all objects that have a *Shape* attribute (all
 Part and PartDesign objects). If the document contains no such objects or
 no objects at all return ``None``.

◆ getSelectedFace()

def femtools.femutils.getSelectedFace ( selectionex )

Return selected face if exactly one face is selected.

:returns:
 The selected face as a ``Part::TopoShape`` if exactly one face is selected.
 Otherwise return ``None``.

:param selectionex:
 A list of selection object like the one Gui.Selection.getSelectionEx()
 returns.

◆ is_derived_from()

def femtools.femutils.is_derived_from	(	obj,
		t
	)

Check if *obj* is derived from *t* honoring Fems typesytem.

Essentially just call ``obj.isDerivedFrom(t)`` and return it's value. For
objects using Fems typesystem (see :py:func:`type_of_obj`) return always
True if the Fem type is equal to *t*.

:note:
 Inheritance of Fem types is not checked. If *obj* uses Fems typesystem the
 type is just checked for equality. If the type doesn't match
 ``obj.isDerivedFrom`` is called as usual. See
 https://forum.freecadweb.org/viewtopic.php?f=10&t=32625

Referenced by femtools.femutils.get_part_to_mesh().

◆ is_of_type()

def femtools.femutils.is_of_type	(	obj,
		ty
	)

Compare type of *obj* with *ty* honoring Fems typesystem.

See :py:func:`type_of_obj` for more info about the special typesystem of
the Fem module.

:returns:
 ``True`` if *obj* is of type *ty*, ``False`` otherwise. Type must match
 exactly: Derived objects are not considered to be of type of one of their
 super classes.

References femtools.femutils.type_of_obj().

◆ pydecode()

def femtools.femutils.pydecode ( bytestring )

Return *bytestring* as a unicode string for python 2 and 3.

For python 2 *bytestring* is converted to a string of type ``unicode``. For
python 3 it is returned as is because it uses unicode for it's ``str`` type
already.

◆ type_of_obj()

def femtools.femutils.type_of_obj ( obj )

Return type of *obj* honoring the special typesystem of Fem.

Python objects of the Fem workbench define their type via a class member
``<Class>.Type``. Return this type if the property exists. If not return
the conventional ``TypeId`` value.

:para obj: a document object

Referenced by femtools.femutils.is_of_type().

Functions