denisgomes / psi

Pipe Stress Infinity (PSI) - The pipe stress analysis and design software.

Pipe Stress Infinity

Overview

Pipe Stress Infinity (PSI) is an engineering analysis and design software used to evaluate the structural behavior and stresses of piping systems to a variety of different codes and standards.

PSI has an active developer and user community. If you find a bug or a problem with the documentation, please open an issue. Anyone is welcome to join our discord server were a lot of the development discussion is going on. It's also a great place to ask for help.

Some of the features of PSI are:

• Modeling of piping components such as Runs, Bends, Reducers, Valves, and Flanges
• Ability to specify section and material data properties for different cross-sections
• Access to a variety of different support types such as Anchors, global X, global Y, and global Z including non-linear support capability
• Assign loads such as Weight, Pressure, Thermal, Wind and Seismic
• Linear combinations of loads and combinations of load cases
• Stress evaluation based on B31.1 power piping code
• Linear static, modal and dynamic analyses
• Movements, support reactions, internal forces and code stress results
• And more...

Requirements

PSI supports Python 3.5 and above. The following is a list of libraries that it depends on:

• jinja2
• numpy
• pint
• tqdm

Installation

To install PSI, type the following command in the terminal:

$ pip install psi --user

Install From Source

If you're reading this README from a source distribution, you can install PSI with:

$ python setup.py install --user

You can also install the latest development version direct from Github using:

$ pip install https://github.com/denisgomes/psi/archive/master.zip

For local development install PSI in editable mode:

# with pip
$ pip install -e .

# with setup.py
$ python setup.py develop

There are no compilation steps during the installation; if you prefer, you can simply add this directory to your PYTHONPATH and use PSI without installing it. You can also copy PSI directly into your project folder.

Quickstart

To start PSI in interactive mode just type:

$ psi

PSI provides an interpreter with added functionality for creating and analyzing piping systems using Python scripts. Type the input file shown below in your favorite text editor and save it as demo.inp:

.. literalinclude:: ../examples/demo.inp
    :language: python

Now run the file above to get the displacements at the nodes and the reaction force at the anchor:

$ psi demo.inp > demo.out        # run demo.py and redirect to demo.out

Inspect the demo.out file to view the output:

.. literalinclude:: ../examples/demo.out

To go directly into interactive mode after running the model, use the -i switch:

$ psi -i demo.inp > demo.out     # start the PSI interpreter

Contribution

There are many different ways to contribute. You can promote PSI, fix bugs, participate on the mailing list, etc. Please read the documentation to find out more ways to contribute to the Community and Enterprise Editions.

Support

The Community Edition of PSI is open source and can be used free of charge. If the software adds value to your life i.e. you use it to do commercial work for example, consider donating to support PSI's ongoing development. Also please read the documentation about the feature rich Enterprise Edition.

Building Docs

PSI's documentation is hosted on Read the Docs. The PDF version and other popular formats are also available on this website. To build the docs, type the following from the project root directory:

$ cd docs
$ make clean && make html

Building Website

The PSI website (i.e. this site) consists of the project README.rst file hosted on GitHub via GitHub Pages. It lives on a branch called gh-pages and is viewable at the project website.

To build and upload the website, type the following from the project root directory:

$ cd www
$ make clean && make html   # for testing
$ make github               # to publish

Testing

$ cd tests
$ tox

Contact

PSI is developed by many individual volunteers, and there is no central point of contact. If you have a question about developing with PSI, or you wish to contribute, please join the mailing list or the discord server.

For license questions, please contact Denis Gomes, the primary author. Also check out the project links below.

• PSI on PyPI
• PSI documentation
• PSI discord server
• PSI mailing list
• PSI issue tracker

psi's Issues

Multiple Loadcase Report

Display summary of multiple loadcase results in one report.

Response Spectrum

Use the modal analysis results to compose a response spectrum analysis by summing the contributions from different modes.

Load Sequencing

Applying load vector one at a time to a displaced model similar to AutoPIPE to get more accurate non-linear solutions.

Data File

Implement a context manager for defining units when extracting data from data files. Look at the .from_file method in sections.py.

Extracting nodal results

When data is save in a loadcase by the solver, the hash of the model should be calculated and saved inside the loadcase. When the results are accesses by loadcase.results, a current hash must be calculated and compared to the hash set by the solver to determine if the model changed.

Overload the getitem magic methods for the LoadCase and LoadComb classes to extract nodal data. For example,

movements[10]['dx'] # returns the dx movement at node 10
movements[10][0] # also return the dx movement
movements[10][:3] # return dx, dy, dz
movements[10][:6:3] # return dx and rx
movements[10] # return dx, dy, dz, rx, ry, rz

Printing for debugging

A function that prints to sys.stdout directly is required as the default behavior of the print function is to print to file.

Implement All Piping Elements

Implement reducers, bends, rigids and all other elements. Pipe reducers are similar to bends in that their internal geometry is defined by a curve (brep). The bezier curve can be used to model a straight line in the case of the reducer with several approximating edges. This approach is also true for bend where a curve is approximated using multiple edges.

A reducer is approximated using multiple run elements. The internal run elements each have a slightly different diameter to account for the change in size of the reducer. The diameter of each run is the average of the large OD at node i and the smaller OD at node j.

When a model is analyzed, a solver pre-processor routine is responsible for creating the intermediate run nodes and elements attributable to each of the edges underlying the reducer and bend elements. Once the solve is completed, the temporary run elements and nodes are removed with the exception of the nodes for which a result is required. Once such case is the mid node of a bend element.

When a model is defined, the wirerep does not contain any bezier curves. Only during the solver pre-processor step is the curve actually created to define the run elements.

Units and Default Positional and Keyword Arguments

What values should be selected for function/method arguments as units may be changed anytime and so the defaults may no longer be valid.

Static Condensation (substructuring)

For bends and reducers use static condensation to reduce the total DOF for each element.

Document all Linear Static Analysis Components

Write all the necessary details in documentation required to perform linear static analysis. Document the API and how everything fits together. Provide simple tutorial examples and other modeling example for showing different modeling aspects exposed by the API.

Add Donate and Useful Links

Add donate button on project website and documentation links to Github sponsers. Setup github sponsers.

Add useful links to website and documentation links.

Project website Shell via Github Pages

Set up Github pages to work with the README including the following.

1. Same theming as documentation.
2. Link to github and forking.
3. Set up CNAME to with openpipstress domain.
4. Unlike the documentation the website is the Overview to the Contact section.

Tee Flexibility

Implement a way to account for tee flexibility factor. Typically this factor is 1 for different codes. The DOFs associated with the tee (in bending would have to be modified), however it's not exactly like modeling supports using the penalty approach.

Nonlinear Supports

Implement one directional supports. Supports with gaps and friction.

Settings and Units

Some of the setting options have a unit associated with them. How should settings be made units aware such that these options can integrate seamlessly with the rest of the software.

Renamed Method

Change the "apply" method to "assign" where applicable.

Spring Hanger Design

Design and implement a hanger design algorithm which allows for different thermal conditions to be met and either hot or cold load balanced supports.

Stress Intensification Factors (SIF)

Implement element based and connection based SIFs per a piping code of interest. Create a template which can be used for all different types of codes. The SIF for a reducer for example will apply to both end nodes of the reducer. Similarly the SIF for a bend will apply all three representative nodes of a bend, namely the near, mid and far nodes.

How to deal with fittings that also have a SIF, for example a reducing tee. Do we taken the max of the two or add them together? What does the code say to do?

V & V Problem for Linear Static Analysis

Create and document a set of verification and validation test problems for linear static analysis.

Docs Theming

Adding theming to documentation. Follow the alabaster theme documentation website. With the following options activated:

1. logo
2. description
3. fixed left sidebar, with donate option
4. Github fork link and fork button.
5. Clicking on a specific guide should go to page specific to that page and it TOC.

Configuration (settings) Management

Settings are saved as a per model basis.

Settings can be imported or exported.

Settings should be aware of units.

Time History

Use the Newmark method or some other time dependent approach to solve time history analyses.

Cladding and Refractory Objects

Implement cladding and refractory similar to insulation.

Determine the best way to implement these pipe attributes. Combine with insulation somehow or pipe section...?

Friction

Inclusion of non-linear friction.

Code Stress Report B31.1

Basic code stress reporting for B31.1 for single and multiple cases results.

Implement delete and update for all elements

Work out the details of how delete and update will work for the different elements.

A run for example can be resized. What happens when a run is delete. Do the points still stay intact. What happens to the adjacent elements. What happens to the adjacent element when a run is resized. These are the details that'll be have to be worked out for all the different types of elements.

Inclined Supports

Use penalty approach and multi-point constraints to implement supports offset from the global orthogonal coordinate directions.

Set up Read the Docs

Access to program documentation via Readthedocs.

Modal Analysis

Implement modal analysis to determine system frequencies due to different types of vibrations.

Load Combination for Stresses

Determine how to generate stress results for load combinations consisting for multiple load cases added together somehow (i.e. algebraically for example).

Write All Tests for Linear Static Analysis

Test all the different aspects of the API. The individual entities, containers and simple example problems that demonstrates how the API is used in practice.

Applying Weak Springs

Determine a way to apply very weak spring to unstable models. In the case the equilibrium state is maintained by the forces (thus requiring no supports), weak springs should be added in the diagonal of the stiffness matrix.

http://help.solidworks.com/2014/English/SolidWorks/cworks/c_Use_Soft_Spring_to_Stabilize_Model.htm

Loggers

Implement different loggers and make log handlers to output data in different ways.

1. For error file.

2. For log file?

3. For tqdm output?

Gravity loading for different unit systems

In base (i.e. SI) units, weight is calculated by multiplying the mass (kg) by the acceleration due to gravity (m/s^2) and given by Newtons. In imperial units, the issue of pound mass vs pound force comes into play. Mass is given by lbm and the acceleration by ft/s^2, however the units do not work out to force units unless multiplied by a g.c (pronounced g sub c) factor.

Operating Cases

A system may have multiple operating cases. Find the best way to assigned thermal, pressure and other loads to these cases.