OpenMDAO Logo

An open-source framework for efficient multidisciplinary optimization.

July 16, 2019
by admin
Comments Off on October 2019 OpenMDAO Workshop!

October 2019 OpenMDAO Workshop!

NASA Glenn Research Center will be hosting a public OpenMDAO workshop on October 28 – 29th, 2019 in Cleveland Ohio. We will be meeting at the Ohio Aerospace Institute.

The primary goal for the workshop is for the broad user community get a chance to interact directly with the OpenMDAO development team in order to discuss the current and future development of the framework. We want to focus on topics surrounding current functionality and future development. In other words, we want to talk about what is working and what is not working right now, and hear about things the community would like to see for future development. Your input will help us figure out our long term development roadmap, so this is your chance to have a voice!

Click here to register for the workshop. There is no cost to attend the workshop, but we will be offering an optional catered lunch each day that will cost ~$30 (total for both days).

We are looking for community members who want to give 15 minute talks about their use of OpenMDAO. There is a space on the registration form to indicate if you would like to present. We have space for between 8-12 talks in the schedule, though if there is a lot of volunteers with good topics we will potentially devote more of day 2 to additional talks.

We need to have a head-count for the workshop, so registration is going to close on September 1st, 2019. Please register ASAP and if you are interested in giving a talk then REALLY register ASAP so we can start to figure out the presentation schedule.

Tentative Schedule:

October 28:

9:00 – 12:00 AM: 6 community members give 15 minute talks about how they are using OpenMDAO. We specifically want to hear what works well for you and (more importantly) what does not work so well! After each talk, we will have 10-15 minutes of open discussion about any important points that each presenter raises.

1:00 – 4:00 PM: OpenMDAO development team will give some demos and tutorials for advanced OpenMDAO features on model visualization, and performance profiling.

October 29:

8:30 – 11:30 AM: 6 more community presentations (15 minutes each, with 15 minutes of discussion)

11:30 AM – 12:15 PM: Presentation and discussion of our OpenMDAO 2020 development roadmap. We will post the roadmap to our website a few weeks before the workshop to give participants a chance to think about it ahead of time. We are hoping to get a lot community input on this!

1:00 – 4:30 PM: Short introduction and training course for Dymos, a time-integration library built on top of OpenMDAO. The course will serve dual purposes:
1) Teach you how to solve optimal-control problems with Dymos.
2) Introduce you to a number of advanced features of OpenMDAO that offer 10-100x speed up for larger models.

If there is enough interest, we may also offer a short introduction for our pyCycle propulsion modeling library in this time as well.

Any questions can be directed to justin.s.gray “at” nasa.gov

June 27, 2019
by admin
Comments Off on OpenMDAO V2.8.0

OpenMDAO V2.8.0

This is a modest release, with a few bug fixes and small list of relatively minor added features. See the release notes for all details.

The biggest change in 2.8 is actually a roll-back of a warning message that was added in 2.7. If you upgraded and started getting a lot of new warnings about promoted inputs that were connected in a funky way… well, we made that go away. It wasn’t helpful and we got a lot of user feedback that we shouldn’t show it by default — and we do occasionally listen to user feedback 🙂

The other change worth noting is not technically a new feature, but rather a new convention. We now recommend that users do the following to import the OpenMDAO API:

import openmdao.api as om

This is a much more compact and convenient way of handling the imports. In hindsight, this is the obvious way of doing this, but since we lack a time machine all we can do is use this better approach from now on. No need to change all your existing scripts if you don’t want to, the old way still works! We’ve updated all our docs to use it though, and we’ll use it for everything going forward.

We hope this new release is useful to you!

June 25, 2019
by admin
Comments Off on Congrats to the 2019 AIAA-MDO Student Paper Competition Winners!

Congrats to the 2019 AIAA-MDO Student Paper Competition Winners!

The NASA OpenMDAO development team would like to congratulate the 2019 AIAA Multidisciplinary Design Optimization Technical Committee student paper competition winners!

1) Anil Yildirim: Aeropropulsive Design Optimization of a Boundary Layer Ingestion System


2) Sicheng He: A Coupled Newton-Krylov Time Spectral Solver for Wing Flutter and LCO Prediction


3) Payam Ghassemi: Adaptive Model Refinement with Batch Bayesian Sampling for Optimization of Bio-inspired Flow Tailoring

See you next year!

For Aviation 2020, there will be another student paper competition. Again, first prize will be $2000, second prize will be $1000, and third prize will be $500. If you’re thinking of submitting your work to that, you should definitely have a look at these papers!

May 28, 2019
by admin
Comments Off on OpenMDAO 2.7.0 Released

OpenMDAO 2.7.0 Released

OpenMDAO 2.7.0 has been released.

Here are the release notes listing the new features, bug fixes and a couple of backwards-incompatible changes:

New Features:

  • You can now define guess_nonlinear method at the group level
  • New documentation added about the N2 diagram usage
  • Significant improvement to documentation search functionality (by default, only searches the feature docs and user guide now)
  • Improvements to support for complex-step across a full model (specifically when guess_nonlinear is implemented)
  • Derivatives:
    • Improved support for full-model complex-step when models have guess_nonlinear methods defined
    • **Experimental** FD and CS based coloring methods for partial derivative approximation. Valuable for efficiently using FD/CS on vectorized (or very sparse) components
  • Solvers:
    • `Solver failed to converge` message now includes solver path name to make it more clear what failed
    • Improved pathname information in the singular matrix error from DirectSolver
    • Directsolver has an improved error message when it detects identical rows or columns in Jacobian
    • NonlinearGaussSeidel solver now accounts for residual scaling in its convergence criterion
    • New naming scheme for solver debug print files (the old scheme was making names so long it caused OSErrors)
  • Components:
    • ExecComp now allows unit=<something> and shape=<something> arguments that apply to all variables in the expression
    • New AkimaSpline component with derivatives with respect to training data inputs
  • Visualization
    • Several improvements for the N2 diagram for large models
    • N2 diagram html files have been reduced in size significantly
    • `openmdao view_model` command line utility now supports case record database files
    • (Experimental) Automatic XDSM generator (using either Latex with pyXDSM or html with XDSMjs)
      • contributed by Peter Onodi
      • uses XDSMjs v0.6.0 by Rémi Lafage (https://github.com/OneraHub/XDSMjs)

Backwards Incompatible API Changes:

  • New APIs for total derivative coloring that are more consistent with partial derivative coloring (previous APIs are deprecated and coloring files generated with the previous API will not work)
  • The API for providing a guess function to the BalanceComp has changed. guess_function is now passed into BalanceComp as an init argument.
  • Changed the N2 diagram json data formatting to make the file size smaller. You can’t use older case record databases to generate an N2 diagram with latest version.
  • The problem level `record_iteration` method was not properly respecting the includes specification
  • All component methods related to execution now include `discrete_inputs` and `discrete_outputs` arguments when a component is defined with discrete i/o. If no discrete i/o is defined, the API remains unchanged. (includes `solve_nonlinear`, `apply_nonlinear`, `linearize`, `apply_linear`, `compute`,
    `compute_jac_vec_product`, `guess_nonlinear`)
  • The internal Driver API has changed, a driver should execute the model with `run_solve_nonlinear` to ensure that proper scaling operations occur .

Bug Fixes:

  • CaseRecorder was reporting incorrect values of scaled variables (analysis was correct, only case record output was wrong)
  • ExecComp problem when vectorize=True, but only shape was defined.
  • Incorrect memory allocation in parallel components when local size of output went to 0
  • Multidimensional `src_indices` were not working correctly with assembled Jacobians
  • Fixed problem with genetic algorithm not working with vector design variables
    • contributed by jennirinker
  • Fixed incompatibility with mpich mpi library causing “PMPI_Allgather(945).: Buffers must not be aliased” error
    • contributed by fzhale and nbons

February 22, 2019
by admin
Comments Off on OpenMDAO 2.6.0 Released!

OpenMDAO 2.6.0 Released!

OpenMDAO 2.6.0 is out!

Here are the release notes listing the new features, bug fixes and a couple of backwards-incompatible changes:

New Features:
-------------

  • MetaModelStructured will detect NaN in requested sample and print a readable message.
  • ScipyOptimizeDriver now supports Hessian calculation option for optimizers that use it.
  • User can specify src_indices that have duplicates or have two inputs on a single component connected to the same output, and still have CSC Jacobian work.
  • User can get/set problem values in a straightforward manner: prob['var'] = 2., etc. even when running in parallel.
    • Problem 'get' access to distributed variables will raise an exception since it isn't clear what behavior is expected, i.e. should prob['comp.x'] return the full distributed variable or just the local part.
  • Directsolver has an improved error message when it detects identical rows or columns in Jacobian.
  • The NonlinearBlockGS solver has been updated with a less expensive implementation that does not call the compute method of Explicit components as many times.
  • User can request a directional-derivative check (similar to SNOPTs built-in level 0 check) for check_partials.
  • check_partials with compact_print will now always show all check pairs.
  • The N^2 diagram (from `openmdao view_model`) now shows the solver hierarchy.
  • KSComp has an improved, vectorized implementation.
  • list_inputs now includes a 'shape' argument.
  • User can generate an XDSM from a model (`openmdao xdsm`).
  • User can set `units=<something>` for an execcomp, when all variables have the same units.

Backwards Incompatible API Changes:
-----------------------------------

  • The default bounds enforcement for BoundsEnforceLS is now 'scalar' (was 'vector')
  • Direct solver will now use 'assemble_jac=True' by default
  • Recording options 'includes' and 'excludes' now use promoted names for outputs (absolute path names are still used for inputs)
  • FloatKrigingSurrogate has been deprecated since it does not provide any unique functionality.
  • FloatMultifiKrigingSurrogate has been deleted because it was never used, was incorrectly implemented, and provides no new functionality.

Bug Fixes:
----------

  • Complex-step around Newton+DirectSolver now works with assembled Jacobians.
  • Armijolinesearch implementation was incorrect when used with solve_subsystems. The implementation is now correct.

 

February 14, 2019
by admin
Comments Off on A fond farewell to Keith Marsteller

A fond farewell to Keith Marsteller

Many users of the OpenMDAO framework have interacted with Keith Marsteller in one way or another over the last 11 years. Keith has decided to move on to other projects and interests and, though the development team is sad to see him go, we wish him all the best in his new endeavors.

If you’ve used OpenMDAO at all, you’ve very likely felt Keith’s influence even if you didn’t realize it. He has managed our development and release process, led the construction of our entire CI system, played a key role in defining the structure our docs, built our web-site, and generally pitched in to keep the overall development process running smoothly all the time.  For users he often helped solve installation issues and provided guidance on how to build plugins.

Those who know Keith, even a little bit, know of his fondness of running up hills — the bigger the better, but he’ll do repeats if he has to!  Gradient based optimization is sometimes referred to as “climbing the hill”, and so in honor of Keith’s time on the team we are pleased to announce that Keith has been awarded the first ever,  OpenMDAO Hill Climb Award. This award is given to those who display stubborn determination in the face of huge hills (literal or metaphorical) that block their path, and climb to the top no matter what obstacles lie in their way. Keith earned this award by sticking with the project through over 10 years of development, three re-writes, 17000 different CI systems, 28 docs re-factors, an unexpected white-board marker battle, and far too many really bad inside jokes.

Keith, we’ll miss you, but we look forward to hearing about your new hill climb adventures in the future.

February 1, 2019
by admin
Comments Off on OpenMDAO Papers for Scitech 2019

OpenMDAO Papers for Scitech 2019

There are several new papers, published for Scitech 2019, that used OpenMDAO as a tool to reach their conclusions, that we wanted to share.  Here are seven OpenMDAO-related works that you may find interesting:

Battery performance modeling on sceptor x-57 subject to thermal and transient considerations,” by authors J. Chin, S. L. Schnulo, T. Miller, K. Prokopius, and J. S. Gray

Gradient-based propeller optimization with acoustic constraints,” by authors D. J. Ingraham, J. S. Gray, and L. V. Lopes.

Multi-point design and optimization of a turboshaft engine for tiltwing turboelectric vtol air taxi,”  by author J. W. Chapman.

Optimal control within the context of multidisciplinary design, analysis, and optimization,” by authors R. D. Falck and J. S. Gray.

Load flow analysis with analytic derivatives for electric aircraft design optimization,” by authors E. S. Hendricks, J. W. Chapman, and E. Artskin-Hariton.

Multipoint variable cycle engine design using gradient-based optimization,” by authorsJ. P. Jasa, J. S. Gray, J. A. Seidel, C. A. Mader, and J. R. R. A. Martins.

A Mixed Integer Efficient Global Optimization Algorithm with Multiple Infill Strategy – Applied to a Wing Topology Optimization Problem,” by authors S. Roy, Willam A. Crossley, B. K. Stanford, K. T. Moore, and J. S. Gray.

If you liked these, and want to see all publications related to OpenMDAO, check out our publications page.

January 22, 2019
by admin
Comments Off on The OpenMDAO Paper!

The OpenMDAO Paper!

A lot of blood, sweat, and tears has gone into OpenMDAO over the years. The project planning started in 2007, coding started in 2008, and our first release came in 2010. We’ve been through three major versions of the code:

  • V0 (2010-2013): our first attempt! Serial, with a really awkward API. This was the playground where we really found the core ideas that would power OpenMDAO!
  • V1 (2013-2017): OpenMDAO, now with parallel computing and a decent API! This was the first version of OpenMDAO to work in parallel, but we sacrificed serial performance to get there.
  • V2 (2017-[a long time into the future]): Awesome performance for both serial AND parallel models, plus an even better API.

With the release of OpenMDAO V2, we finally achieved flexible framework that was efficient for serial and parallel problems. So we finally wrote an overview paper for the framework, and its recently been accepted for publication in the Journal of Structural and Multidisciplinary Optimization. You can find the pre-print here.

There is a bit of something for everyone in this paper. There is a high-level overview of the framework, including how implicit and explicit components leverage the underlying core APIs to support multidisciplinary modeling. There is a walk-through example of how some of the key underlying mathematics of the framework are used and how analytic derivatives are computed. Lastly, there are  examples of how and when to use some of the specialized algorithms for computing derivatives efficiently for different kinds of problems.

We hope the paper helps you understand the framework better, and most importantly, helps you to solve some really nice MDO problems!

November 8, 2018
by admin
Comments Off on Research Debt

Research Debt

There is a new online journal called distill.pub that has an interesting new format. It places a particular emphasis on clear explanations of concepts and high-quality infographics that help to further understanding. This is so obviously a good idea, that it may seem somewhat unclear why a journal would need to explicitly include it as a metric for judging publications at all. The reality is that a lot of really great papers are not written with accessibility as a primary goal of the work. Researchers often focus on developing new theory, new applications, or new implementations to advance the state-of-the-art. There often isn’t time to develop clear and concise explanations that will help specialists and non-specialists alike understand the work, but the lack there of does limit the impact the work on the broader field. Still confused? Here, we made this super-fancy animation to help you understand it better!

The term “research debt” has been coined to describe this phenomenon, where some members of a particular community have made large advances but the broader group has yet to catch up.  distil.pub has a great, in-depth discussion of research debt. They talk about different ways it can occur, what its fundamental costs really amount to, and when you should consider investing the time and effort to reduce it. Distill.pub is looking to publish papers that help to reduce research debt! As our helps to demonstrate, good explanation helps others in the field to better understand and build off your work and thus increases its impact.

When reading about the idea of research debt, it became clear that OpenMDAO could be viewed as project that reduces the research debt in the gradient-based optimization community. The most advanced gradient-based optimization techniques, with analytic derivatives, offer the potential for 10-to-10,000-times faster optimizations. Unfortunately these methods are usually implemented in an ad-hoc and problem-specific manner that makes it tough to generalize to a wide range of applications. What OpenMDAO does is implement these methods in a way that makes it possible to use analytic derivatives without being an expert in them, and without having to use a custom implementation for each problem.

Since OpenMDAO version 2.3, we’ve been continuously introducing new features that offer dramatic performance improvements. If you haven’t tried out assembled Jacobians (added in v2.3), you are missing out! There is also a new graph-coloring approach that works miracles for some problems (added in v2.4).  But along the way we’ve also been trying to limit our own research debt by keeping the docs up-to-date and working to improve their clarity and usefulness. Writing more docs keeps the new methods more accessible to OpenMDAO users. More importantly, it also forces us to think about ways to explain the concepts more clearly and concisely which often leads to simpler APIs and more general implementations.

So if you’ve ever gotten really deep down into a literature review on a subject and thought, “Hey, there is a better way to explain all this!”, now you have a great place to publish peer-reviewed journal articles that will help everyone in the broader community. The exact same concept goes for OpenMDAO docs too. If you’re working with our tools and you think you see a way to explain features in a simpler and more general manner, please feel free to submit a pull request. We’ll be happy to add an acknowledgment in the docs you contributed, so you get credit for helping to pay down the research debt!

 

October 31, 2018
by admin
Comments Off on OpenMDAO version 2.5.0 is released!

OpenMDAO version 2.5.0 is released!

OpenMDAO 2.5.0 is out, containing lots of new features, including some backwards-incompatible changes.  Here are the release notes:

Release Notes for OpenMDAO 2.5.0

October 31, 2018

New Features:
--------------
- list_outputs() method now includes a `prom_name` argument to include the promoted name in the printed output (Thanks John Jasa!).
- N2 viewer now includes tool tip (hover over) showing the promoted name of any variable.
- Improved error msg when building sparse partials with duplicate col/row entries.
- You can now build the docs without MPI/PETSc installed (you will get warnings, but no longer errors).
- Major internal refactor to reduce overhead on compute_totals calls (very noticeable on large design spaces but still cheap problems).
- Components now have a `under_complex_step` attribute you can check to see if complex-step is currently active.
- Components `distributed` attribute has been moved to an option (old attribute has been deprecated).
- MetaModelUnstructured will now use FD for partial derivatives of surrogates that don't provide analytic derivatives (user can override the default settings if they wish to use CS or different FD config).
- Improvements to SimpleGA to make it more stable, and added support constraints via penalty functions (Thanks madsmpedersen and onodip).
- Parallel FD and CS at the component and group level is now supported.
- Can turn off the analytic derivative sub-system if it is not needed via an argument to setup().
- Derivative coloring now works for problems that run under MPI.

- New Components in the standard library:
    - Mux and Demux components.

- New CaseRecording/CaseReading Features:
    - DesVar AND output variable bounds are both reordered now.
    - Improved error msg if you try to load a non-existent file with CaseReader.

- **Experimental Feature**: Discrete data passing is now supported as an experimental feature... we're still testing it, and may change the API!

Backwards Incompatible API Changes:
------------------------------------
- `get_objectives` method on CaseReader now returns a dict-like object.
- Output vector is now locked (read-only) when inside the `apply_nonlinear` method (you shouldn't have been changing it then anyway!).
- default step size for complex-step has been changed to 1e-40.
- Moderate refactor of the CaseReader API. It is now self-consistent.
Fork me on GitHub