Ferney Morales's Activities

Python: Looping through structural elements painfully slow

Ferney Morales — Wed, 25 Jan 2023 09:02:20 GMT

Hi,

I have a simulation with 635 piles (embedded beams), which has 26 calculated Phases, I want to create a 4D array to save all the results for later postprocessing

The structure of the array is as follows:

1D: Number of evaluated points along each piles

2D: Each pile

3D: Phase ID

4D: each result variable i.e. (X,Y,Z,N,Q12,Q13,M1,M2,M3,ux,uy,uz)

I created a script with a double loop (one loops through each Phase, and the internal loop goes through all the piles). It starts running quite fast, but after a while it becomes way too slow. I mean, several hours (more than 20) and still only halfway. Is there a way to make it run faster?

I think it has something to do with memory management, because I stopped in after some phases and restart the output program and it started again faster, but once again after a while it becomes really slow. I think each time I call the "getresults" command it stores the beam in memory but never release it... I must point out that the overall memory of the PC never gets full occupied (output only uses 3GB/32GB) and the processor use is lower than 30% (none of the 8 cores gets clogged with the process)

It seems to me that it's faster to select all beams and create the output table with the values and copy them in excel, but it would also take a lot of time to do it for all phases and it can't be unattended, which is the point of these automatization tasks. I hope someone can give me some guide

import numpy as np
Results_Pile=np.empty([200,635,29,12]) # [num_segments-per-pile,num_piles,num_phases,num_variables]
for phase_id in range(1,27): 
    Piles = g_o.EmbeddedBeams
    pile_id = 0
    for Pile in Piles:
        A=[float(x) for x in(g_o.getresults(Piles[pile_id],g_o.Phases[phase_id], g_o.ResultTypes.EmbeddedBeam.X,"node")).echo()[1:-1].split(",")]
        Results_Pile[0:len(A),pile_id,phase_id-6,0] = [float(x) for x in(g_o.getresults(Piles[pile_id],g_o.Phases[phase_id], g_o.ResultTypes.EmbeddedBeam.X,"node")).echo()[1:-1].split(",")]
        Results_Pile[0:len(A),pile_id,phase_id-6,1] = [float(x) for x in(g_o.getresults(Piles[pile_id],g_o.Phases[phase_id], g_o.ResultTypes.EmbeddedBeam.Y,"node")).echo()[1:-1].split(",")]
        Results_Pile[0:len(A),pile_id,phase_id-6,2] = [float(x) for x in(g_o.getresults(Piles[pile_id],g_o.Phases[phase_id], g_o.ResultTypes.EmbeddedBeam.Z,"node")).echo()[1:-1].split(",")]
        Results_Pile[0:len(A),pile_id,phase_id-6,3] = [float(x) for x in(g_o.getresults(Piles[pile_id],g_o.Phases[phase_id], g_o.ResultTypes.EmbeddedBeam.N,"node")).echo()[1:-1].split(",")]
        Results_Pile[0:len(A),pile_id,phase_id-6,4] = [float(x) for x in(g_o.getresults(Piles[pile_id],g_o.Phases[phase_id], g_o.ResultTypes.EmbeddedBeam.Q12,"node")).echo()[1:-1].split(",")]
        Results_Pile[0:len(A),pile_id,phase_id-6,5] = [float(x) for x in(g_o.getresults(Piles[pile_id],g_o.Phases[phase_id], g_o.ResultTypes.EmbeddedBeam.Q13,"node")).echo()[1:-1].split(",")]
        Results_Pile[0:len(A),pile_id,phase_id-6,6] = [float(x) for x in(g_o.getresults(Piles[pile_id],g_o.Phases[phase_id], g_o.ResultTypes.EmbeddedBeam.M1,"node")).echo()[1:-1].split(",")]
        Results_Pile[0:len(A),pile_id,phase_id-6,7] = [float(x) for x in(g_o.getresults(Piles[pile_id],g_o.Phases[phase_id], g_o.ResultTypes.EmbeddedBeam.M2,"node")).echo()[1:-1].split(",")]
        Results_Pile[0:len(A),pile_id,phase_id-6,8] = [float(x) for x in(g_o.getresults(Piles[pile_id],g_o.Phases[phase_id], g_o.ResultTypes.EmbeddedBeam.M3,"node")).echo()[1:-1].split(",")]
        Results_Pile[0:len(A),pile_id,phase_id-6,9] = [float(x) for x in(g_o.getresults(Piles[pile_id],g_o.Phases[phase_id], g_o.ResultTypes.EmbeddedBeam.Ux,"node")).echo()[1:-1].split(",")]
        Results_Pile[0:len(A),pile_id,phase_id-6,10] = [float(x) for x in(g_o.getresults(Piles[pile_id],g_o.Phases[phase_id], g_o.ResultTypes.EmbeddedBeam.Uy,"node")).echo()[1:-1].split(",")]
        Results_Pile[0:len(A),pile_id,phase_id-6,11] = [float(x) for x in(g_o.getresults(Piles[pile_id],g_o.Phases[phase_id], g_o.ResultTypes.EmbeddedBeam.Uz,"node")).echo()[1:-1].split(",")]
        
        pile_id += 1

Design Approach Implementation - EC7 A3

Mohamad Raad — Fri, 17 Feb 2023 13:39:40 GMT

Hello, I would appreciate you answering the following inquiry: When running a slope stability model on PLAXIS 2D while implementing manually partial safety factors, in my case the ones stated for Approach 3 of EC7, I'm having trouble deciding the basis on which each Construction Phase is considered passing or not. For instance, according to A3 in EC7, when using the right reduction factors for soil and structures' strengths, the Phase is considered verified in case the Safety Factor is above 1.00.

For comparison, other slope stability software that are based on LEM, the SF is calculated based on Bishop's method.

Therefore in the case of PLAXIS's FEM, what is the factor that can be representative of the SF which should be compared to 1.00? Is it the Mstage of each construction phase (where in that case, a phase is considered verified if it finishes the calculation properly)? Or are we obliged to add a Safety type phase for each Phase to extract the Msafety of each one based on c-phi reduction?

Your help is much appreciated.

Let me Help You

Mon, 13 Mar 2023 03:10:37 GMT

Answer a question that is verified as helpful or correct.

Ask A Question I

Wed, 25 Jan 2023 07:37:26 GMT

Ask a question in a forum.

how do multiple phases with partial SumMstage solve the general unbalance?

Ferney Morales — Fri, 02 Sep 2022 06:02:33 GMT

Hi all,

I'm working on a prototype model for a R&D project, and my idea is to create multiple phases, for which each one just a small amount of the total unbalance is solved each time, that way I can look at the intermediate results and take action upon.

here https://blog.virtuosity.com/how-to-speed-up-calculation-time-with-plaxis is said: " SumMstage: This translates the proportion of the initially applied load (at the beginning of the phase), referred to as the external forces which have been balanced by the development of soil stresses that are considered being the internal forces."

If I understand correctly, this means that if you have an unbalance at the beginning of a stage SumMStage will solve that proportion of that unbalance. If so, that means that if I assign a MSumStage=0.1 for Phase_1, at the end of its calculation 90% of the initial unbalance remains. Now, if in Phase_2 I have again SumMStage=0.1, would it mean that it will now solve 10% of the 90% left from Phase_1? and if we repeat the same over several phases would we get something like?:

	Total unbalance at beggining of phase [%]	SumMStage	Percentage of total unbalance solved on current phase
Phase_1	100	0.1	10
Phase_2	90.0	0.1	9.0
Phase_3	81.0	0.1	8.1
Phase_4	72.9	0.1	7.3
Phase_5	65.6	0.1	6.6
Phase_6	59.0	0.1	5.9
Phase_7	53.1	0.1	5.3
Phase_8	47.8	0.1	4.8
Phase_9	43.0	0.1	4.3
Phase_10	38.7	0.1	3.9

thx in advance,

Ferney