Nsryjdtyk

I have created a class capacity, which makes some calculation by iterating valuex through a for-loop. There is nothing wrong with the calculation process. I only need to break or stop equation, when this condition is matched.

self.Nrd= Ned

To obtain the above result, I create the following condition,

e=float(Nrd)-Ned

if e>= 0 and e<=1:

    break

But that does not yield a good and satisfactory result, and better saying not really working properbly.

I hope you could help me with this, to stop the equation when Nrd = Ned condition is reached.

And the second issue, I do not really get anything back by using __str__ method. How do the values return?

The code:

import numpy as np

from PyQt5 import QtCore, QtGui, QtWidgets



class capacity:

    def __init__(self,b,h,y,ecu,cb,ct,fyd,fcd,Esd,Ned):

        d = h - cb

        ds = ct

        Ast = int(3.1416/4*(y)**2*6.67)

        Asb = int(3.1416/4*(y)**2*6.67)



        for x in np.linspace(1,h,10000):



            esc=ecu/x*(ds-x)

            es=ecu/x*(d-x)



            sisc=Esd*esc

            sis=min(Esd*es,fyd)



            if sisc <= -fyd:

                sisc=-fyd

            elif sisc >= -fyd and sisc < 0:

                sisc= sisc

            else:

                sisc=min(sisc,fyd)



            self.Nrd=int((0.8*x*b*fcd+Ast*sisc-Asb*sis)/1000)

            self.Mrd=(0.8*x*b*fcd*(h/2-0.4*x)+Ast*sisc*(h/2-ds)+Asb*sis*(d-h/2))/1000000



            self.x = x

            e=float(Nrd)-Ned



            if e>= 0 and e<=1:

                break

            if x==h and Nrd != Ned:

                print('Errors','Compression over whole section', sep=' ') 

                app = QtWidgets.QApplication()

                error_dialog = QtWidgets.QErrorMessage()

                error_dialog.showMessage('Increase size of column, compressed reinforced column!!')

                app.exec_()



    def __str__(self):

        return print(self.x , self.Nrd, self.Mrd)



foo = capacity(b= 300,h=300,y=12,ecu= 0.0035,cb=35,ct=35,fyd=435,fcd=20,Esd=2e5,Ned=1000)

I appreciate any help, and you are welcome to improve the code. Thanks

Update of code:

According to recent argument on the code above, I manage to define a function which does the calculation, but the question I want to ask, how can I implement it as a class in python. Getting the same print as display by function.

def capacity(b,h,y,ecu,cb,ct,fyd,fcd,Esd,Ned):

    d = h - cb

    ds = ct

    Ast = int(3.1416/4*(y)**2*6.67)

    Asb = int(3.1416/4*(y)**2*6.67)



    for x in np.linspace(1,h,10000):



        try:

            esc=ecu/x*(ds-x)

            es=ecu/x*(d-x)

        except (ZeroDivisionError, RuntimeWarning):

            esc = 0

            es =  0



        sisc=Esd*esc

        sis=min(Esd*es,fyd)



        if sisc <= -fyd:

                    sisc=fyd

        elif sisc >= -fyd and sisc < 0:

            sisc= sisc

        else:

            sisc=min(sisc,fyd)





        Nrd=int((0.8*x*b*fcd+Ast*sisc-Asb*sis)/1000)

        Mrd=(0.8*x*b*fcd*(h/2-0.4*x)+Ast*sisc*(h/2-ds)+Asb*sis*(d-h/2))/1000000



        e=float(Nrd)-float(Ned)



        if e>= 0 and e<=0.5:

            return print('n','x value:', x,'n' ,'Normalforce: ', Nrd,'n','Moment capacity :', Mrd,'n','Bottom steel strain :',es,'n', 

                         'Top steel strain :', esc,'n', 'Bottom steel stress :', sisc,'n','Top steel stress :' ,sis )

            break

        if x==h and Nrd != Ned:

            print('Errors','Tryk over hele tværsnit', sep=' ') 

            app = QtWidgets.QApplication()

            error_dialog = QtWidgets.QErrorMessage()

            error_dialog.showMessage('Increase size of column, compressed reinforced column!!')

            app.exec_()



            return print(x, Nrd, Mrd)





foo = Capacity(b= 300,h=250,y=12,ecu= 0.0035,cb=50,ct=50,fyd=435,fcd=20,Esd=2e5,Ned=800)

Result:

There's a live version online of the Capacity class from this answer that you can try for yourself

Your code is on the right track. There's a bunch of little stuff that can be cleaned up (for example, you can check if your loop didn't break by using a for... else construct). You also need a proper implementation of __str__. Here's a complete working implementation of the Capacity class that does all of that stuff:

import numpy as np

from PyQt5 import QtCore, QtGui, QtWidgets



class Capacity:

    labels = (

        ('x', 'x value'),

        ('Nrd', 'Normal force'),

        ('Mrd', 'Moment capacity'),

        ('es', 'Bottom steel strain'),

        ('esc', 'Top steel strain'),

        ('sisc', 'Bottom steel stress'),

        ('sis', 'Top steel stress')

    )



    def __init__(self, *args, **kwargs):

        # most recent values of interest

        self.x = None

        self.Nrd = None

        self.Mrd = None

        self.es = None

        self.esc = None

        self.sisc = None

        self.sis = None



        # if any args are passed to init, try to use them to run .check

        if args or kwargs:

            self.check(*args, **kwargs)



    def check(self, b, h, y, ecu, cb, ct, fyd, fcd, Esd, Ned):

        d = h - cb

        ds = ct

        Ast = int(3.1416/4*(y)**2*6.67)

        Asb = int(3.1416/4*(y)**2*6.67)

        Nrd = None



        for x in np.linspace(1,h,10000):

            try:

                esc = ecu/x*(ds-x)

                es = ecu/x*(d-x)

            except (ZeroDivisionError, RuntimeWarning):

                esc = 0

                es = 0



            sisc = Esd*esc

            sis = min(Esd*es,fyd)



            if sisc <= -fyd:

                sisc=fyd

            elif sisc >= -fyd and sisc < 0:

                sisc = sisc

            else:

                sisc = min(sisc,fyd)



            Nrd = int((0.8*x*b*fcd+Ast*sisc-Asb*sis)/1000)

            Mrd = (0.8*x*b*fcd*(h/2-0.4*x)+Ast*sisc*(h/2-ds)+Asb*sis*(d-h/2))/1000000



            # record values of interest for later printing

            self.x = x

            self.Nrd = Nrd

            self.Mrd = Mrd

            self.es = es

            self.esc = esc

            self.sisc = sisc

            self.sis = sis



            if 0 <= (float(Nrd) - Ned) <= 0.5:

                # the return statement breaks the loop

                return True

        else:

            # the else clause executes if the end of the for loop is reached without a break

            if Nrd != Ned:

                print('Errors','Tryk over hele tværsnit', sep=' ')

                print(self)

                app = QtWidgets.QApplication()

                error_dialog = QtWidgets.QErrorMessage()

                error_dialog.showMessage('Increase size of column, compressed reinforced column!!')

                app.exec_()



            return False



    def __str__(self):

        strs = 

        for attr,label in self.labels:

            # loop through the labels and get the value of the corresponding attribute from self

            val = getattr(self, attr)

            strs.append('{}: {}'.format(label, val))



        # join all the labeled attribute strings with newline characters and return the result

        return 'n'.join(strs)

You can then use the Capacity class like this:

capacity = Capacity(b=300, h=300, y=12, ecu=0.0035, cb=35, ct=35, fyd=435, fcd=20, Esd=2e5, Ned=1000)

print(capacity)

which will output:

x value: 186.3985398539854

Normal force: 1000

Moment capacity: 130.8115324251227

Bottom steel strain: 0.0014758973472997895

Top steel strain: -0.0028428060107339903

Bottom steel stress: 435

Top steel stress: 295.1794694599579

You might be looking for something like bellow, Create your class attrs empty and call a class method that populates them as part of __init__ you can then use the overloading of __str__ to get your desired output. f-strings might be cleaner also. (I didn't have time to collect your code and test it so you might need to do some massaging)

import numpy as np

from PyQt5 import QtCore, QtGui, QtWidgets



class Capacity():

    def __init__(self,b,h,y,ecu,cb,ct,fyd,fcd,Esd,Ned):

        self.filename = b



        self.x_value = None

        self.nrm_frc = None

        self.mom_cap = None

        self.bsstress = None

        self.tsstress = None

        self.bsstrain = None

        self.tsstrain = None

        self.parse_file(b,h,y,ecu,cb,ct,fyd,fcd,Esd,Ned)



    def parse_file(self,b,h,y,ecu,cb,ct,fyd,fcd,Esd,Ned):

        #all the code for calculation where:

        self.x_value = 'value'

        self.nrm_frc = 'value'

        self.mom_cap = 'value'

        self.bsstress = 'value'

        self.tsstress = 'value'

        self.bsstrain = 'value'

        self.tsstrain = 'value'



    def __str__(self):

        return ('nx value: {0} nNormalforce: {1} nMoment capacity : {2} nBottom steel strain : {3} '

                'nTop steel strain : {4} nBottom steel stress :{5} nTop steel stress : {6}'

                .format(self.x_value, self.nrm_frc, self.mom_cap, self.bsstress, self.tsstress, self.bsstrain, self.tsstrain))





foo = Capacity(b= 300,h=250,y=12,ecu= 0.0035,cb=50,ct=50,fyd=435,fcd=20,Esd=2e5,Ned=800)

print foo