# 58. `plugins.properties` — General framework for attributing properties to geometrical elements.

Properties can really be just about any Python object. Properties can be attributed to a set of geometrical elements.

## 58.1. Classes defined in module plugins.properties

class `plugins.properties.``Database`(data={})

  A class for storing properties in a database.

  `readDatabase`(filename, *args, **kargs)

    Import all records from a database file.

    For now, it can only read databases using flatkeydb. args and kargs can be used to specify arguments for the FlatDB constructor.

class `plugins.properties.``MaterialDB`(data={})

  A class for storing material properties.

class `plugins.properties.``SectionDB`(data={})

  A class for storing section properties.

class `plugins.properties.``ElemSection`(section=None, material=None, orientation=None, **kargs)

  Properties related to the section of an element.

  An element section property can hold the following sub-properties:

  section

    the geometric properties of the section. This can be a dict or a string. If it is a string, its value is looked up in the global section database. The section dict should at least have a key ‘sectiontype’, defining the type of section.

    Currently the following sectiontype values are known by module `fe_abq` for export to Abaqus/Calculix:

    > - ‘solid’ : a solid 2D or 3D section,
    > - ‘circ’ : a plain circular section,
    > - ‘rect’ : a plain rectangular section,
    > - ‘pipe’ : a hollow circular section,
    > - ‘box’ : a hollow rectangular section,
    > - ‘I’ : an I-beam,
    > - ‘general’ : anything else (automatically set if not specified).
    > - ‘rigid’ : a rigid body

    The other possible (useful) keys in the section dict depend on the sectiontype. Again for `fe_abq`:

    > - for sectiontype ‘solid’ : thickness
    > - the sectiontype ‘general’: cross_section, moment_inertia_11, moment_inertia_12, moment_inertia_22, torsional_constant
    > - for sectiontype ‘circ’: radius
    > - for sectiontype ‘rigid’: refnode, density, thickness

  material
    the element material. This can be a dict or a string. Currently known keys to fe_abq.py are: young_modulus, shear_modulus, density, poisson_ratio . (see fmtMaterial in fe_abq) It should not be specified for rigid sections.
  orientation
    - a Dict, or
    - a list of 3 direction cosines of the first beam section axis.
  `addSection`(section)

    Create or replace the section properties of the element.

    If ‘section’ is a dict, it will be added to the global SectionDB. If ‘section’ is a string, this string will be used as a key to search in the global SectionDB.

  `computeSection`(section)

    Compute the section characteristics of specific sections.

  `addMaterial`(material)

    Create or replace the material properties of the element.

    If the argument is a dict, it will be added to the global MaterialDB. If the argument is a string, this string will be used as a key to search in the global MaterialDB.

class `plugins.properties.``ElemLoad`(label=None, value=None, dir=None)

  Distributed loading on an element.

class `plugins.properties.``EdgeLoad`(edge=-1, label=None, value=None)

  Distributed loading on an element edge.

class `plugins.properties.``CoordSystem`(csys, cdata)

  A class for storing coordinate systems.

class `plugins.properties.``Amplitude`(data, definition='TABULAR', atime='STEP TIME', smoothing=None)

  A class for storing an amplitude.

  The amplitude is a list of tuples (time,value).

  atime (amplitude time) can be either STEP TIME (default in Abaqus) or TOTAL TIME

  smoothing (optional) is a float (from 0. to 0.5, suggested value 0.05) representing the fraction of the time interval before and after each time point during which the piecewise linear time variation will be replaced by a smooth quadratic time variation (avoiding infinite accelerations). Smoothing should be used in combination with TABULAR (set 0.05 as default value?)

class `plugins.properties.``PropertyDB`(mat='', sec='')

  A database class for all properties.

  This class collects all properties that can be set on a geometrical model.

  This should allow for storing:

  - materials
  - sections
  - any properties
  - node properties
  - elem properties
  - model properties (current unused: use unnamed properties)

  Materials and sections use their own database for storing. They can be specified on creating the property database. If not specified, default ones are created from the files distributed with pyFormex.

  `setMaterialDB`(aDict)

    Set the materials database to an external source

  `setSectionDB`(aDict)

    Set the sections database to an external source

  `print`()

    Print the property database

  `Prop`(kind='', tag=None, set=None, name=None, **kargs)

    Create a new property, empty by default.

    A property can hold almost anything, just like any Dict type. It has however four predefined keys that should not be used for anything else than explained hereafter:

    - nr: a unique id, that never should be set/changed by the user.
    - tag: an identification tag used to group properties
    - name: the name to be used for this set. Default is to use an automatically generated name.
    - set: identifies the geometrical elements for which the defined properties will hold. This can be either:
      - a single number,
      - a list of numbers,
      - the name of an already defined set,
      - a list of such names.

    Besides these, any other fields may be defined and will be added without checking.

  `getProp`(kind='', rec=None, tag=None, attr=[], noattr=[], delete=False)

    Return all properties of type kind matching tag and having attr.

    kind is either ‘’, ‘n’, ‘e’ or ‘m’ If rec is given, it is a list of record numbers or a single number. If a tag or a list of tags is given, only the properties having a matching tag attribute are returned.

    attr and noattr are lists of attributes. Only the properties having all the attributes in attr and none of the properties in noattr are returned. Attributes whose value is None are treated as non-existing.

    If delete==True, the returned properties are removed from the database.

  `delProp`(kind='', rec=None, tag=None, attr=[])

    Delete properties.

    This is equivalent to getProp() but the returned properties are removed from the database.

  `nodeProp`(prop=None, set=None, name=None, tag=None, cload=None, bound=None, displ=None, veloc=None, accel=None, csys=None, ampl=None, **kargs)

    Create a new node property, empty by default.

    A node property can contain any combination of the following fields:

    - tag: an identification tag used to group properties (this is e.g. used to flag Step, increment, load case, …)
    - set: a single number or a list of numbers identifying the node(s) for which this property will be set, or a set name If None, the property will hold for all nodes.
    - cload: a concentrated load: a list of 6 float values [FX,FY,FZ,MX,MY,MZ] or a list of (dofid,value) tuples.
    - displ,veloc,accel: prescribed displacement, velocity or acceleration: a list of 6 float values [UX,UY,UZ,RX,RY,RZ] or a list of tuples (dofid,value)
    - bound: a boundary condition: a string, a list of 6 codes (0/1), or a list of tuples (dofid, value)
    - csys: a CoordSystem
    - ampl: the name of an Amplitude
  `elemProp`(prop=None, grp=None, set=None, name=None, tag=None, section=None, eltype=None, dload=None, eload=None, ampl=None, **kargs)

    Create a new element property, empty by default.

    An elem property can contain any combination of the following fields:

    - tag: an identification tag used to group properties (this is e.g. used to flag Step, increment, load case, …)
    - set: a single number or a list of numbers identifying the element(s) for which this property will be set, or a set name If None, the property will hold for all elements.
    - grp: an elements group number (default None). If specified, the element numbers given in set are local to the specified group. If not, elements are global and should match the global numbering according to the order in which element groups will be specified in the Model.
    - eltype: the element type (currently in Abaqus terms).
    - section: an ElemSection specifying the element section properties.
    - dload: an ElemLoad specifying a distributed load on the element.
    - ampl: the name of an Amplitude

## 58.2. Functions defined in module plugins.properties

`plugins.properties.``setMaterialDB`(mat)

  Set the global materials database.

  If mat is a MaterialDB, it will be used as the global MaterialDB. Else, a new global MaterialDB will be created, initialized from the argument mat.

`plugins.properties.``setSectionDB`(sec)

  Set the global sections database.

  If sec is a SectionDB, it will be used as the global SectionDB. Else, a new global SectionDB will be created, initialized from the argument sec.

`plugins.properties.``checkIdValue`(values)

  Check that a variable is a list of (id,value) tuples

  id should be convertible to an int, value to a float. If ok, return the values as a list of (int,float) tuples.

`plugins.properties.``checkArrayOrIdValue`(values)

  Check that a variable is a list of values or (id,value) tuples

  This convenience function checks that the argument is either:

  - a list of 6 float values (or convertible to it), or
  - a list of (id,value) tuples where id is convertible to an int, value to a float.

  If ok, return the values as a list of (int,float) tuples.

  Examples

      >>> checkArrayOrIdValue([0,3,4,0,0,0])
      [(1, 3.0), (2, 4.0)]
      >>> checkArrayOrIdValue([(1,3.0),(2,4.0)])
      [(1, 3.0), (2, 4.0)]
      >>> checkArrayOrIdValue([(0,1.0),(2,4.0),(3,5.0),(4,4),(5,3.0),(1,4.0)])
      [(0, 1.0), (2, 4.0), (3, 5.0), (4, 4.0), (5, 3.0), (1, 4.0)]

`plugins.properties.``checkArrayOrIdValueOrEmpty`(values)

  Check that a variable is a list of values or (id,value) tuples or empty.

  This convenience function checks that the argument is either:

  - a list of 6 float values (or convertible to it), or
  - a list of (id,value) tuples where id is convertible to an int, value to a float.
  - something representing an empty list

  If ok, return the values as a list of (int,float) tuples.

  Examples

      >>> checkArrayOrIdValueOrEmpty([0,3,4,0,0,0])
      [(1, 3.0), (2, 4.0)]
      >>> checkArrayOrIdValueOrEmpty([(1,3.0),(2,4.0)])
      [(1, 3.0), (2, 4.0)]
      >>> checkArrayOrIdValueOrEmpty([])
      []

`plugins.properties.``checkString`(a, valid)

  Check that a string a has one of the valid values.

  This is case insensitive, and returns the upper case string if valid. Else, an error is raised.

`plugins.properties.``FindListItem`(l, p)

  Find the item p in the list l.

  If p is an item in the list (not a copy of it!), this returns its position. Else, -1 is returned.

  Matches are found with a ‘is’ function, not an ‘==’. Only the first match will be reported.

`plugins.properties.``RemoveListItem`(l, p)

  Remove the item p from the list l.

  If p is an item in the list (not a copy of it!), it is removed from the list. Matches are found with a ‘is’ comparison. This is different from the normal Python list.remove() method, which uses ‘==’. As a result, we can find complex objects which do not allow ‘==’, such as ndarrays.