Topic: End releases on beam

Hi all,
I'm trying to get working a model translated from a commercial solver into OOFEM, and the original model (made in SAP2000) uses beam end releases, i.e. the stiffness contribution for some chosen DoFs are null at the ends of a beam element (example: moment releases at both ends).

I just want to know if there are some features in OOFEM to replicate this behavior. Looking in this page I cannot find nothing applicable.
Moreover, I cannot find any suitable "Dof manager" record to replicate this.

Thanks,
Giovanni

Re: End releases on beam

Well, there is functionality to condense dofs on some types of beam models (which means disconnecting moments and such).
See "beam2d_3.in"

However, I think it is a much better use slave dofs in OOFEM. It will work with any type of element and is more logical (i.e. you get correct reaction forces, displacements and everything, works with nonlinear models).
See "slavedofs.in"
Though, that example isn't that good. I remember making a better example for beams and doing momentless joints using duplicate nodes + slave dofs, but I can't find it here at work. I'll check at home later.

Re: End releases on beam

Thanks Mikael.

Some points:
In "slavedofs.in", the end release, typically a property of the element, is obtained applying DoFidmask to node. If I understood correctly the model, 2D trusses are simulated through beam2d elements. In the line:

node 4 coords 3 0.  0.  0.  dofidmask 3 1 3 5 masterMask 3 1 1 0 doftype 3 1 1 0

the "masterMask" keyword, which relies on another (coincident) node to apply the releases, oblige the user to change the beam connectivity.

I agree that this second example uses a more powerful approach for modelling end releases, but the replication of the single node is needed to to that. On the contrary, in the 1st example I think that "DoFtoCondense" would work only in elastic field, right?

Re: End releases on beam

The usage is correct, but I wouldn't say it's simulating beams, as this property shouldn't be part of the elements to start with. Node 4 in that example is a bearing-joint to node 1. So it's the other way around; beam end releases is just a limited way of simulating a bearing joint.

Say you wish to weld 2 beams into one side of a bearing, and two other beams welded into the other side of the bearing. The angle of each pair of beams would should in this case be fixed.
This is impossible to achieve by manipulating each beams end forces, due to the fact that it's a property of each individual beam.


The dof condensation code could possibly be modified to correctly take into account nonlinearities, but it's unlikely to be correct as it is today (haven't checked carefully).  I would prefer to see the code eliminated rather than fixed, as the method lies about the results in the output file (rotation of the released beams are no longer part of the solution, and they can't be visualized).  I think the bearing joints are much much easier to understand, and they have huge technical advantages.

In OOFEM, only 1 dof type per node is a very fundamental concept, and can not be changed, so we definitely need to add another node, since we want to add another rotational degree of freedom.


We could, if we wanted, create a special type node that does all the dofidmask stuff automatically:

bearing2d 4 master 1 # equivalent to dofidmask 3 1 3 5 masterMask 3 1 1 0 doftype 3 1 1 0
ballbearing 4 master 1 # equivalent to dofidmask 6 1 2 3 4 5 6 masterMask 6 1 1 1 0 0 0 doftype 6 1 1 1 0 0 0

which would have all those parameters as default, but unless there is a huge need for these, I would refrain from adding more code.

Re: End releases on beam

Hi Mikeal, I'd like to raise a question concerning the simple model here attached, which uses the doftocondense parameter.
As you can see, node reactions are nonzero whilst the end forces of the beam are zero. What's wrong with it?

Post's attachments

condense.zip 1.41 kb, 5 downloads since 2015-10-12 

You don't have the permssions to download the attachments of this post.

Re: End releases on beam

This is because the output from the beam element itself is not "aware" of the b.c.s applied by sets, so what you see in the output file is just the internal forces of the beam, which are zero for this beam.
Your load is projected on the basis functions and added to the nodes, it's never condensed. Should it be? No, it's not quite that simple.
If we condense the external forces from a beam, it would just disappear from that end, and it would not accumulate to the reaction force in the other node.

Basically, if you use distributed loads, you can't use dof condensation. It's not a OOFEM limitation, I just can't see a meaningful way to compute the answer. You need the second setup of DOFs to handle it correctly, and this is what the slave node does.


In fact, the beam model is the odd one out here, all the other elements will not try to print out nodal forces in the default output file. Normally, elements would print their integration point material status and that's it.

Re: End releases on beam

Mikael, thanks for your answers.
Anyway, it is not the best for me that only the second type of "releases" (dofidmask ...) would work properly. This is very risky.

To me, if I apply a distributed load (via sets or not) to a beam like in the file "condense.zip" and I want to "release" 1 or more dofs in the element, this loads should not be in the global reactions, otherwise there is a problem in the equilibrium (or in the sets that hold the loads, that must always refer to element behaviour and to nothing else). Too risky, truly.

On the other hand, there's too difficult to handle connectivity using the second type of solution you suggested. Imagine to have a truss assemblage, but made with beam3d properly "released". Now you want some nodal loads, and you will find N+1 nodes at each trusses intersection, where N is the number of concurrent trusses. It is definitely too complicated. Please note that the solution is not to use the truss3d elements directly, because if I want to see the beam diagrams caused by the self-weight loads, I need beam3d.

8

Re: End releases on beam

HI,

I don't have time now to see provided files, but I just want to point out that the do-condensation takes into account the distributed load and if dof is condensed on one end this affects the load vector values on the other side. The condensation is performed both on stiffness and load vector. Also the condensation in my opinion handles the non-linearity correctly, is just based on element equilibrium and using the fact that one of the end-forces is known to be zero, then this known relation is substituted to other beam equilibrium equations. So there is nothing concerning material non-linearity, only equilibrium is used.
There is an example  in tests/sm/beam2d_3.in illustrating the use of condensed dofs.

9 (edited by johnnyontheweb 13-10-2015 16:41:45)

Re: End releases on beam

Thanks bp. Just for you to know, with the beam2d_3.in I get the following errors (at least in my copy of the code...):

____________________________________________________
           OOFEM - Finite Element Solver
        Copyright (C) 1994-2014 Borek Patzak
____________________________________________________
Total number of solution steps     1


Solving ...

Checking rules...
_______________________________________________________
Warning: (errorcheckingexportmodule.C:175)
In oofem::ElementErrorCheckingRule::check:
Check failed in: tstep 1, element 1, gpnum 1, ist 7, component 2:
value is -4.83081068e+001, but should be -4.68592395e+001 ( error is 1.448867e+0
00 but tolerance is 1.000000e-005 )
_______________________________________________________
FloatArray of size : 3
-8.704e+000  -4.831e+001  1.674e+001
_______________________________________________________
Warning: (errorcheckingexportmodule.C:175)
In oofem::ElementErrorCheckingRule::check:
Check failed in: tstep 1, element 1, gpnum 1, ist 7, component 3:
value is 1.67422378e+001, but should be 6.75783746e+001 ( error is 5.083614e+001
 but tolerance is 1.000000e-005 )
_______________________________________________________
FloatArray of size : 3
-8.704e+000  -4.831e+001  1.674e+001
_______________________________________________________
Warning: (errorcheckingexportmodule.C:175)
In oofem::ElementErrorCheckingRule::check:
Check failed in: tstep 1, element 5, gpnum 1, ist 7, component 2:
value is -7.08912945e+001, but should be -6.37670945e+001 ( error is 7.124200e+0
00 but tolerance is 1.000000e-005 )
_______________________________________________________
FloatArray of size : 3
-1.296e+000  -7.089e+001  3.503e+001
_______________________________________________________
Error: (errorcheckingexportmodule.C:378)
In ErrorCheckingExportModule::oofem::ErrorCheckingExportModule::doOutput:
Rule not passed, exiting with error
_______________________________________________________
No backtrace available
Total 1 error(s) and 3 warning(s) reported
oofem exit code 1

The errors reported are due to errorchecking module; if I remove it from the analysis deck, I see all the results.
So, DofToCondense should work in non-linear analysis, good to know.

Re: End releases on beam

The fact that the beam reports end forces to begin with is a different issue, and the best solution was the beam export module instead.
I think the standard output should just report the integration point status, just like for any other element.

But there is no DOF (by choice of doing condensation) that can "hold" the load for the beam with the end release! For what equation would that load appear? There is no extra DOF, so there is no equation to apply the load to. Just zeroing the forces is not an option, because that's the same as not having them in the first place.

I was wrong in my wording before. It is possible to have external loads with proper static condensation. But it is messy and breaks modularity of the different components to the solver.
Static condensation that includes external forces is difficult to support, because it breaks other things. For example, load control, and error norms in newton iterations. Also very difficult to reconcile with sets, which has several major benefits to adaptivity and error estimation.
That's why, at least on element level, supporting condensation is quite difficult (when loads are involved).
And of course, nonlinear problems, proper static condensation can't be done at all (as far as I know).
That's why, unfortunately, I doubt I will it will ever be included in OOFEM.

Re: End releases on beam

But there is no DOF (by choice of doing condensation) that can "hold" the load for the beam with the end release! For what equation would that load appear? There is no extra DOF, so there is no equation to apply the load to. Just zeroing the forces is not an option, because that's the same as not having them in the first place.

I never said that, the condensation implies to transform also the load vector, as bp said before.

I understood that condensating external load can break other things, but IMHO the choice to renounce to that is hard to understand. Can a FE solver have things like XFEM, adaptivity, parallelism, and give in the meanwhile wrong reactions for the equilibrium of a simple elastic beam with a shear-release on one node?
This provocation apart, results without sets are correct (see attachments). As I said, I think this behaviour is too risky, at least for the beginner.

Post's attachments

OneEndRels.zip 2.74 kb, 2 downloads since 2015-10-13 

You don't have the permssions to download the attachments of this post.

Re: End releases on beam

Alright, so this has turned into me VS. condensation. But I'm not one to back away. I don't think nonlinearities are supported (or can be supported). I tested it out and it immediately diverged (works with slave nodes).
I attached a zip. I'm not surprised it doesn't work at all, as I will detail below.
The problems in the zip reflects the problem illustrated here:
http://www.oofem.org/resources/doc/oofe … ode49.html


BP:
I've never seen static condensation done on anything but linear systems, since, well, it's based around substructuring a linear system of equations (?).
Either way, this, for example, can't support nonlinear problems;

    FloatMatrix stiff;

    // The un-condensed value is computed for the "normal" solution vector, which doesn't post-process the un-condensed dofs.
    // This proves that the material with nonlinearities (layered c.s. with some plasticity maybe?) will be completely wrong.
    StructuralElement :: computeLocalForceLoadVector(answer, tStep, mode); // in global c.s

    if ( answer.giveSize() && dofsToCondense ) {
        // condense requested dofs
        if ( answer.giveSize() != 0 ) {
            this->computeClampedStiffnessMatrix(stiff, TangentStiffness, tStep);
            this->condense(& stiff, NULL, & answer, dofsToCondense);
        }
    }

So, I still don't think it will handle nonlinearities correctly, as it doesn't matter how the condensation is done, if the un-condensed answer is wrong (moment computed for the incorrect curvature).

Perhaps these problems can be fixed, but I'd need to see an example file before I'm convinced that it actaully support nonlinearities. Back when the condensation code was written, only linear problems for beam2d and beam3d was supported.


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

Giovanni;
I'm all for a good provocation!
I agree with you. I think the beam standard output should print the GP values of the material response and nothing else.
I think the condensation code should be removed since it has such a huge list of disadvantages.
If that was done, there would always be correct output.
( I'm not just now making this up, I talked to Borek about the condensation over a year ago: http://www.oofem.org/forum/viewtopic.php?id=1431 )

Condensing dofs is a very invasive operation. Beams now need to know of any external load in order to compute it's stiffness matrix, which isn't the case for any other element.

Using sets for loads is more than just an alternative syntax for the input files. Part of the reason (long term plans) I pushed for this is because this will enable me to do easier adaptivity for all types of analysis. It will enable me to implement a much simpler to use indirect load control while keeping the possibility of adaptivity/remeshing/change dirichlet b.c. at the same time (currently not possible).
These are major features planned, and the fact of removing the element loads from the elements directly is a central part of this.


Personally, I really can't understand why static condensation could ever be considered simpler than using a bearing-type node (or some other type of support) when explaining to a beginner. "Here is a bearing/hinge, you can connect beams/whatever to either side of it" is all there is to it. It clearly reflects real life components.
And most trusses you find in real life are, in fact, frames. So the need to have any extra rotations or the likes (with or without condensation) is nearly meaningless outside a few school book examples in mechanics.

Lets also take a look at the file (OneEndRels-Qk1.out)

...
beam element 1 :
  local displacements  0.0000e+000 0.0000e+000 0.0000e+000 0.0000e+000 0.0000e+000 0.0000e+000 0.0000e+000 0.0000e+000 0.0000e+000 0.0000e+000 0.0000e+000 0.0000e+000
...

That's wrong. The beam is free to deflect in dof 2 and 3, and will certainly do so on dof 3 with the load applied.
So my conclusion is that using condensation is just too risky for a beginner (and anyone else)!
It has so many many major disadvantages. You can't export the condensed dofs to VTK (or anywhere else]. You can't use in arc-length methods/indirect load control. You can't apply nodal loads to the condensed dof. You can't have 2 beams connected to the same condensed dof (it's *very* limited in terms of types of trusses and frames).

If it wasn't possible to do this type of analysis without condensation, then there would be a different discussion. But now we have a more general, works-in-all-cases, bulletproof, consistent, super flexible, proper, easy-to-explain, way of doing it with slave nodes.


Your counter to the slave nodes was basically that it was to inconvenient when you have a truss, so you have to do this for every beam. In that case, you have completely disconnected the beam equation from the bar equation in your element, and you are basically only solving the FE-problem with bar stiffness only, and computing the bending moment inside each element induvidually due to loads.
This moment will be completely seperate from the solution, and you can solve for it analytically without FEM. The only reason to ever use beams is when you have a frame, and in those cases you don't have any momentless joints.

One can always dream up a scenario where in the syntax of the input file is more cumbersome, but for some pratical examples, like
http://www.oofem.org/resources/doc/oofe … ode49.html
there is absolutely no problem in having slave nodes.

I'm unconvinced that there is any benefits of the condensation code.

Post's attachments

nonlinear.zip 1.66 kb, 3 downloads since 2015-10-14 

You don't have the permssions to download the attachments of this post.

13

Re: End releases on beam

I fully agree with this:
> The un-condensed value is computed for the "normal" solution vector, which doesn't post-process the un-condensed dofs.
After the condensation, the linear system gives you the solution that is exactly the same as with slave dofs, except the fact that the end-rotation for the condensed rotation is not computed. But it could be easily computed from the remaining known element end displacements and rotations, basically from the equilibrium relation stating that the corresponding end-moment should be zero. Basically, the equilibrium equation for free rotation can be solved locally on the element, as no other element contributes to it. 
In the old version of the (linear) beam implementations (where the end forces were computed from stiffness) this was done correctly, but in the new one, where the implementation was switched to numerical integration of internal forces this is not done correctly, as we missing the postprocessing of the local displacement vector.

The beauty of the condensation is in the  simplicity of the model creation. You simply have element with clamped rotations, and elements with free rotation on one or both ends. No need to duplicate nodes and connect dofs. Simple to understand for practical engineers.

Anyway, for the non-linear calculations, the simpler beam elements are typically used (linear interpolation), as the cubic interpolation is no longer an exact solution.

Re: End releases on beam

The beauty of the condensation is in the  simplicity of the model creation. You simply have element with clamped rotations, and elements with free rotation on one or both ends. No need to duplicate nodes and connect dofs. Simple to understand for practical engineers.

I perfectly agree to this, and reading also here: http://www.oofem.org/forum/viewtopic.php?id=1431
I convinced myself that it is true that the slave node is an extremely more powerful approach, but in the end it is only a matter of points-of-views or habits (ex. linear analyses only).

Just a couple of final questions related to that:

After the condensation, the linear system gives you the solution that is exactly the same as with slave dofs, except the fact that the end-rotation for the condensed rotation is not computed. But it could be easily computed from the remaining known element end displacements and rotations, basically from the equilibrium relation stating that the corresponding end-moment should be zero. Basically, the equilibrium equation for free rotation can be solved locally on the element, as no other element contributes to it.
In the old version of the (linear) beam implementations (where the end forces were computed from stiffness) this was done correctly, but in the new one, where the implementation was switched to numerical integration of internal forces this is not done correctly, as we missing the postprocessing of the local displacement vector.

How can this be done in the post-processing module?

are you too determined to solve this in OOFEM or, just because the dof condensation is not so effective, may I have to include some code in the beamExportModule I'm writing to post-process beam displacements?

15 (edited by johnnyontheweb 16-10-2015 18:16:28)

Re: End releases on beam

Sorry, a little correction for my last questions. In the same output file cited by Mikael:

Lets also take a look at the file (OneEndRels-Qk1.out)

...
beam element 1 :
  local displacements  0.0000e+000 0.0000e+000 0.0000e+000 0.0000e+000 0.0000e+000 0.0000e+000 0.0000e+000 0.0000e+000 0.0000e+000 0.0000e+000 0.0000e+000 0.0000e+000
...

That's wrong. The beam is free to deflect in dof 2 and 3, and will certainly do so on dof 3 with the load applied.
So my conclusion is that using condensation is just too risky for a beginner (and anyone else)!

I get also the nodal displacement all zeros. I've checked them with SAP2000 and they are ok.

16

Re: End releases on beam

Hi Giovanni,

the post-processing of condensed end- rotations (and end-displacements) can be most conveniently done in the solver as you need for this the original stiffness matrix (element without condensed DOFs). And this has to be done anyway, otherwise the wrong internal forces will be obtained. This is relatively simple.

The problem now is that the element load vector has to be condensed as well, and element needs to access its applied load. Element  can do it easily, if the load is set on element directly (aka boundaryload keyword) but if loads are applied indirectly using sets, this requires element to collect its load vector from indirectly applied loading, which is not available now. Simply saying, the concept of indirect loading using sets makes this procedure difficult.
I understand Mikael with his effort to implement sets, but on the other hand, this should not mean we have to sacrifice the good stuff.

Borek

Re: End releases on beam

(sorry for writing such long posts guys, I really do try to keep them as short as I can).

Giovanni,
No, SAP2000 gives the wrong answer as well (most likely it doesn't bother to un-condense the dofs, just like in OOFEM). The beam is definitely deforming; there is a load and you had dofs condensed (i.e. freed) in one end.
What OOFEM prints, is just the output from the nodes it's connected to. But the actual solution you have is disconnected from the nodal values. The beams "own" copy of the rotations/displacements will be non-zero when subjected to a load, which if it must, should be what is printed. The output from OOFEM is definitely wrong here.

I don't want to see this in a custom export module, because the output should be correct in whatever format you use to export with (perhaps someone is looking at concrete reinforcements, and is fine with the limited beam visualization in VTK).

Nonlinear model + dof condensation rambling
BP:
With nonlinear problems, I don't necessarily mean large bending. It could be plastic material model, or simple large rotations of beams. It's perfectly sensible to use beam2d and beam3d for this.

BP & Giovanni:
For any type of nonlinear problem, uncondensing dofs needs to be done *every iteration*.  Basically the element needs to keep a "condensed" internal dofmanager. We would even do it without condensing and just adding an element internal dof manager.
So to support nonlinearities we would need to store the displacements inside the beam, un-condensing them every iteration.
But.. now we have cached displacement values inside an element (not part of any dofmanager). What happens if we want to, say, restart the NRSolver? Or restart the timestep (we should really have this feature)? We'd have to start resetting the condensed dofs as well. The condensed data will also not be captured in the congergence criteria in NRSolver.
Cached values are easy to get right when everything converges nicely. But when issues arise, it's very easy to mess up and get the wrong values somehow.
We will have to start adding a lot of tricky code, all over the place. Not to mention that the poor Beam element will be 2 times as much code.
I think it's safe to say that for nonlinear problems, it's not nearly worth the headaches.

Many issues even for linear problems
Neither can we actually export the correct values to VTK-xml files (linear or nonlinear), (it will actually export incorrect results, and this can't be fixed). In order to get correct export to VTK, another node is necessary (e.g. the slave node), so even if we have the correct, uncondensed value waiting for us inside the beam element, it can't be part of the output to VTK.
The beam export tool that Giovanni wrote will also need to extract out this condensed values from the beam to export the correct displacements.

Even in the linear case, this isn't just something that the element can deal with internally, because computing the tangent isn't all there is to it.
I don't even imagine the complications that would arise would we ever want to have error estimation or adaptivity on beam elements.
I don't want to see an alternative method that can only be used in special conditions with careful analysis setup (which would otherwise produce silent errors). We will have users who try to use it and will spend days debugging why they get such strange results.

What's so great out the dof input description?
Even leaving these issues aside. I can't understand what is supposed to be so good about the input file description? You have to know the internal equation numbering inside the beams in order to use it. It's very limited (can't apply loads direclty on the condensed dof, can't share condensed dof with other elements).
Creating a bearing node is much closer to what the constructions look like in real life, and should be just a easy (if not easier) for an engineer to understand. The bearing/momentless joint isn't part of any particular beam, it's a connection, a node!! Clamping rotations isn't something that should be part of the elements. Just like how boundary conditions aren't a part of the elements.

And if one is creating lots of these bearings (e.g. 2 on every beam), then I have to wonder what kind of structure you are really trying to create. You are turning a frame into a truss, and your condensed beams are just bar elements.

One also need to be careful to leave at least 1 of the beams connected to the "original" nodal dof, else it will be completely unconnected DOFs, which leads to a singular K, which at least some of our solver don't like.
Most frame structures I can imagine would have a handful, if any, momentless joints. Most of the times, more than 1 beam will be connected to a single joint, leaving no other option than to use the slave node.


I don't really expect to convince anyone here, but I just want to point out that...
1. there are a lot more issues (current and future) related to the dof condensation (basically everything is effected). It might seem like a fairly innocent feature, but it's not. Some of these issues might be solveable, but many are fundamentally difficult.
2. the dof condensation input description isn't particularly great

I'd rather write a conversion script that generates input files using slave nodes than to extend/fix and functionality in the existing dof condensation.

18

Re: End releases on beam

I don;t have power now to comment all the stuff in the Mikael's post.

I just want to add that condensation is not only related to beams, it is frequently used in reduce-order modelling, and in some element formulations. We should not simply ignore this, as we may close some doors for the future. We want to be flexible, right?
The condensation is fully equivalent to slave dofs. The difference is that slaves introduce the free rotations  at the global level (by adding an additional global equation) while condensation does this locally at the element level. You don't need to cache any local displacements at the element level, the missing rotations can be always computed from the remaining DOFs. 

In any case, we need to keep the original element formulation in with dof condensation in official releases, as this is the way how deformation method is taught at our university and it part of our commitment to provide this.

Re: End releases on beam

As I mentioned for *nonlinear* problems, you really must store the values in the element, and "un-condense" each increment.


We also want to support things like indirect load control (arc length methods). We want to be flexible in this regard as well right?
Well that invalidates this type of dof-condensation. If users tried to do this, they would get the wrong results, and there is no way to fix this.
DOF-condensation as part of a linear system solver strategy is perfectly fine, and has no issues whatsoever. Condense -> solve -> un-condense, is perfectly fine. But not when it's just the condensation step, and done in secret inside some of the elements.
I'm not against substructuring/static condensation as a method for solving linear systems of equations, but it needs to be part of the solver. Not as a hack to support end-releases in beams, which causes dozens of serious problems.

The beam condensation is nothing like, say "bubble functions" added to stabilize mixed formulation elements (the MINI-element). That's a hierarchical addition whose influence can be mostly neglected (since it's just there for stabilization), so that it would be fine to just drop it when exporting the data.
In the beam we have the major DOF components that can not be neglected, and we lie in the input file about how the element is connected (since it's not actually connected to the dofs in the node).


The beam-dof-condensation input format can't even deal with simple, even common, structures like this
beams
Which I think it shouldn't be part of the beams to begin with. It should be a special node.. since that is what it truly is.

The beam dof condensation (1)can only do trivial trusses, (2)can't export data correctly, (3)can't apply nodal load on condensed dof, won't work correctly with (4)inelastic materials, (5)hanging nodes, (6)adaptivity, (7)error analysis, (8)convergence criteria, (9)arc-length methods, (10) adaptivity, (11)error estimates, (12)recovery models, (13)neumann b.c.s, (14)sets.

I stand by my opinion that this shouldn't be used by anyone.

Re: End releases on beam

Mikael,
thanks for the the posts. In your previous example, the one in the picture, there is a particular need that cannot be treated with dof condensation in the beam in almost any of the solver I know.

For me, the main need is to have the dof condensation wirking even only for linear analysis, to cover simple static scheme, and it would be good to have also the post-processing of condensed end- rotations and end-displacements as bp said. This can cover a large amount of needs, but not all of them, as you said in your post. For non linear analysis I agree with you.

21

Re: End releases on beam

I have added the experimental implementation of global based condensation of beam2d DOFs.
It uses what I call ghost DOF managers (potentially one for each real node), that are created by the beam element automatically and transparently to the user, when some DOFs to be condensed at particular node. For example, if we are going to condense rotation in element local node 2, then ghost dof manager will be created, corresponding to this local node with rotational degree of freedom only.

Then the whole trick is to introduce additional transformation from local element DOFS (these include nodal dofs + dofs of ghost nodes) into primary element dofs (containing only 6 dofs per element, where the condensed displacement and rotations replace the nodal ones).
The input syntax remains the same as before, the positive difference is that we have now end-beam rotations and displacements computed as well. It is probably less efficient than the local variant, but perhaps acceptable for everyone.

Let me know, if there are any comments to new beam2d code. I will do the same for beam3d soon.

PS: there is one test that fails (test_eigen_beam2d.in) looks like a tolerance problem, but I have to investigate further.

Re: End releases on beam

Borek, I tested the modifications you did in beam3d, and they seems fine. For the above example (post no. 11), I get now:

  local displacements  0.0000e+000 -2.8644e+000 0.0000e+000 0.0000e+000 0.0000e+000 0.0000e+000 0.0000e+000 0.0000e+000 0.0000e+000 0.0000e+000 0.0000e+000 0.0000e+000

so the ghost node is doing the job fine.
Thanks for your help

Re: End releases on beam

johnnyontheweb wrote:

Mikael,
In your previous example, the one in the picture, there is a particular need that cannot be treated with dof condensation in the beam in almost any of the solver I know.

Well, nothing else could be expected. It is an fundamental limitation of that method, it couldn't be supported in any software ever. Same with lots of other stuff, for example if you wanted to have a torsional spring to simulate a deformable, but not quite moment-less, joint. Can't be done with the dof-condensation hack.

And neither can the other 14 things i mentioned in that post. It's not a matter of just writing the code, they just aren't compatible. We can't add all the features. This is killing features, and adding essentially nothing.

Basically all frames/trusses I can think of has almost no moment-less joints anyway. This discussion makes it seem like there are ball-joints everywhere in constructions.. but.... there isn't. It's almost always something like welded frames with no joints of any kind (either dof-condensation or slave dofs).
It certainly isn't any more common than the type of construction I showed earlier; like a simple X cross of beams with a center joint would be impossible with the dof-condensation.

http://ibin.co/2M1HgGtcci0L

Re: End releases on beam

Hi again,
what if I want a partial release? I mean, instead of releasing completely the dof, if I want a certain percentage of stiffness?
There are many paractical cases in which the moment in a beam is release "partially", with a residual stiffness of, let's say, 5% of the full bounded beam.
The unique alternative is to add a spring with the proper stiffness?

Re: End releases on beam

You can of course do this with slave nodes combined with (torsional) springs, but it is not supported in the beams dof-condensation OOFEM. It would be theoretically possible to include a spring into an element and still do dof condensation internally, but it would be quite a mess and you are basically just now combining even more elements into one big meta-element.

Needless to say, I would also be strongly opposed to add even more of this mess into the poor beam element. We should have things modular, so that we can combine elements to create the structure we want. Having 2 nodes and a torsional spring to model... well... a torsional spring joint.. makes perfect sense, and should be the way to go here.