greg-hamel / femur Goto Github PK

Only Quad(Element2D) Class functionalities have been implemented yet.
The triangular function can base itself a lot on the Element2D methods, but needs its own way of calculating the Jacobien Matrix (J_e) as well as the Shape Functions Derivative Matrix (B_e).

Gauss Quadrature will be required as soon as we start implementing more dimensions.

This function will need to:

1. Return gauss weights and postions; and
2. Calculate the integral from -1 to 1 of the specified Quadrature.

I made a mistake in the implementation. Current nodes affected by the Cauchy condition are only affected by their neighbouring Cauchy conditions affected nodes and not all nodes like it should be.

Simple fix: Remove the reset part of the update_stiff_load_cauchy() method from in the Mesh2D class.

Only an per-element solver currently exists. The global solver would use the element-based solver in order to generate a global matrix that creates all interactions between each element-based matrices.

In order for this to work, a Assembler would need to be implemented either as a function or a class of its own.

The Mesh2D should be able to be given an analysis type.
This analysis type will then be passed on to the elements and nodes contained within the mesh for the Ne_ref and other shape functions derived results to follow their analysis-required shape.

Here is an example of one of the differences between the heat transfer equations and the structures-based equations.

Heat transfer:
Ne_ref = [N1, N2, N3, N4, ...]

Structures:
Ne_ref = [N1, 0, N2, 0, ...]
[ 0, N1, 0, N2, ...]

To complement the software, a weak-form evaluation method needs to be implemented.

This method would take input from the user (strong form equation and known values of temperature or displacement) and calculate the weak from representation.

This would allow the user to have a complete end-to-end solvability where the user could take the weak form as well as the calculated shape functions of each element to solve for each points and therefore allow for approximations.

This will be implemented into a project along with a few more issues.

More to follow.

In the current implementation, every element created will calculate its own shape functions. If multiple element of the same type (i.e. pre-defined Tria6) are created all instances of this class will create their own shape functions. These shape functions will all be the same because they are based on the reference element and not the real coordinates.

This process will take away a lot of time in the process.

I will need to update the algorithm to only calculate it with the first instance.

There are currently no test functions associated to FEMur.

Every release has to be tested manually using previously calculated examples. This does not allow a full code coverage of testing and definitely isn't kosher in a development process.

Tests will allow for a simpler and more autonomous review of code change.

The current implementation tried to calculate any type of jacobien matrices for any type of element. This proved to create some problems in the calculation of the jacobien matrices.

I will implement jacobien matrices on a pre-defined element basis (all pre-defined element will have a jacobien matrix tailored to them).

A Mesh2D class and its methods need to be implemented in order to create a solvable 2D mesh.

All variables that have the same function should be renamed with the same name in order to provide better reading between the two classes and facilitate issue #6.

For example:
nnodes (Element1D) vs num_nodes (Element2D)

The package currently focuses on heat transfer analysis and nothing else. The ground work has been developed, but still needs to be refined in order to be a fully functional heat transfer calculation model.

Furthermore, I do not want this package to be Heat Transfer limited. I would like to add a structure part to it and will do so in the future commits (slowly)

A few methods in both Element1D and Element2D look alike, if they are not the same.

Two things can be done in order to optimize this:

1. Generalize both methods, make them behave the same way and move them to the parent class (Element)
2. Move them to the parent class directly if they are the exact same.