An input file format converter from Nastran to Code_Aster is available at

https://sourceforge.net/projects/nastrantocodeas/

Vittorio

TBD

Here is the original source code from NASA:
https://github.com/nasa/NASTRAN-95

Based on this, Thomas Hermann (along with Harry Schaeffer), created this version:
https://github.com/OdonataResearchLLC/NASTRAN-95

Later, it seems (but not exactly sure of the timeline), that Luca created this version for Linux, which was was later distributed with Ubuntu:
https://github.com/ldallolio/NASTRAN-95
I think this is a more user friendly version that is easier to set up on the host computer, but not sure. TBD item.

Note from Vittorio:
I also compiled successfully NASTRAN-95, both under linux (Ubuntu 16.04) and Cygwin/windows. Under ubuntu the simplest way is to use the debian version already available.

Bill pointed us to the full user manual (1382 pages). The important of this manual (unlike the one on GitHub), is that is has the "Quick Reference Guide", which is what most end users are used to (as opposed to the programming related aspects).

https://ntrs.nasa.gov/search.jsp?R=19720022271

Thomas Hermann has a large collection of documents here:

https://www.odonata-research.com/referen...talog.html

https://www.odonata-research.com/referen...talog.html

A theoretical manual is here:
https://ntrs.nasa.gov/search.jsp?R=19790019360

A list of elements is shown here:
A list of elements is shown here ( https://github.com/SteveDoyle2/pyNastran/issues/583 )

EDIT: See this thread for the most current version: https://www.mystran.com/forums/showthread.php?tid=2

The older Intel MKL sparse solver has been removed. This was done because those libraries are no longer available and it was not a good sparse solver.

However, this means that a BDF should have the line "PARAM, SOLLIB, ZZPACK" to call LAPACK as the default solver. Otherwise, it will call the Intel solver by default, which is no longer available. I think the default should change to ZZPACK, but for for the meantime be aware of this item.

In other to best develop MYSTRAN, we should be aware of the other offerings.

CalculiX is an excellent FEA solver that has an ABAQUS-like input deck (the input deck is often interchangeable in same manner as MYSTRAN and NASTRAN are similar). This is a great advantage to those already familiar with ABAQUS. It also seems to be one of the most popular open source solvers.

Here is the website:
http://www.dhondt.de/

It is split into two aspects:
1. CalculiX CrunchiX (CCX) is the solver, which is developed by Guido Dhondt
2. CalculiX GraphiX (CGX) is a pre/post, which is developed by Klaus Wittig

A distinct advantage is that the solver has nonlinear capabilities. However, something important to notes is that all elements are 3D on the solver side. A user can specify a beam or shell element, but the solver internally expands those elements into 3D. This has some advantages and some disadvantages, but is not a "classical" approach to FEA.  I think this presents a bigger challenge for beam elements than shell elements. And one advantage is that shell elements automatically have transverse shear stiffness because they are ultimately 3D. Another thing to consider is that CalculiX only reports the beam results at the integration point (center of the beam element) and the user is often interested in the results at the nodes (ends of the beam element).

I have been impressed with CalculiX and have built some specialty pre/post programs with them ( www.espcomposites.com ) and (www.structuralfea.com)

----------------

There is some carry over from CaculiX to MYSTRAN:

1. The CalculiX developers are looking to incorporate a new sparse solver. We can learn a lot from their efforts.
2. CGX is a light pre/post that has some interesting capabilities. It uses an FRD file, which seems to be relatively straightforward. MYSTRAN could export a FRD file and CGX could be used.

MYSTRAN is largely compatible with programs that can read BDF/DAT files. MYSTRAN outputs OP2 and also NEU (though it is an older format).

While there are commercial programs that can use MYSTRAN, such as MSC Patran and Femap, these programs are expensive and are usually combined with their own solvers. Instead, this thread will present low cost or free/open pre/post software that works with MYSTRAN.

Using the OP2 interface, you can read large result files quickly and efficiently. Additionally, you can also extract a subset of the result data and write OP2/F06 result files.

FYI, see also this repository: https://github.com/MYSTRANsolver/MYSTRAN_Resources

BDF Readers

A BDF (Bulk Data File) or DAT file reader can be read to interrogate models, but are not all programs can be used to create a mesh, apply loads, etc.

pyNastran ( https://github.com/SteveDoyle2/pyNastran )
Using the BDF interface, you can read/edit/write Nastran geometry without worrying about field formatting. Many checks are also performed to verify that your model is correct.

FEX
A lightweight program (only 3MB) that can read and interrogate BDF files. It can be used to visually show the model, discover issues, measure, and perform various other operations. It has a built in tutorial and low learning curve. I found this to be a simple tool that is quite useful. It does not have post processing capabilities

This program no longer has a website, but the most recent version (1.1), can be downloaded here: https://www.mystran.com/misc/fex-1.1.zip

M3DFEA (http://www.m3dfea.com )
See below for additional information

LS-PrePost ( https://www.lstc.com/products/ls-prepost )
This is a pre/post that can create finite element models and can also read BDF files. See below for more information.

PreProcessors (With Native MYSTRAN Support)

Preprocessors have the ability to create geometry, a mesh, apply loads, etc. However, not all preprocessors can create a compatible MYSTRAN deck (BDF/DAT). These are programs that can natively create a NASTRAN deck. This is a significant advantage because the elements are linked to properties (among other things).

M3DFEA ( http://www.m3dfea.com )
A pre/post that supports NASTRAN (and MYSTRAN by extension). It is a free program, but not open source. It has only been evaluated on a preliminary basis, but looks like a promising option.


PreProcessors (Without Native MYSTRAN Support)

Mecway ( https://www.mecway.com)
Apre/post and has an internal Mecway solver as well. It also supports the CalculiX solver. A simple mesh converter has been partially developed, but a true translator from BDF to INP (CalculiX/ABAQUS) has not been developed. This may be a possible option in the future since pyNastran has some capabilities to do this. Although Mecway is not free, it is low cost.

LS-PrePost (https://lsdyna.ansys.com/download-install-overview/ links to here: https://ftp.lstc.com/anonymous/outgoing/lsprepost/ )
This is a pre/post that can create finite element models, but not native MYSTRAN decks. However, we are working on a generic converted that can covert nodes/elements from one program to another. While this is not the same as creating a BDF (in fact it is quite different), it may be functional approach for specific models. For example, models with only a few element types but where a very good geometry/mesh creation tool is required.

PostProcessors

pyNastran ( https://github.com/SteveDoyle2/pyNastran )
Open source and can post-process OP2 files. pyNastran is a very complete postprocessor. Also, the developer assists with MYSTRAN and developed the MYSTRAN OP2 files, which helps to ensure compatibility. pyNastran is considered to be the most native MYSTRAN post processor (there is also a BDF switch that can be turned on to improve postprocessing with MYSTRAN).

M3DFEA ( http://www.m3dfea.com )
A pre/post that supports NASTRAN (and MYSTRAN by extension). It is a free program, but not open source. It has only been evaluated on a preliminary basis, but looks like a promising option.

LS-PrePost ( https://www.lstc.com/products/ls-prepost )
This is a pre/post that can read NASTRAN Punch (PCH) files. We need to evaluate if it can read MYSTRAN Punch files.

Other

1D Elements (https://www.structuralfea.com/ )
A program that can use beam, rod, and spring elements in 2D space (linear static analysis, buckling analysis, natural frequency analysis). It has complete documentation and series of videos that explain how the program works. This program is not a general pre/post. Rather, it is a specific tool limited to beams, rods, and springs in 2D space.

Dear all,
have a look at 
http://www.f-e-x.com/
FEX is a free program that can read  Nastran INPUT and view/check the model
Bye
Vittorio

As discussed in this thread (https://www.mystran.com/forums/showthread.php?tid=6), one of the top priorities is to address the sparse solver.

For small DOF problems, this card "PARAM, SOLLIB, ZZPACK" can be used and is reliable (banded solver). However, for larger DOF programs, a sparse solver may be required. MYSTRAN currently uses an older Intel solver for this case (this only exists for the complied EXE but ***NOT*** for the files on GitHub, which is a known issue). However, this older sparse solver is not very reliable. This challenge has increased in priority because we can not use the older Intel MKL solver that Bill used in the past (so MYSTRAN only has the banded solvers LAPACK/ARPACK).

We are investigating various sparse solvers. We previously looked at BCSLIB-EXT, but the cost is relatively high and it appears there may be other solvers that are just as good (if not better).

1. The SPOOLES solver is an option, but it seems to be relatively slow compared to other options.
2. PARDSIO with Intel MKL is an option, but requires an Intel compiler and the user must also download the Intel MKL (personal information is required).
3. PARDISO 6 is more improved than PARDISO MKL, but requires the user download a free license every year (personal information is required).
4. PaStiX may be the best option since it is modern and free. We can take a page from CalculiX and see how their investigation is going since they looking at other solvers.

CalculiX has historically used SPOOLES, but recently added an option for the PARDISO MKL.

My personal feeling is to incorporate the SPOOLES solver for the time being and continue to investigate other solvers (and keep on eye on what CalculiX is doing). The SPOOLES solver has been around for a while and including it as an option would not be a disadvantage (even if we later add other sparse solver options). If anyone is interested in looking into this, go ahead and create a thread about it.

Brian Esp

These are some notes about NASTRAN, which may help to shed light about the state of NASTRAN-95:
-------------------------------

The FTC settlement with MSC resulted in the sale of UAI NASTRAN to a competitor. It wasn't made public. As I recall SDRC was the purchaser. They eventually were taken over by Siemens and UAI Nastran is part of their engineering software offering. The original NASA NASTRAN is still available but I don't know the details about that. 

The original Nastran was written in a subset of FORTRAN IV that would compile on IBM, CDC and Univac machines. Starting around 1979 <name omitted> led a project to put NASA Nastran on the Digital Equipment VAX computers running VMS. MSC complained about our doing what they had shown little interest in doing. MSC then did an updated version themselves that ran on VAX and other brands with FORTRAN 77 compilers. 

Meanwhile UAI also migrated their version to the VAX and other platforms including PCs running Windows. I provided the VAX computer UAI used for a lot of their debugging. You may recall that we had a rather rocky start with UAI Nastran but I helped them in various ways to use our VAX via a phone dial up connection (1200 baud!). Given the three hour difference in California time, the arrangement worked fairly well as they used our VAX after we went home. Eventually UAI's version worked as well as MSC's did. As you know, UAI had better sub structuring. Eventually MSC took over UAI and then CSA for good measure. Somebody (not us) sicced the FTC on them and that eventually led to the anti-trust trial that almost happened. The day before the trial, MSC folded and negotiated the settlement that led ultimately to the Siemens version.