LamAna Documentation¶

Single Geometry Plots¶

We can plot stress distributions for single laminates as a function of layer thicknesses or normalized thicknesses (default).

In [5]:

case1 = la.distributions.Case(load_params, mat_props)      # instantiate a User Input Case Object through distributions
case1.apply(single_geo)
case1.plot(normalized=False)

Converting mat_props to Standard Form.
User input geometries have been converted and set to Case.

In [6]:

case1.plot(normalized=True, grayscale=True)

We can superimpose both layer axes with insets, and adjust the colors for publications.

In [7]:

case1.plot(annotate=True, colorblind=True, inset=True)

Multiple Geometry Plots¶

Normalized layers enables superimposed of stress distributions and concurrent laminate analysis. Data for multiple laminates are encapsulated in a Case object.

In [10]:

case2.plot(title, colorblind=True, annotate=True)

These distributions can be separated as desired into a panel of multiple plots.

In [11]:

case2.plot(title, colorblind=True, annotate=True, separate=True)

Halfplots¶

The following has not been implemented yet, but demonstrates the idea of several multi-plots of tensile data. Each plot show cases some pattern of interest.

• 1. constant total thickness; varied layer thicknesses
• 2. constant outer layer
• 3. constant inner layer
• 4. constant middle layer

halfplots

In [13]:

cases1.plot(extrema=False)

Data Analysis¶

Using a prior case, we can analyze the data calculations based on a given theorical model.

Laminate data is contained in a DataFrame, a powerful data structure used in data analysis.

In [16]:

#df = case1.frames
df = case1.frames[0]
df
#df.style                                                   # pandas 0.17.1, css on html table
#df.style.bar(subset=['stress_f (MPa/N)', 'strain'], color='#d65f5f')

Accessing frames method.

Out[16]:

Finally, we can export the latter data and parameters to Excel or .csv formats for archiving and further use.

ouput

Install LamAna¶

There are two simple options for installing LamAna. Open a terminal and run one of the following options:

$ pip install lamana                       # from source (default)

$ pip install lamana --use-wheel           # from binary (faster)

For more detailed installation instructions, see Advanced Installation.

Using LamAna with Jupyter (recommended)¶

LamAna was developed with visualization in mind.

LamAna works best with the Jupter Notebook 4.0+ (formerly IPyhon 3.2+). Jupyter is a powerful analytical tool that performs computations in separated cells and integrates well with Python. Plotting works best in Jupyter with some matplotlib backend initiated in a cell using idiomatic IPython magics e.g. %matplotlib inline.

The user starts by importing the desired Feature module, e.g. distributions for plots of stress or strain distributions.

Using LamAna from Commandline¶

If visualization is not important to you, you can still run calcuations and export data from the commandline.

We will now explore how the user can input data and generate plots using the distributions module.

User Setup¶

First we must input loading parameters and material pproperties. Secondly, we must invoke a selected laminate theory. The former requires knowlege of the specimen dimensions, the materials properties and loading configuration. For illustration, an example schematic of laminate loading parameters is provided below.

Loading Parameters

A table is provided defining the illustrated parameters. These loading parameters are coded in a dictionary called load_params.

In [14]:

# SETUP -----------------------------------------------------------------------

import lamana as la

# For plotting in Jupyter
%matplotlib inline

# Build dicts for loading parameters and material properties
load_params = {
    'P_a': 1,                                              # applied load
    'R': 12e-3,                                            # specimen radius
    'a': 7.5e-3,                                           # support radius
    'p': 4,                                                # points/layer
    'r': 2e-4,                                             # radial distance from center loading
}

# Using Quick Form (See Standard Form)
mat_props = {
    'HA': [5.2e10, 0.25],                                  # modulus, Poissions
    'PSu': [2.7e9, 0.33],
}

# Build a list of geometry strings to test.  Accepted conventions shown below:
# 'outer - [{inner...-...}_i] - middle'

geos1 = ['400-400-400', '400-200-800', '400-350-500']      # = total thickness
geos2 = ['400-[400]-400', '400-[200,100]-800']             # = outer thickness
#------------------------------------------------------------------------------

Generate Data in 3 Lines¶

With the loading and material information, we can make stress distribution plots to define (reusable) test cases by implementing 3 simple steps.

1. Instantiate a Feature object with loading and material parameters (generates makes a user Case object)
2. apply() a model to a test with desired geometries (assumes mirrored at the neutral axis)
3. plot() the case object based on the chosen feature

Once the parameters geometries are set, in three lines of code, you can build a case and simultaneiously plot stress distributions for an indefinite number of laminates varying in compostion and dimension within seconds. Conveniently, the outputs are common Python data structures, specifically pandas DataFrames and matplotlib graphical plots ready for data munging and analysis.

In [13]:

case1 = la.distributions.Case(load_params, mat_props)      # instantiate
case1.apply(geos1, model='Wilson_LT')                      # apply
case1.plot()                                               # plot

Converting mat_props to Standard Form.
User input geometries have been converted and set to Case.

Other Attributes¶

A case stores all of the laminate data for a particular set of parameters in two forms: a dict and a DataFrame (see tutorial for details). Once a case is built, there serveral covenient builtin attributes for accessing this data for further analysis.

# Case Attributes
case.geometries                                            # geometry object
case.total                                                 # total laminate thickness (all)
case.inner                                                 # layer thickness (all)
case.total_inner                                           # total layer type (all)
case.total_inner[0]                                        # slicing
case.total_inner_i                                         # total inner layers
case1.snapshot                                             # list of all geometry stacks (unique layers)
case1.frames                                               # list all DataFrames (all layers)

Extensibile¶

LamAna is extensible. Users can define custom or modified models based on laminate theory and apply these models to cases (see theories section for details).

# Classical Laminate Theory
case2 = la.distributions(load_params, mat_props)           # instantiate
case2.apply(geos2, model='Classic_LT')                     # apply model
case2.plot()

# Custom Biaxial Flexure Model
case3 = la.distributions(load_params, mat_props)           # instantiate
case3.apply(geos2, model='Wilson_LT')                      # custom model
case3.plot()

We can perform sepearate analyses by building different cases and apply different models (default model: “Wilson_LT” for circular disks in biaxial flexure).

Core Modules¶

Feature Modules¶

Auxiliary Modules¶

Models¶

LamAna Objects¶

Authoring Custom Models¶

Custom models are simple .py files that can be locally placed by the user into the models directory. The API allows for calling these selected files in the apply() method of the distributions module. In order for these process to work smoothly, the following essentials are needed to talk to theories module.

1. Implement a _use_model_() hook that returns (at minimum) an updated DataFrame.
2. If using the class-style to make models, implement _use_model_() hook within a class named “Model” (must have this name) that inherits from theories.BaseModel.

Exceptions for specific models are maintained by the models author.

The following cell shows excerpts of the class-style model. Examples of function-style and class-style models are found in the “examples” folder found in the repository.

#------------------------------------------------------------------------------
# Class-style model

# ...

class Model(BaseModel):
    '''A custom CLT model.

    A modified laminate theory for circular biaxial flexure disks,
    loaded with a flat piston punch on 3-ball support having two distinct
    materials (polymer and ceramic).

    '''
    def __init__(self):
        self.Laminate = None
        self.FeatureInput = None
        self.LaminateModel = None

    def _use_model_(self, Laminate, adjusted_z=False):
        '''Return updated DataFrame and FeatureInput.

        ...

        Returns
        -------
        tuple
            The updated calculations and parameters stored in a tuple
            `(LaminateModel, FeatureInput)``.

            df : DataFrame
                LaminateModel with IDs and Dimensional Variables.
            FeatureInut : dict
                Geometry, laminate parameters and more.  Updates Globals dict for
                parameters in the dashboard output.


        '''
        self.Laminate = Laminate
        df = Laminate.LFrame.copy()
        FeatureInput = Laminate.FeatureInput

        # Author-defined Exception Handling
        if (FeatureInput['Parameters']['r'] == 0):
            raise ZeroDivisionError('r=0 is invalid for the log term in the moment eqn.')
        elif (FeatureInput['Parameters']['a'] == 0):
            raise ZeroDivisionError('a=0 is invalid for the log term in the moment eqn.')

        # ...

        # Calling functions to calculate Qs and Ds
        df.loc[:, 'Q_11'] = self.calc_stiffness(df, FeatureInput['Properties']).q_11
        df.loc[:, 'Q_12'] = self.calc_stiffness(df, FeatureInput['Properties']).q_12
        df.loc[:, 'D_11'] = self.calc_bending(df, adj_z=adjusted_z).d_11
        df.loc[:, 'D_12'] = self.calc_bending(df, adj_z=adjusted_z).d_12

        # Global Variable Update
        if (FeatureInput['Parameters']['p'] == 1) & (Laminate.nplies%2 == 0):
            D_11T = sum(df['D_11'])
            D_12T = sum(df['D_12'])
        else:
            D_11T = sum(df.loc[df['label'] == 'interface', 'D_11']) # total D11
            D_12T = sum(df.loc[df['label'] == 'interface', 'D_12'])
        #print(FeatureInput['Geometric']['p'])

        D_11p = (1./((D_11T**2 - D_12T**2)) * D_11T)         #
        D_12n = -(1./((D_11T**2 - D_12T**2))  *D_12T)        #
        v_eq = D_12T/D_11T                                   # equiv. Poisson's ratio
        M_r = self.calc_moment(df, FeatureInput['Parameters'], v_eq).m_r
        M_t = self.calc_moment(df, FeatureInput['Parameters'], v_eq).m_t
        K_r = (D_11p*M_r) + (D_12n*M_t)                    # curvatures
        K_t = (D_12n*M_r) + (D_11p*M_t)

        # Update FeatureInput
        global_params = {
            'D_11T': D_11T,
            'D_12T': D_12T,
            'D_11p': D_11p,
            'D_12n': D_12n,
            'v_eq ': v_eq,
            'M_r': M_r,
            'M_t': M_t,
            'K_r': K_r,
            'K_t:': K_t,
        }

        FeatureInput['Globals'] = global_params
        self.FeatureInput = FeatureInput                   # update with Globals
        #print(FeatureInput)

        # Calculate Strains and Stresses and Update DataFrame
        df.loc[:,'strain_r'] = K_r * df.loc[:, 'Z(m)']
        df.loc[:,'strain_t'] = K_t * df.loc[:, 'Z(m)']
        df.loc[:, 'stress_r (Pa/N)'] = (df.loc[:, 'strain_r'] * df.loc[:, 'Q_11']
                                ) + (df.loc[:, 'strain_t'] * df.loc[:, 'Q_12'])
        df.loc[:,'stress_t (Pa/N)'] = (df.loc[:, 'strain_t'] * df.loc[:, 'Q_11']
                             ) + (df.loc[:, 'strain_r'] * df.loc[:, 'Q_12'])
        df.loc[:,'stress_f (MPa/N)'] = df.loc[:, 'stress_t (Pa/N)']/1e6

        del df['Modulus']
        del df['Poissons']

        self.LaminateModel = df

        return (df, FeatureInput)


    #  Add Defaults here

class Defaults(BaseDefaults):
    '''Return parameters for building distributions cases.  Useful for consistent
    testing.

    Dimensional defaults are inherited from utils.BaseDefaults().
    Material-specific parameters are defined here by he user.

    - Default geometric parameters
    - Default material properties
    - Default FeatureInput

    Examples
    ========
    >>> dft = Defaults()
    >>> dft.load_params
    {'R' : 12e-3, 'a' : 7.5e-3, 'p' : 1, 'P_a' : 1, 'r' : 2e-4,}

    >>> dft.mat_props
    {'Modulus': {'HA': 5.2e10, 'PSu': 2.7e9},
    'Poissons': {'HA': 0.25, 'PSu': 0.33}}

    >>> dft.FeatureInput
     {'Geometry' : '400-[200]-800',
      'Geometric' : {'R' : 12e-3, 'a' : 7.5e-3, 'p' : 1, 'P_a' : 1, 'r' : 2e-4,},
      'Materials' : {'HA' : [5.2e10, 0.25], 'PSu' : [2.7e9, 0.33],},
      'Custom' : None,
      'Model' : Wilson_LT}

    '''
    def __init__(self):
        BaseDefaults.__init__(self)
        '''DEV: Add defaults first.  Then adjust attributes.'''
        # DEFAULTS ------------------------------------------------------------
        # Build dicts of geometric and material parameters
        self.load_params = {
            'R': 12e-3,                                    # specimen radius
            'a': 7.5e-3,                                   # support ring radius
            'p': 5,                                        # points/layer
            'P_a': 1,                                      # applied load
            'r': 2e-4,                                     # radial distance from center loading
        }

        self.mat_props = {
            'Modulus': {'HA': 5.2e10, 'PSu': 2.7e9},
            'Poissons': {'HA': 0.25, 'PSu': 0.33}
        }

        # ATTRIBUTES ----------------------------------------------------------
        # FeatureInput
        self.FeatureInput = self.get_FeatureInput(
            self.Geo_objects['standard'][0],
            load_params=self.load_params,
            mat_props=self.mat_props,
            model='Wilson_LT',
            global_vars=None
        )

Package Module Summary¶

This section details some important modules critical to LamAna’s operation. The following table summarizes the core and feature modules in this package, what they intend to do and some important objects that result. Objects that get passed between modules are italicized. The Auxillary (or Utility) modules house support code that will not be discussed.

FeatureInput = {
    'Geometry': Geometry,                           # defined in Case
    'Parameters': load_params,
    'Properties': mat_props,
    'Materials': materials,                         # set material order
    'Model': model,
    'Globals': None,                                # defined in models
}

Core Module: input_¶

LamAna.input_.Geometry(geo_input) --> <Geometry object>

self.geo_inputs = {
    '1-ply': ['0-0-2000', '0-0-1000'],
    '2-ply': ['1000-0-0'],
    '3-ply': ['600-0-800', '600-0-400S'],
    '4-ply': ['500-500-0', '400-[200]-0'],
    '5-ply': ['400-200-800', '400-[200]-800', '400-200-400S'],
    '6-ply': ['400-[100,100]-0', '500-[250,250]-0'],
    '7-ply': ['400-[100,100]-800', '400-[100,100]-400S'],
    '9-ply': ['400-[100,100,100]-800'],
    '10-ply': ['500-[50,50,50,50]-0'],
    '11-ply': ['400-[100,100,100,100]-800'],
    '13-ply': ['400-[100,100,100,100,100]-800'],
}

Feature Module: distributions¶

case = la.distributions.Case(load_params, mat_props)
case.apply(geo_strings=None, model='Wilson_LT', **kwargs)
case.plot(**kwargs)

import lamana as la

bdft = la.input_.BaseDefaults()
cases = Cases(bdft.geo_inputs['geos_all'], ps=[2,3,4])

Core Module: constructs¶

Principally, the constructs module builds a LaminateModel object. Technically a LaminateModel is a `pandas <http://pandas.pydata.org/>`__ DataFrames representing a physical laminate with a few helpful attributes. DataFrames were chosen as the backend object because they allow for powerful data manipulation analyses and database/spreadsheet-like visualizations with simple methods.

Additionally, the constructs module computes laminate dimensional columns and compiles theoretical calculations handled by the complementary theories module. Conventiently, all of this data is contained in tabular form within the DataFrame. The column names are closely related to computational variables defined in the next sub-section.

Variable Classifications¶

Before we discuss the Laminate structure, here we distinguish two ubiquitous variable categories used internally: “Laminate” and “model” variables. In in a full laminate DataFrame, these categories comprise variables that are represented as columns. The categories variables, columns and corresponding modules are illustrated in the image below and described in greater detail:

dataframe output

An image of the output for a DataFrame and their labeled categories of columns (IDs, dimensionals and models). The first two categories are computed by constructs classess; the models columns are computed by theories classes and models. The highlighted blue text indicates user interaction. Groups of rows are colored with alternating red and orange colors to distinguish separate layers.

What distinguishes “Laminate” variables from “Model” variables¶

• Laminate (or constructs) variables are responsible for building the laminate stack and defining dimensions of the laminate. Internally, these varibles will be semantically distinguished with one trailing underscore.
  1. ID: variables related to layer and row identifications
     1. layer_, side_, matl_, type_, t_
  2. Dimensional: variables of heights relative to cross-sectional planes
     1. label_, h_, d_, intf_, k_, Z_, z_
• Model (or theories) variables: all remaining variables are relevant for LT calculations and defined from a given model. Since these variables are model-specific, theres is no particular semantic or naming format.

The finer granularity seen with model variables is not essential for typcial API use, but may be helpful when authoring custom code that integrates with LamAna.

Further Details of Model Variables¶

For more detailed discussions, model variables can be further divided into sub-categories. There common subsets are as follows:

1. **User**: global variables delibrately set by the user at startup
2. **Inline**: variables used per lamina at a kth level (row)
3. **Global**: variables applied to the laminate, accessible by ks

Although model variables are often particular to a chosen model, e.g Wilson_LT, there are some general trends that may be adopted. Some model variables are provided at startup by the user (user_vars). Some variables are calculated for each row of the data within the table (inline_vars). Some variables are calculated by the designated laminate theory model, which provide constants for remaining calculations (global_vars). Global values would display as the same number for every row. These constants are thus removed from the DataFrame, but they are stored internally within a dict. The details of this storage are coded within each model module.

Global values are of particular importance to FeatureInput objects and when exporting meta data as dashboards in spreadsheets. In contrast, Inline values alter directly with the dimensional values thoroughout the lamainate thickness. Names of common variables used in distributions are organized below:

Model Variable Subsets

Model_vars = {user_vars, inline_vars, global_vars}

Examples of Subsets of Model Variables

• user_vars = [mat_props, load_params]
• global_vars = [v_eq, D_11T, D_12T, M_r, M_t, D_11p, D_12n, K_r, K_t]
• inline_vars = [Q11, Q12, D11, D12, strain_r, strain_t, stress_r, stress_t, stress_f]

TIP: Aside from user variables, all others are found as headers for columns in a DataFrame (or spreadsheet).

Examples
--------
>>> import LamAna as la
>>> G = la.input_.Geometry(['400-200-800'])
>>> G
<Geometry object (400-[200]-800)>

Create a StackTuple and access its attributes
>>> st = constructs.Stack(G).StackTuple    # converts G to a namedtuple
>>> st.order                               # access namedtuple attributes
{1: [400.0, 'outer'],
 2: [200.0, 'inner']
 3: [800.0, 'middle']
 4: [200.0, 'inner']
 5: [400.0, 'outer']}
>>> st.nplies
5
>>> st.name
'5-ply'
>>> st.alias
'standard'

constructs :: class Stack --> class Laminate

theories :: class BaseModel

class Stack --> StackTuple
 |
class Laminate --> Snapshot, LFrame, LMFrame
 |
 | # Phase 1 : Instantiate; Determine Laminate ID Values
 | Laminate._build_snapshot(stack) --> Snapshot
 |     |
 |   Stack.add_materials(stack)
 |   Stack.stack_to_df(stack)        # first creation of the Laminate df
 |   Laminate._set_stresses(stack)
 |
 | Laminate._build_laminate(snapshot) --> LFrame
 |
 | # Phase 2 : Calculate Laminate Dimensional Values
 | Laminate._update_columns._update_dimensions() --> LFrame (updated)
 |        label_, h_, d_, intf_, k_, z_, Z_
 |
 | # Phase 3 : Calculate Model Values
 | Laminate._update_columns._update_calculations() --> LMFrame
 |    theories.Model(Laminate)
 |    models.<selected model>
 |       _calc_stiffness()
 |       _calc_bending()
 |       _calc_moment()
 |       global_vars = [`v_eq`, `D_11T`, `D_12T`, ...]
 |       inline_vars = [`Q11`, `D11` `strain_r`, ...]
 |
LaminateModel : df

Additional Details¶

More on Material Stacking Order¶

The material order is initially defined by the user mat_props dict in distributions and automatically parsed in the input_ module. Extracting order from a dict is not trivial, so the default sorting is alphabetical order. This order is handled by converting the dict to a pandas index. See Stack.add_materials() method for more details.

As of 0.4.3d4, the user can partially override the default ordering by setting the materials property in the Case instance. This allows simple control of the stacking order in the final laminate stack and Laminate objects. At the moment, a list of materials is cycled through; more customizations have not been implemented yet.

>>> case.material
['HA', 'PSu']                                     # alphabetical order
>>> case.material = ['PSu', 'HA']                 # overriding order
>>> case.material
['PSu', 'HA']
>>> case.apply(...)
<materials DataFrame>                             # cycles the stacking order

More on Laminate¶

Using Laminate._build_snapshot(), the instance stack dict is converted to a DataFrame (Snapshot), giving a primitive view of the laminate geometry, idenfiers (IDs) and stacking order. This “snapshot” has the following ID columns of infornation, which are accessible to the user in a Case instance (see distributions.Case.snapshot):

Variables addressed: `layer_, matl_, type_, t_`

From this snapshot, the DataFrame can is updated with new information. For example, the sides on which to expected tensile and compressive stresses are located (side_) are assigned to a laminate through the Laminate._set_stresses() method. This function accounts for DataFrames with even and odd rows. For odd rows, ‘None’ is assigned to the neutral axis, implying “no stress”.

Variables addressed: `side_`

Note

This stress assignment is a general designation, coarsely determined by which side of the netural axis a row is found. The rigorous or finite stress state must be calculated through other analytical tools means such as Finite Element Analysis.

Likewise, the DataFrame is further updated with columns of dimensional data (from Dimensional variables) and laminate theory data (from model variables). The current LaminateModel object is made by calling Laminate._update_columns._build_laminates() which updates the snapshot columns to build two DataFrame objects:

Here are similarities between the laminate data columns and the its objects:

• Snapshot: primiate DataFrame of the Stack (see materials, layer info order).
• LFrame: updated Snapshot of IDs and dimensionals.
• LMFrame: updated LFrame with models computed columns.

laminate objects

LMFrame is the paramount data structure of interest containing all IDs, Dimensional and Model variables and p number of rows pertaining to data points within a given lamina.

Dimensional variable columns are populated through the Laminate._update_columns._update_dimensions() method, which contains algorithms for calculating realative and absolute heights, thicknesses and midplane distances relative to the neutral axis. These columns contain dimensional data that are determined independent from the laminate theory model.

Variables addresed: `label_, h_, d_, intf_, k_, Z_, z_`

These variables are defined in the Laminate class docstring. See More on label_ to understand the role of points, p and their relationship to DataFrame rows.

Finally Data variable columns are populated using Laminate._update_columns._update_calculations(). These columnns contain data based on calculations from laminate theory for a selected model. Here global_vars and inline_vars are calculated.

Variables addressed:
--------------------
global_vars = [`v_eq, D_11T, D_12T, M_r, M_t, D_11p, D_12n, K_r, K_t`] --> FeatureInput['Global'] (dict entry)

inline_vars = [`Q11, Q12, D11, D12, strain_r, strain_t, stress_r, stress_t, stress_f`] --> LaminateModel object (DataFrame)

More on FeatureInput

A Feature module defines a FeatureInput object.

For distributions, it is defined in Case. FeatureInputs contain information that is passed between objects. For instance, this object transfers user input data in distributions (converted in input_) to the constructs module to build the laminate stack and populate ID and dimensional columns. A FeatureInput from distributions looks like the following (as of 0.4.4b).

FeatureInput = {
    'Geometry': <Geometry object>,
    'Loading': <load_params dict>,
    'Materials': <mat_props dict>,
    'Custom': <undefined>,
    'Model': <string>,
    'Globals': <dict>,
}

After calculating model data, the “Globals” key is updated containing all necessary globabl_vars. These variables are constant and are necessary for further calculations of inline_vars. Here is an example of Global variables key-value pair in FeatureInput.

FeatureInput['Globals'] = [v_eq, D_11T, D_12T, M_r, M_t, D_11p, D_12n, K_r, K_t]

More on label_

See LPEP 001.02 for standards of API units.

For this explanation, imagine we transverse the absolute height of the laminate at different cross-sectional planes. The values of inline stress points are calculated along different planes throughout the laminate thickness. What happens at interfaces where two materials meet with different stresses? How are these two stress points differentiated in a DataFrame or in a plot? For plotting purposes, we need to define diferent types of points. Here we define some rulse and four types of points found within a (i.e. DataFrame rows):

1. interfacial - point on unbound outer surfaces and bound internal surfaces.
2. internal - point with the lamina thickness between interfaces
3. discontinuity - point on bounded interfaces pertaining to an adjacent lamina
4. neutralaxis - the middle, symmetric axial plane

How these points are distributed depends on their locations within each lamina and whether they are located on the tensile or compressive side_. The neutral axis exists in physical laminates, but they are only represented as a row in DataFrames of odd ply, odd p laminates; they are not displayed in even laminates. The image below illustrates the different points from above with respect to k_ (the fractional height for a given layer).

points

Notice various layers have different point types.

• Middle layers have two interfacial points, no discontinuities and a neutral axis.
• All other layers have one interfacial point with a discontinuity if p >= 2.
• All layers may (or may not) have internal points.
• Monoliths do not have discontinuities

Note

Only the interfacial points can be theoreticlly verified, representing the maximum principal strains and stresses. The internal and discontinuity points are merely used by matplotlib to connect the points, assuming a linear stress distribution.

Note

The midplane z height (z_) for discontinuities assumes a non-zero, lower limit value equal to the Z_ height of the bounding layer. This value should be verified.

More on IndeterminateError

An IndeterminateError is thrown in cases where values cannot be calculated. An INDET keyword is given as values in DataFrame cells. An example for such an error is determining the stress state side_ for a monolith with one data point (nplies=1, p=1). From a design perspective, the location of the point is ambiguous, either one one interface, but more intuitively at the neutral access. At such a position, the value of stress would report zero, which is misleading for the true stress state of the monolith. Therefore, the InderminateError is thrown, recommending at least p = 2 for disambiguated stress calculations.

Core Module: theories¶

Laminate theory is merged with dimensional data to create a LaminateModel.

LaminateModel Handling¶

For clarify, an illustration of LaminateModel handling is shown below.

The Laminate DataFrame (LFrame) is passed from constructs to theories. If successful the LaminateModel is returned to constructs; otherwise an exception is thrown, consumed and the Laminate is returned unchanged (LFrame).

theories flowchart

Note

The term repr for <LaminateModel object> remains constant refering to a post-theories operation, whether LMFrame is updated with Model columns or not.

When Laminate._update_columns._update_calculations() (represented as Laminate.foo()) is called, an instance of the Laminate self (shown as “x”) is passed to theories.handshake() (black arrow). This function handles all updates to the primitive Laminate DataFrame (LFrame) which comprise IDs and Dimensional columns only. The Laminate gives the models author full access to its attributes. From here, theories.handshakes() searches within the models directory for a model (grey, dashed arrows) specified by the user at the time of instantiation, i.e. Case.apply(*args, model=<model_name>).

A model is simply a module containing code that handles laminate theory calculations. The purpose of the model is to update the primitive LFame with LT calculations. handshake() automatically distinguishes whether the author implemented a class-style or function-style model. The most important hook method/function is ``_use_model_()``, which must be present somewhere inside the model module and must return a tuple containing:

- the updated Laminate DataFrame with model data columns (a.k.a. `LaminateModel`)
- the `FeatureInput` with updated `'Globals'` key.  `'Globals'` is a dict of calculated constants, used in exported reports (see output_ section).

Finally, the Laminate.LMFrame attribute is updated with the new LaminateModel and FeatureInput (green arrow). However, if exceptions are raised, Laminate._update_calculations() handles them by reverting the LMFrame to a copy of LFrame, printing a warning and printing a minor traceback informing the author to refactor the code. This is commom for Laminates with p=1, which detects an INDET in middle layers and must revert to LFrame. The handshake() method for more details on Exceptions.

Core Module: output_¶

A summary of output objects

The utils.tools.export() function is used to save regular or temporary file versions of .xslx or .csv files. Files are automatically stored in the default export folder. More details are shown in the Demonstrations file.

Philosphophy on Reproducibility¶

Problem: The same package can behave differently based on:

1. the dependency environment and versions
2. third-party updates to dependencies
3. operating system (OS)

The first is and second items are prevented with pinned dependencies, one method for repeatable packages. The third item is prevented by through continuous integration, specifically with Travis and Appveyor (for Linux and Windows systems respectively). We will discuss proposals for the first two items only.

Proposal: We endorse freezing of dependencies at the start and end of the delevopment release cycle.

• Start: freeze the conda enviroment in an environment.yaml file
• End: freeze all dependencies in dev_requirement.txt and critical dependencies in requirements.txt files.

In [ ]:

# TODO: Add diagram of trends in typical release cycle; show start and end freezings.

How Reprodicibility Is Approached in LamAna¶

If packages work flawlessly, reproducible environments are generally not necessary for successful package use. Reproducible enviroments do become important when dependencies conflict with the package due to bugged patches or API changes in sub-dependencies. LamAna support either a “hands-off” or “hands-off” approach to versioning dependencies.

$ pip install lamana

$ pip install -r </path/to/requirements.txt>

$ pip install lamana                        # source

$ pip install lamana --use-wheel            # binary

Creating a developer environment with conda¶

The latter methods can be very slow, especially when intalling dependencies that rely on C extensions (numpy, pandas). Anaconda serves as the most consistent option for building dependencies and sub-dependencies. Here is a supporting rationale for using conda in travis. The following creates a fresh conda environment with critical dependencies that trigger installation of sub-dependencies required for LamAna.

$ git clone -b <branch name> https://github.com/par2/lamana
$ conda create -n <testenv name> pip nose numpy matplotlib pandas
$ source activate <testenv name>       # exclude source for Windows
$ pip install -r dev_requirements.txt
$ pip install .                        # within lamana directory

The first command downloads the repo from a spefic branch using git. The second command creates a reproducbile virtual environment using conda where therein, isolated versions of pip and nose are installed. Specific dependencies of the latest versions are downloaded within this environment which contain a necessary backend of sub-dependencies that are difficult to install manually. The environment is activated in the next command. Once the conda build is setup, pip will downgrade the existing versions to the pinned versions found in the requirments.txt file. Afterwards, the package is finally installed mimicking the original release environment.

The latter installation method should work fine. To check, the following command should be able to run without errors:

$ nosetests

Now, you should be able to run include jupyter notebook Demos.

$ apt-get install build-essential python3-dev

As an Author¶

As a Developer¶

In [ ]:

# TODO: add gitflow, workflow diagram

Resources¶

If you are new to developing, here are some resources to get started on this project:

• git: default version control
• GitHub: git host opensource projects
• gitflow-avh: a git extension used to ease development workflow
• atom: an great, open source text editor [using linter, flake8, minimap, pygments, colorpicker]

The following packages are available in conda or pip:

• virtualenv: create reproducible, isolated virtual enviroments
• vituralenvwrapper: simplify virtualenv creation; see also virtualenvwrapper-win for Windows
• nose: test code; see also pytest alternative.

The following are Sphinx extensions helpful in documenting code:

• autodoc: auto generate api docs
• autosummary: make a custom API reference, summary table
• nbsphinx: auto generate rst files from jupyter notebook files
• numpydoc: auto format docs using numpy-style docstrings
• napoleon: numpy and google-style doctrings
• viewcode: link api references and see implementation of the code directly in source.

The following are useful web-based tools:

• Travis: test builds on linux/Mac systems and dependency versions
• readthedocs: automate doc builds (in a travis-like way)
• TestPyPI: Test code before officially hosting to PyPI
• PyPI: host Python projects

Testing code with nose¶

The current testing utility is nose. From the root directory, you can test all files prepended with “test_” by running:

$ nosetests

There are three types of tests contained in the source lamana directory:

1. module tests: normal test files located in the ”./tests” directory
2. model tests: test files specific for custom models, located in ”./models/tests”
3. controls: .csv files located ”./tests/controls_LT”

Models tests are separated to support an extensibile design for author contributions. This design enables authors to create models and tests together with a single pull request to the standard module directory.

Tests for the utils module writes and removes temporary files in a root directory called “export”. If this directory does not exist, one will be created. These test check that writing and reading of files are consistent. Temporary files are prefixed with “temp”, but should be removed by these test functions.

Coverage¶

We use the following tools and commands to assess test coverage. nose-cov helps to combine coverage reports for sub-packages automatically. The remaining flags will report missing lines for the source directory.

$ pip install coverage, nose-cov
$ nosetests --with-cov --cov lamana

or

$ nosetests --with-cov --cov-report term-missing --cov lamana

LamAna aims for the highest “reasonable” coverage for core modules. A separate ideology must be developed for testing output_ as plots are tricky to test fully.

Regression Testing¶

Prior to a release, it is fitting to test API regression tests on any demonstration notebooks in a development virtual environment and release branch (see docs/demo.ipynb). A simple way to validate API is to run demo.ipynb notebook in Python 3 and Python 2 kernels.

Another simple way to validate notebook cells without errors is to use the `runipy tool <https://github.com/paulgb/runipy>`__. This tool will run notebook cells in the command prompt and halt if errors are found. The command is simple to apply to a notebook:

$ pip install runipy
$ runipy <demo>.ipynb

If no errors were found, your tested API works, and you can advance in the release workflow.

As a Developer¶

docs
|
|+ _archive
|+ _images
|- conf.py
|- Makefile
|- make.bat
|- index.rst
|- *.ipynb
|- ...

$ sphinx-api -f -o ./docs/generated .

$ make clean

$ make html

User Input Startup¶

In [4]:

#------------------------------------------------------------------------------
import pandas as pd

import lamana as la
#import LamAna as la

%matplotlib inline
#%matplotlib nbagg
# PARAMETERS ------------------------------------------------------------------
# Build dicts of geometric and material parameters
load_params = {'R' : 12e-3,                                # specimen radius
               'a' : 7.5e-3,                               # support ring radius
               'r' : 2e-4,                                 # radial distance from center loading
               'P_a' : 1,                                  # applied load
               'p' : 5,                                    # points/layer
               }

# Quick Form: a dict of lists
mat_props = {'HA' : [5.2e10, 0.25],
             'PSu' : [2.7e9, 0.33],
             }

# Standard Form: a dict of dicts
# mat_props = {'Modulus': {'HA': 5.2e10, 'PSu': 2.7e9},
#              'Poissons': {'HA': 0.25, 'PSu': 0.33}}


# What geometries to test?
# Make tuples of desired geometeries to analyze: outer - {inner...-....}_i - middle

# Current Style
g1 = ('0-0-2000')                                          # Monolith
g2 = ('1000-0-0')                                          # Bilayer
g3 = ('600-0-800')                                         # Trilayer
g4 = ('500-500-0')                                         # 4-ply
g5 = ('400-200-800')                                       # Short-hand; <= 5-ply
g6 = ('400-200-400S')                                      # Symmetric
g7 = ('400-[200]-800')                                     # General convention; 5-ply
g8 = ('400-[100,100]-800')                                 # General convention; 7-plys
g9 = ('400-[100,100]-400S')                                # General and Symmetric convention; 7-plys

'''Add to test set'''
g13 = ('400-[150,50]-800')                                 # Dissimilar inner_is
g14 = ('400-[25,125,50]-800')


geos_most = [g1, g2, g3, g4, g5]
geos_special = [g6, g7, g8, g9]
geos_full = [g1, g2, g3, g4, g5, g6, g7, g8, g9]
geos_dissimilar = [g13, g14]

# Future Style
#geos1 = ((400-400-400),(400-200-800),(400-350-500))        # same total thickness
#geos2 = ((400-400-400), (400-500-1600), (400-200-800))     # same outer thickness

In [5]:

#import pandas as pd
pd.set_option('display.max_columns', 10)
pd.set_option('precision', 4)

Goal: Generate a Plot in 3 Lines of Code¶

In [6]:

case1 = la.distributions.Case(load_params, mat_props)      # instantiate a User Input Case Object through distributions
case1.apply(['400-200-800'])
case1.plot()

Converting mat_props to Standard Form.
User input geometries have been converted and set to Case.

That’s it! The rest of this demonstration showcases API functionality of the LamAna project.

Calling Case attributes¶

Passed in arguments are acessible, but can be displayed as pandas Series and DataFrames.

In [7]:

# Original
case1.load_params

Out[7]:

{'P_a': 1, 'R': 0.012, 'a': 0.0075, 'p': 5, 'r': 0.0002}

In [8]:

# Series View
case1.parameters

Out[8]:

P_a    1.000e+00
R      1.200e-02
a      7.500e-03
p      5.000e+00
r      2.000e-04
dtype: float64

In [9]:

# Original
case1.mat_props

Out[9]:

defaultdict(<class 'dict'>, {'Poissons': {'PSu': 0.33, 'HA': 0.25}, 'Modulus': {'PSu': 2700000000.0, 'HA': 52000000000.0}})

In [10]:

# DataFrame View
case1.properties

Out[10]:

In [11]:

# Equivalent Standard Form
case1.properties.to_dict()

Out[11]:

{'Modulus': {'HA': 52000000000.0, 'PSu': 2700000000.0},
 'Poissons': {'HA': 0.25, 'PSu': 0.33000000000000002}}

Reset material order. Changes are relfected in the properties view and stacking order.

In [12]:

case1.materials = ['PSu', 'HA']
case1.properties

Overriding materials order...

Out[12]:

Serial resets

In [13]:

case1.materials = ['PSu', 'HA', 'HA']
case1.properties

Overriding materials order...

Out[13]:

In [14]:

case1.materials                                          # get reorderd list of materials

Getting materials...

Out[14]:

['PSu', 'HA', 'HA']

In [15]:

case1._materials

Out[15]:

['PSu', 'HA', 'HA']

In [16]:

case1.apply(geos_full)

User input geometries have been converted and set to Case.

In [17]:

case1.snapshots[-1]

Accessing snapshot method.

Out[17]:

In [18]:

'''Need to bypass pandas abc ordering of indicies.'''

Out[18]:

'Need to bypass pandas abc ordering of indicies.'

Reset the parameters

In [19]:

mat_props2 = {'HA' : [5.3e10, 0.25],
              'PSu' : [2.8e9, 0.33],
             }

In [20]:

case1 = la.distributions.Case(load_params, mat_props2)
case1.properties

Converting mat_props to Standard Form.

Out[20]:

apply() Geometries and LaminateModels¶

Construct a laminate using geometric, matrial paramaters and geometries.

In [21]:

case2 = la.distributions.Case(load_params, mat_props)
case2.apply(geos_full)                                     # default model Wilson_LT

Converting mat_props to Standard Form.
User input geometries have been converted and set to Case.

Access the user input geometries

In [22]:

case2.Geometries                                           # using an attribute, __repr__

Out[22]:

[Geometry object (0.0-[0.0]-2000.0),
 Geometry object (1000.0-[0.0]-0.0),
 Geometry object (600.0-[0.0]-800.0),
 Geometry object (500.0-[500.0]-0.0),
 Geometry object (400.0-[200.0]-800.0),
 Geometry object (400.0-[200.0]-400.0S),
 Geometry object (400.0-[200.0]-800.0),
 Geometry object (400.0-[100.0,100.0]-800.0),
 Geometry object (400.0-[100.0,100.0]-400.0S)]

In [23]:

print(case2.Geometries)                                    # uses __str__

[Geometry object (0.0-[0.0]-2000.0), Geometry object (1000.0-[0.0]-0.0), Geometry object (600.0-[0.0]-800.0), Geometry object (500.0-[500.0]-0.0), Geometry object (400.0-[200.0]-800.0), Geometry object (400.0-[200.0]-400.0S), Geometry object (400.0-[200.0]-800.0), Geometry object (400.0-[100.0,100.0]-800.0), Geometry object (400.0-[100.0,100.0]-400.0S)]

In [24]:

case2.Geometries[0]                                        # indexing

Out[24]:

Geometry object (0.0-[0.0]-2000.0)

We can compare Geometry objects with builtin Python operators. This process directly compares GeometryTuples in the Geometry class.

In [25]:

bilayer = case2.Geometries[1]                              # (1000.0-[0.0]-0.0)
trilayer = case2.Geometries[2]                             # (600.0-[0.0]-800.0)
#bilayer == trilayer
bilayer != trilayer

Out[25]:

True

Get all thicknesses for selected layers.

In [26]:

case2.middle

Out[26]:

[2000.0, 0.0, 800.0, 0.0, 800.0, 400.0, 800.0, 800.0, 400.0]

In [27]:

case2.inner

Out[27]:

[[0.0],
 [0.0],
 [0.0],
 [500.0],
 [200.0],
 [200.0],
 [200.0],
 [100.0, 100.0],
 [100.0, 100.0]]

In [28]:

case2.inner[-1]

Out[28]:

[100.0, 100.0]

In [29]:

case2.inner[-1][0]                                         # List indexing allowed

Out[29]:

100.0

In [30]:

[first[0] for first in case2.inner]                        # iterate

Out[30]:

[0.0, 0.0, 0.0, 500.0, 200.0, 200.0, 200.0, 100.0, 100.0]

In [31]:

case2.outer

Out[31]:

[0.0, 1000.0, 600.0, 500.0, 400.0, 400.0, 400.0, 400.0, 400.0]

A general and very important object is the LaminateModel.

In [32]:

case2.LMs

Out[32]:

[<lamana LaminateModel object (0.0-[0.0]-2000.0), p=5>,
 <lamana LaminateModel object (1000.0-[0.0]-0.0), p=5>,
 <lamana LaminateModel object (600.0-[0.0]-800.0), p=5>,
 <lamana LaminateModel object (500.0-[500.0]-0.0), p=5>,
 <lamana LaminateModel object (400.0-[200.0]-800.0), p=5>,
 <lamana LaminateModel object (400.0-[200.0]-400.0S), p=5>,
 <lamana LaminateModel object (400.0-[200.0]-800.0), p=5>,
 <lamana LaminateModel object (400.0-[100.0,100.0]-800.0), p=5>,
 <lamana LaminateModel object (400.0-[100.0,100.0]-400.0S), p=5>]

Sometimes might you want to throw in a bunch of geometry strings from different groups. If there are repeated strings in different groups (set intersections), you can tell Case to only give a unique result.

For instane, here we combine two groups of geometry strings, 5-plys and odd-plys. Clearly these two groups overlap, and there are some repeated geometries (one with different conventions). Using the unique keyword, Case only operates on a unique set of Geometry objects (independent of convention), resulting in a unique set of LaminateModels.

In [33]:

fiveplys = ['400-[200]-800', '350-400-500', '200-100-1400']
oddplys = ['400-200-800', '350-400-500', '400.0-[100.0,100.0]-800.0']
mix = fiveplys + oddplys
mix

Out[33]:

['400-[200]-800',
 '350-400-500',
 '200-100-1400',
 '400-200-800',
 '350-400-500',
 '400.0-[100.0,100.0]-800.0']

In [34]:

# Non-unique, repeated 5-plys
case_ = la.distributions.Case(load_params, mat_props)
case_.apply(mix)
case_.LMs

Converting mat_props to Standard Form.
User input geometries have been converted and set to Case.

Out[34]:

[<lamana LaminateModel object (400.0-[200.0]-800.0), p=5>,
 <lamana LaminateModel object (350.0-[400.0]-500.0), p=5>,
 <lamana LaminateModel object (200.0-[100.0]-1400.0), p=5>,
 <lamana LaminateModel object (400.0-[200.0]-800.0), p=5>,
 <lamana LaminateModel object (350.0-[400.0]-500.0), p=5>,
 <lamana LaminateModel object (400.0-[100.0,100.0]-800.0), p=5>]

In [35]:

# Unique
case_ = la.distributions.Case(load_params, mat_props)
case_.apply(mix, unique=True)
case_.LMs

Converting mat_props to Standard Form.
User input geometries have been converted and set to Case.

Out[35]:

[<lamana LaminateModel object (400.0-[200.0]-800.0), p=5>,
 <lamana LaminateModel object (350.0-[400.0]-500.0), p=5>,
 <lamana LaminateModel object (200.0-[100.0]-1400.0), p=5>,
 <lamana LaminateModel object (400.0-[100.0,100.0]-800.0), p=5>]

DataFrame Access¶

You can get a quick view of the stack using the snapshot method. This gives access to a Construct - a DataFrame converted stack.

In [36]:

case2.snapshots[-1]

Accessing snapshot method.

Out[36]:

We can easily view entire laminate DataFrames using the frames attribute. This gives access to LaminateModels (DataFrame) objects, which extends the stack view so that laminate theory is applied to each row.

In [37]:

'''Consider head command for frames list'''

Out[37]:

'Consider head command for frames list'

In [38]:

#case2.frames

In [39]:

##with pd.set_option('display.max_columns', None):           # display all columns, within this context manager
##    case2.frames[5]

In [40]:

case2.frames[5].head()

Accessing frames method.

Out[40]:

In [41]:

'''Extend laminate attributes'''

Out[41]:

'Extend laminate attributes'

In [42]:

case3 = la.distributions.Case(load_params, mat_props)
case3.apply(geos_dissimilar)
#case3.frames

Converting mat_props to Standard Form.
User input geometries have been converted and set to Case.

NOTE, for even plies, the material is set alternate for each layer. Thus outers layers may be different materials.

In [43]:

case4 = la.distributions.Case(load_params, mat_props)
case4.apply(['400-[100,100,100]-0'])
case4.frames[0][['layer', 'matl', 'type']]
;

Converting mat_props to Standard Form.
User input geometries have been converted and set to Case.
Accessing frames method.

Out[43]:

''

In [44]:

'''Add functionality to customize material type.'''

Out[44]:

'Add functionality to customize material type.'

In [45]:

'''Show Geometry first then case use.'''

Out[45]:

'Show Geometry first then case use.'

In [46]:

case2.total

Out[46]:

[2000.0, 2000.0, 2000.0, 2000.0, 2000.0, 2000.0, 2000.0, 2000.0, 2000.0]

In [47]:

case2.total_middle

Out[47]:

[2000.0, 0.0, 800.0, 0.0, 800.0, 800.0, 800.0, 800.0, 800.0]

In [48]:

case2.total_middle

Out[48]:

[2000.0, 0.0, 800.0, 0.0, 800.0, 800.0, 800.0, 800.0, 800.0]

In [49]:

case2.total_inner_i

Out[49]:

[[0.0],
 [0.0],
 [0.0],
 [1000.0],
 [400.0],
 [400.0],
 [400.0],
 [200.0, 200.0],
 [200.0, 200.0]]

In [50]:

case2.total_outer

Out[50]:

[0.0, 2000.0, 1200.0, 1000.0, 800.0, 800.0, 800.0, 800.0, 800.0]

In [51]:

case2.total_outer[4:-1]                                    # slicing

Out[51]:

[800.0, 800.0, 800.0, 800.0]

In [52]:

[inner_i[-1]/2.0 for inner_i in case2.total_inner_i]       # iterate

Out[52]:

[0.0, 0.0, 0.0, 500.0, 200.0, 200.0, 200.0, 100.0, 100.0]

In [53]:

G1 = case2.Geometries[-1]
G1

Out[53]:

Geometry object (400.0-[100.0,100.0]-400.0S)

In [54]:

G1.total                                                   # laminate thickness (um)

Out[54]:

2000.0

In [55]:

G1.total_inner_i                                           # inner_i laminae

Out[55]:

[200.0, 200.0]

In [56]:

G1.total_inner_i[0]                                        # inner_i lamina pair

Out[56]:

200.0

In [57]:

sum(G1.total_inner_i)                                      # inner total

Out[57]:

400.0

In [58]:

G1.total_inner                                             # inner total

Out[58]:

400.0

LaminateModel Attributes¶

Access the LaminateModel object directly using the LMs attribute.

In [59]:

case2.LMs[5].Middle

Out[59]:

In [60]:

case2.LMs[5].Inner_i

Out[60]:

Laminates are assumed mirrored at the neutral axis, but dissimilar inner_i thicknesses are allowed.

In [61]:

case2.LMs[5].tensile

Out[61]:

Separate from the case attributes, Laminates have useful attributes also, such as nplies, p and its own total.

In [62]:

LM = case2.LMs[4]
LM.LMFrame.tail(7)

Out[62]:

Often the extreme stress values (those at the interfaces) are most important. This is equivalent to p=2.

In [63]:

LM.extrema

Out[63]:

In [64]:

LM.p                                                       # number of rows per group

Out[64]:

5

In [65]:

LM.nplies                                                  # number of plies

Out[65]:

5

In [66]:

LM.total                                                   # total laminate thickness (m)

Out[66]:

0.002

In [67]:

LM.Geometry

Out[67]:

Geometry object (400.0-[200.0]-800.0)

In [68]:

'''Overload the min and max special methods.'''

Out[68]:

'Overload the min and max special methods.'

In [69]:

LM.max_stress                                             # max interfacial failure stress

Out[69]:

0     0.379
5     0.013
10    0.151
14   -0.151
19   -0.013
24   -0.379
Name: stress_f (MPa/N), dtype: float64

NOTE: this feature gives a different result for p=1 since a single middle cannot report two interfacial values; INDET.

In [70]:

LM.min_stress

Out[70]:

4     0.227
9     0.009
15   -0.009
20   -0.227
Name: stress_f (MPa/N), dtype: float64

In [71]:

'''Redo tp return series of bool an index for has_attrs'''

Out[71]:

'Redo tp return series of bool an index for has_attrs'

In [72]:

LM.has_neutaxis

Out[72]:

0     False
1     False
2     False
3     False
4     False
5     False
6     False
7     False
8     False
9     False
10    False
11    False
12     True
13    False
14    False
15    False
16    False
17    False
18    False
19    False
20    False
21    False
22    False
23    False
24    False
Name: label, dtype: bool

In [73]:

LM.has_discont

Out[73]:

0     False
1     False
2     False
3     False
4      True
5     False
6     False
7     False
8     False
9      True
10    False
11    False
12    False
13    False
14    False
15     True
16    False
17    False
18    False
19    False
20     True
21    False
22    False
23    False
24    False
Name: label, dtype: bool

In [74]:

LM.is_special

Out[74]:

False

In [75]:

LM.FeatureInput

Out[75]:

{'Geometry': Geometry object (400.0-[200.0]-800.0),
 'Globals': {'D_11T': 31.664191802890315,
  'D_11p': 0.033700807714524279,
  'D_12T': 7.9406108505093584,
  'D_12n': -0.0084513446948124519,
  'K_r': 0.0034519261262397653,
  'K_t:': 0.0059650953251038216,
  'M_r': 0.15666895161350616,
  'M_t': 0.216290324549788,
  'v_eq ': 0.25077573114575868},
 'Materials': ['HA', 'PSu'],
 'Model': 'Wilson_LT',
 'Parameters': {'P_a': 1, 'R': 0.012, 'a': 0.0075, 'p': 5, 'r': 0.0002},
 'Properties': defaultdict(<class 'dict'>, {'Poissons': {'PSu': 0.33, 'HA': 0.25}, 'Modulus': {'PSu': 2700000000.0, 'HA': 52000000000.0}})}

In [76]:

'''Need to fix FeatureInput and Geometry inside LaminateModel'''

Out[76]:

'Need to fix FeatureInput and Geometry inside LaminateModel'

As with Geometry objects, we can compare LaminateModel objects also. [STRIKEOUT:This process directly compares two defining components of a LaminateModel object: the LM DataFrame (LMFrame) and FeatureInput. If either is False, the equality returns False.]

In [77]:

case2 = la.distributions.Case(load_params, mat_props)
case2.apply(geos_full)

Converting mat_props to Standard Form.
User input geometries have been converted and set to Case.

In [78]:

bilayer_LM = case2.LMs[1]
trilayer_LM = case2.LMs[2]
trilayer_LM == trilayer_LM
#bilayer_LM == trilayer_LM

Out[78]:

True

In [79]:

bilayer_LM != trilayer_LM

Out[79]:

True

Use python and pandas native comparison tracebacks that to understand the errors directly by comparing FeatureInput dict and LaminateModel DataFrame.

In [80]:

#bilayer_LM.FeatureInput == trilayer_LM.FeatureInput    # gives detailed traceback

In [81]:

'''Fix FI DataFrame with dict.'''

Out[81]:

'Fix FI DataFrame with dict.'

In [82]:

bilayer_LM.FeatureInput

Out[82]:

{'Geometry': Geometry object (1000.0-[0.0]-0.0),
 'Globals': {'D_11T': 19.498876544595319,
  'D_11p': 0.054826177209184083,
  'D_12T': 4.9555181486053437,
  'D_12n': -0.013933731800259629,
  'K_r': 0.0055968142719747937,
  'K_t:': 0.009677945375294943,
  'M_r': 0.15709082448075087,
  'M_t': 0.21644417677735781,
  'v_eq ': 0.25414377783621128},
 'Materials': ['HA', 'PSu'],
 'Model': 'Wilson_LT',
 'Parameters': {'P_a': 1, 'R': 0.012, 'a': 0.0075, 'p': 5, 'r': 0.0002},
 'Properties': defaultdict(<class 'dict'>, {'Poissons': {'PSu': 0.33, 'HA': 0.25}, 'Modulus': {'PSu': 2700000000.0, 'HA': 52000000000.0}})}

In [83]:

#bilayer_LM.LMFrame == trilayer_LM.LMFrame                # gives detailed traceback

plot() LT Geometries¶

CAVEAT: it is recommended to use at least p=2 for calculating stress. Less than two points for odd plies is indeterminant in middle rows, which can raise exceptions.

In [84]:

'''Find a way to remove all but interfacial points.'''

Out[84]:

'Find a way to remove all but interfacial points.'

We try to quickly plot simple stress distriubtions with native pandas methods. We have two variants for displaying distributions:

- Unnoormalized: plotted by the height (`d_`). Visaully: thicknesses vary, material slopes are constant.
- Normalized: plotted by the relative fraction level (`k_`). Visually: thicknesses are constant, material slopes vary.

Here we plot with the nbagg matplotlib backend to generatre interactive figures. NOTE: for Normalized plots, slope can vary for a given material.

In [85]:

from lamana.utils import tools as ut
from lamana.models import Wilson_LT as wlt

dft = wlt.Defaults()
#%matplotlib nbagg

# Quick plotting
case4 = ut.laminator(dft.geos_standard)
for case in case4.values():
    for LM in case.LMs:
        df = LM.LMFrame

df.plot(x='stress_f (MPa/N)', y='d(m)', title='Unnormalized Distribution')
df.plot(x='stress_f (MPa/N)', y='k', title='Normalized Distribution')

Converting mat_props to Standard Form.
User input geometries have been converted and set to Case.

Out[85]:

<matplotlib.axes._subplots.AxesSubplot at 0x9e43390>

While we get reasonable stress distribution plots rather simply, LamAna offers some plotting methods pertinent to laminates than assisting with visualization.

Demo - An example illustration of desired plotting of multiple geometries from distributions.

demo

This is image of results from legacy code used for comparison.

We can plot the stress distribution for a case of a single geometry.

In [86]:

case3 = la.distributions.Case(load_params, mat_props)
case3.apply(['400-200-800'], model='Wilson_LT')
case3.plot()

Converting mat_props to Standard Form.
User input geometries have been converted and set to Case.

We can also plot multiple geometries of similar total thickness.

In [87]:

five_plies = ['350-400-500',  '400-200-800', '200-200-1200', '200-100-1400',
              '100-100-1600', '100-200-1400', '300-400-600']

case4 = la.distributions.Case(load_params, mat_props)
case4.apply(five_plies, model='Wilson_LT')
case4.plot()

Converting mat_props to Standard Form.
User input geometries have been converted and set to Case.

In [88]:

'''If different plies or patterns, make new caselet (subplot)'''
'''[400-200-800, '300-[400,200]-600']            # non-congruent? equi-ply'''
'''[400-200-800, '400-200-0']                    # odd/even ply'''
# currently superimposes plots.  Just needs to separate.

Out[88]:

"[400-200-800, '400-200-0']                    # odd/even ply"

Exporting¶

Saving data is critical for future analysis. LamAna offers two formas for exporting your data and parameters. Parameters used to make calculations such as the FeatureInput information are saved as “dashboards” in different forms. - ‘.xlsx’: (default); convient for storing multiple calculationa amd dashboards as se[arate worksheets in a Excel workbook. - ‘.csv’: universal format; separate files for data and dashboard.

The lowest level to export data is for a LaminateModel object.

In [89]:

LM = case4.LMs[0]
LM.to_xlsx(temp=True, delete=True)                         # or `to_csv()`
;

Out[89]:

''

The latter LaminateModel data was saved to an .xlsx file in the default export folder. The filepath is returned (currently suppressed with the ; line).

The next level to export data is for a case. This will save all files comprise in a case. If exported to csv format, files are saved seperately. In xlsx format, a single file is made where each LaminateModel data and dashboard are saved as seperate worksheets.

In [90]:

case4.to_xlsx(temp=True, delete=True)                      # or `to_csv()`
;

Out[90]:

''

Generating Multiple Cases¶

We’ve already seen we can generate a case object and plots with three lines of code. However, sometimes it is necessary to generate different cases. These invocations can be tedious with three lines of code per case. Have no fear. A simple way to produce more cases is to instantiate a Cases object.

Below we will create a Cases which houses multiples cases that: - share similiar loading parameters/material properties and laminate theory model with - different numbers of datapoints, p

In [92]:

cases1 = la.distributions.Cases(['400-200-800', '350-400-500',
                                 '400-200-0', '1000-0-0'],
                                load_params=load_params,
                                mat_props=mat_props, model= 'Wilson_LT',
                                ps=[3,4,5])
cases1

Caselets not using `combine`.
User input geometries have been converted and set to Case.
User input geometries have been converted and set to Case.
User input geometries have been converted and set to Case.
User input geometries have been converted and set to Case.
User input geometries have been converted and set to Case.
User input geometries have been converted and set to Case.
User input geometries have been converted and set to Case.
User input geometries have been converted and set to Case.
User input geometries have been converted and set to Case.
User input geometries have been converted and set to Case.
User input geometries have been converted and set to Case.
User input geometries have been converted and set to Case.

Out[92]:

<lamana.distributions.Cases object at 0x0000000009B15710>, {0: <<class 'lamana.distributions.Case'> p=3, size=1>, 1: <<class 'lamana.distributions.Case'> p=3, size=1>, 2: <<class 'lamana.distributions.Case'> p=3, size=1>, 3: <<class 'lamana.distributions.Case'> p=3, size=1>, 4: <<class 'lamana.distributions.Case'> p=4, size=1>, 5: <<class 'lamana.distributions.Case'> p=4, size=1>, 6: <<class 'lamana.distributions.Case'> p=4, size=1>, 7: <<class 'lamana.distributions.Case'> p=4, size=1>, 8: <<class 'lamana.distributions.Case'> p=5, size=1>, 9: <<class 'lamana.distributions.Case'> p=5, size=1>, 10: <<class 'lamana.distributions.Case'> p=5, size=1>, 11: <<class 'lamana.distributions.Case'> p=5, size=1>}

Cases() accepts a list of geometry strings. Given appropriate default keywords, this lone argument will return a dict-like object of cases with indicies as keys. The model and ps keywords have default values.

A Cases() object has some interesting characteristics (this is not a dict):

• if user-defined, tries to import Defaults() to simplify instantiations
• dict-like storage and access of cases
• list-like ordering of cases
• gettable: list-like, get items by index (including negative indicies)
• sliceable: slices the dict keys of the Cases object
• viewable: contained LaminateModels
• iterable: by values (unlike normal dicts, not by keys)
• writable: write DataFrames to csv files
• selectable: perform set operations and return unique subsets

In [93]:

# Gettable

cases1[0]                                                 # normal dict key selection
cases1[-1]                                                # negative indices
cases1[-2]                                                # negative indicies

Out[93]:

<<class 'lamana.distributions.Case'> p=5, size=1>

In [94]:

# Sliceable

cases1[0:2]                                               # range of dict keys
cases1[0:3]                                               # full range of dict keys
cases1[:]                                                 # full range
cases1[1:]                                                # start:None
cases1[:2]                                                # None:stop
cases1[:-1]                                               # None:negative index
cases1[:-2]                                               # None:negative index
#cases1[0:-1:-2]                                           # start:stop:step; NotImplemented
#cases1[::-1]                                              # reverse; NotImplemented

Out[94]:

[<<class 'lamana.distributions.Case'> p=3, size=1>,
 <<class 'lamana.distributions.Case'> p=3, size=1>,
 <<class 'lamana.distributions.Case'> p=3, size=1>,
 <<class 'lamana.distributions.Case'> p=3, size=1>,
 <<class 'lamana.distributions.Case'> p=4, size=1>,
 <<class 'lamana.distributions.Case'> p=4, size=1>,
 <<class 'lamana.distributions.Case'> p=4, size=1>,
 <<class 'lamana.distributions.Case'> p=4, size=1>,
 <<class 'lamana.distributions.Case'> p=5, size=1>,
 <<class 'lamana.distributions.Case'> p=5, size=1>]

In [95]:

# Viewable
cases1
cases1.LMs

Out[95]:

[<lamana LaminateModel object (400.0-[200.0]-800.0), p=3>,
 <lamana LaminateModel object (350.0-[400.0]-500.0), p=3>,
 <lamana LaminateModel object (400.0-[200.0]-0.0), p=3>,
 <lamana LaminateModel object (1000.0-[0.0]-0.0), p=3>,
 <lamana LaminateModel object (400.0-[200.0]-800.0), p=4>,
 <lamana LaminateModel object (350.0-[400.0]-500.0), p=4>,
 <lamana LaminateModel object (400.0-[200.0]-0.0), p=4>,
 <lamana LaminateModel object (1000.0-[0.0]-0.0), p=4>,
 <lamana LaminateModel object (400.0-[200.0]-800.0), p=5>,
 <lamana LaminateModel object (350.0-[400.0]-500.0), p=5>,
 <lamana LaminateModel object (400.0-[200.0]-0.0), p=5>,
 <lamana LaminateModel object (1000.0-[0.0]-0.0), p=5>]

In [96]:

# Iterable
for i, case in enumerate(cases1):                         # __iter__ values
    print(case)
    #print(case.LMs)                                      # access LaminateModels

<<class 'lamana.distributions.Case'> p=3>
<<class 'lamana.distributions.Case'> p=3>
<<class 'lamana.distributions.Case'> p=3>
<<class 'lamana.distributions.Case'> p=3>
<<class 'lamana.distributions.Case'> p=4>
<<class 'lamana.distributions.Case'> p=4>
<<class 'lamana.distributions.Case'> p=4>
<<class 'lamana.distributions.Case'> p=4>
<<class 'lamana.distributions.Case'> p=5>
<<class 'lamana.distributions.Case'> p=5>
<<class 'lamana.distributions.Case'> p=5>
<<class 'lamana.distributions.Case'> p=5>

In [97]:

# Writable
#cases1.to_csv()                                          # write to file

In [98]:

# Selectable
cases1.select(nplies=[2,4])                               # by # plies
cases1.select(ps=[3,4])                                   # by points/DataFrame rows
cases1.select(nplies=[2,4], ps=[3,4], how='intersection') # by set operations

Out[98]:

{<lamana LaminateModel object (400.0-[200.0]-0.0), p=3>,
 <lamana LaminateModel object (1000.0-[0.0]-0.0), p=4>,
 <lamana LaminateModel object (1000.0-[0.0]-0.0), p=3>,
 <lamana LaminateModel object (400.0-[200.0]-0.0), p=4>}

LamainateModels can be compared using set theory. Unique subsets of LaminateModels can be returned from a mix of repeated geometry strings. We will use the default model and ps values.

In [99]:

set(geos_most).issubset(geos_full)                        # confirm repeated items

Out[99]:

True

In [100]:

mix = geos_full + geos_most                               # contains repeated items

In [101]:

# Repeated Subset
cases2 = la.distributions.Cases(mix, load_params=load_params, mat_props=mat_props)
cases2.LMs

Caselets not using `combine`.
User input geometries have been converted and set to Case.
User input geometries have been converted and set to Case.
User input geometries have been converted and set to Case.
User input geometries have been converted and set to Case.
User input geometries have been converted and set to Case.
User input geometries have been converted and set to Case.
User input geometries have been converted and set to Case.
User input geometries have been converted and set to Case.
User input geometries have been converted and set to Case.
User input geometries have been converted and set to Case.
User input geometries have been converted and set to Case.
User input geometries have been converted and set to Case.
User input geometries have been converted and set to Case.
User input geometries have been converted and set to Case.

Out[101]:

[<lamana LaminateModel object (0.0-[0.0]-2000.0), p=5>,
 <lamana LaminateModel object (1000.0-[0.0]-0.0), p=5>,
 <lamana LaminateModel object (600.0-[0.0]-800.0), p=5>,
 <lamana LaminateModel object (500.0-[500.0]-0.0), p=5>,
 <lamana LaminateModel object (400.0-[200.0]-800.0), p=5>,
 <lamana LaminateModel object (400.0-[200.0]-400.0S), p=5>,
 <lamana LaminateModel object (400.0-[200.0]-800.0), p=5>,
 <lamana LaminateModel object (400.0-[100.0,100.0]-800.0), p=5>,
 <lamana LaminateModel object (400.0-[100.0,100.0]-400.0S), p=5>,
 <lamana LaminateModel object (0.0-[0.0]-2000.0), p=5>,
 <lamana LaminateModel object (1000.0-[0.0]-0.0), p=5>,
 <lamana LaminateModel object (600.0-[0.0]-800.0), p=5>,
 <lamana LaminateModel object (500.0-[500.0]-0.0), p=5>,
 <lamana LaminateModel object (400.0-[200.0]-800.0), p=5>]

In [102]:

# Unique Subset
cases2 = la.distributions.Cases(mix, load_params=load_params, mat_props=mat_props,
                                unique=True)
cases2.LMs

Single geometry string detected. unique not applied. See combine=True keyword.
Single geometry string detected. unique not applied. See combine=True keyword.
Single geometry string detected. unique not applied. See combine=True keyword.
Single geometry string detected. unique not applied. See combine=True keyword.
Single geometry string detected. unique not applied. See combine=True keyword.
Single geometry string detected. unique not applied. See combine=True keyword.
Single geometry string detected. unique not applied. See combine=True keyword.
Single geometry string detected. unique not applied. See combine=True keyword.
Single geometry string detected. unique not applied. See combine=True keyword.
Single geometry string detected. unique not applied. See combine=True keyword.
Single geometry string detected. unique not applied. See combine=True keyword.
Single geometry string detected. unique not applied. See combine=True keyword.
Single geometry string detected. unique not applied. See combine=True keyword.
Single geometry string detected. unique not applied. See combine=True keyword.
User input geometries have been converted and set to Case.
User input geometries have been converted and set to Case.
User input geometries have been converted and set to Case.
User input geometries have been converted and set to Case.
User input geometries have been converted and set to Case.
User input geometries have been converted and set to Case.
User input geometries have been converted and set to Case.
User input geometries have been converted and set to Case.
User input geometries have been converted and set to Case.
User input geometries have been converted and set to Case.
User input geometries have been converted and set to Case.
User input geometries have been converted and set to Case.
User input geometries have been converted and set to Case.
User input geometries have been converted and set to Case.

Out[102]:

[<lamana LaminateModel object (0.0-[0.0]-2000.0), p=5>,
 <lamana LaminateModel object (1000.0-[0.0]-0.0), p=5>,
 <lamana LaminateModel object (600.0-[0.0]-800.0), p=5>,
 <lamana LaminateModel object (500.0-[500.0]-0.0), p=5>,
 <lamana LaminateModel object (400.0-[200.0]-800.0), p=5>,
 <lamana LaminateModel object (400.0-[200.0]-400.0S), p=5>,
 <lamana LaminateModel object (400.0-[200.0]-800.0), p=5>,
 <lamana LaminateModel object (400.0-[100.0,100.0]-800.0), p=5>,
 <lamana LaminateModel object (400.0-[100.0,100.0]-400.0S), p=5>,
 <lamana LaminateModel object (0.0-[0.0]-2000.0), p=5>,
 <lamana LaminateModel object (1000.0-[0.0]-0.0), p=5>,
 <lamana LaminateModel object (600.0-[0.0]-800.0), p=5>,
 <lamana LaminateModel object (500.0-[500.0]-0.0), p=5>,
 <lamana LaminateModel object (400.0-[200.0]-800.0), p=5>]

Subclassing Custom Default Parameters¶

We observed the benefits of using implicit, default keywords (models, ps) in simplifying the writing of Cases() instantiations. In general, the user can code explicit defaults for load_params and mat_props by subclassing BaseDefaults() from inputs_. While subclassing requires some extra Python knowledge, this is a relatively simple process that reduces a significant amount of redundant code, leading to a more effiencient anaytical setting.

The BaseDefaults contains a dict various geometry strings and Geometry objects. Rather than defining examples for various geometry plies, the user can call from all or a groupings of geometries.

In [103]:

from lamana.input_ import BaseDefaults

bdft = BaseDefaults()

# geometry String Attributes
bdft.geo_inputs                                           # all dict key-values
bdft.geos_all                                             # all geo strings
bdft.geos_standard                                        # static
bdft.geos_sample                                          # active; grows

# Geometry Object Attributes; mimics latter
bdft.Geo_objects                                          # all dict key-values
bdft.Geos_all                                             # all Geo objects
# more ...

# Custom FeatureInputs
#bdft.get_FeatureInput()                                   # quick builds
#bdft.get_materials()                                      # convert to std. form

Out[103]:

[Geometry object (0.0-[0.0]-2000.0),
 Geometry object (0.0-[0.0]-1000.0),
 Geometry object (1000.0-[0.0]-0.0),
 Geometry object (600.0-[0.0]-800.0),
 Geometry object (600.0-[0.0]-400.0S),
 Geometry object (500.0-[500.0]-0.0),
 Geometry object (400.0-[200.0]-0.0),
 Geometry object (400.0-[200.0]-800.0),
 Geometry object (400.0-[200.0]-800.0),
 Geometry object (400.0-[200.0]-400.0S),
 Geometry object (400.0-[100.0,100.0]-0.0),
 Geometry object (500.0-[250.0,250.0]-0.0),
 Geometry object (400.0-[100.0,100.0]-800.0),
 Geometry object (400.0-[100.0,100.0]-400.0S),
 Geometry object (400.0-[100.0,100.0,100.0]-800.0),
 Geometry object (500.0-[50.0,50.0,50.0,50.0]-0.0),
 Geometry object (400.0-[100.0,100.0,100.0,100.0]-800.0),
 Geometry object (400.0-[100.0,100.0,100.0,100.0,100.0]-800.0)]

The latter geometric defaults come out of the box when subclassed from BaseDefaults. If custom geometries are desired, the user can override the geo_inputs dict, which automatically builds the Geo_objects dict.

Users can override three categories of defaults parameters:

1. geometric variables
2. loading parameters
3. material properties

As mentioned, some geometric variables are provided for general laminate dimensions. The other parameters cannot be predicted and need to be defined by the user. Below is an example of a Defaults() subclass. If a custom model has been implemented (see next section), it is convention to place Defaults() and all other custom code within this module. If a custom model is implemented an located in the models directory, Cases will automatically search will the designated model modules, locate the load_params and mat_props attributes and load them automatically for all Cases instantiations.

In [104]:

# Example Defaults from LamAna.models.Wilson_LT
class Defaults(BaseDefaults):
    '''Return parameters for building distributions cases.  Useful for consistent
    testing.

    Dimensional defaults are inheirited from utils.BaseDefaults().
    Material-specific parameters are defined here by he user.

    - Default geometric and materials parameters
    - Default FeatureInputs

    Examples
    ========
    >>>dft = Defaults()
    >>>dft.load_params
    {'R' : 12e-3, 'a' : 7.5e-3, 'p' : 1, 'P_a' : 1, 'r' : 2e-4,}

    >>>dft.mat_props
    {'Modulus': {'HA': 5.2e10, 'PSu': 2.7e9},
    'Poissons': {'HA': 0.25, 'PSu': 0.33}}

    >>>dft.FeatureInput
     {'Geometry' : '400-[200]-800',
      'Geometric' : {'R' : 12e-3, 'a' : 7.5e-3, 'p' : 1, 'P_a' : 1, 'r' : 2e-4,},
      'Materials' : {'HA' : [5.2e10, 0.25], 'PSu' : [2.7e9, 0.33],},
      'Custom' : None,
      'Model' : Wilson_LT,
     }

    '''
    def __init__(self):
        BaseDefaults.__init__(self)
        '''DEV: Add defaults first.  Then adjust attributes.'''
        # DEFAULTS ------------------------------------------------------------
        # Build dicts of geometric and material parameters
        self.load_params = {'R' : 12e-3,                   # specimen radius
                            'a' : 7.5e-3,                  # support ring radius
                            'p' : 5,                       # points/layer
                            'P_a' : 1,                     # applied load
                            'r' : 2e-4,                    # radial distance from center loading
                            }

        self.mat_props = {'Modulus': {'HA': 5.2e10, 'PSu': 2.7e9},
                           'Poissons': {'HA': 0.25, 'PSu': 0.33}}

        # ATTRIBUTES ----------------------------------------------------------
        # FeatureInput
        self.FeatureInput = self.get_FeatureInput(self.Geo_objects['standard'][0],
                                             load_params=self.load_params,
                                             mat_props=self.mat_props,
                                             ##custom_matls=None,
                                             model='Wilson_LT',
                                             global_vars=None)