class Blaster():    
    import json
    
                                #Οι τιμές self είναι αυτές που θα πάρει απο το αρχείο .json
    def __init__(self):
        self.name = " "         # Όνομα εκρηκτικού
        self.Density = 0         # Πυκνότητα εκρηκτικής ύλης
        self.Q = 0              # Ενέργεια εκρητικού
        self.V = 0               # Όγκος αερίων κατα την ανατίναξη του εκρηκτικού
        self.hdiam=0            # Διάμετρος διατρήματος
        self.emptyf =0           # Διάμετρος κενού διατρήματος
        self.width =0           # Πλάτος μετώπου
        self.abutmentH =0        # Ύψος μετώπου
        self.archHeight =0      # Ύψος κυκλικού τμήματος οροφής
        self.a =0                # Γωνιακή απόκλιση
        self.b =0               # Απόκλιση κολάρου
        self.c =0                # Σταθερά πετρώματος
        self.g=0                # Γωνιακή απόκλιση για περιμετρικά διατρήματα
        self.Sanfo=0             # Γραμμική πυκνότητα εκρηκτικού ως προς ANFO
        self.hdepth=0           # Βάθος διατρήματος
        self.advance=0           # Προχώρηση μετώπου
        self.massph=[]          # Λίστα μάζας γόμωσης εκρηκτικού ανά διάτρημα 
        self.total=[]            # Συνολική μάζας εκρηκτικών
        self.charge=[]          # Λίστα γραμμικής πυκνότητας γόμωσης φυσιγγίων
        self.cartridges = []     # Λίστα φυσιγγίων εκρηκτικής ύλης 
        self.B=[]               # Λίστα πλευρών τετραγώνων της προεκσκαφής
        self.practicalb=[]       # Λίστα πρακτικών φορτίων
        self.diam=[]            # Λίστα διαμέτρων φυσιγγίων που χρησιμοποιείται σαν τίτλος διατρημάτων στον τελικό πίνακα
        self.holes=[]            # Λίστα αριθμού διατρημάτων για κάθε τμήμα
        self.number_first=[]
        self.number_second=[]           # Λίστες φυσιγγίων στα διατρήματα του κάθε τμήματος. Χρησιμοποιείται για τον τελικό συγκεντρωτικό πίνακα.
        self.number_third=[]            # π.χ. [4,4.5,0] ποσότητα κάθε φυσιγγίου στα διατρήματα
        self.number_fourth=[]
        self.number_lifters=[]
        self.number_roof=[]
        self.number_wall=[]
        self.number_stoping=[] 
        self.spacing=[]                # Λίστα με τις αποστάσεις των εκρηκτικών δαπέδου και τοίχου 
        self.No_columns=[]            # Ο αριθμός των στηλών διατρημάτων που πρέπει να δημιουργηθούν στα stoping holes
        self.No_rows=[]                # Ο αριθμός των σειρών διατρημάτων που πρέπει να δημιουργηθούν στα stoping holes
        self.spacing_columns=[]       # Η απόσταση μεταξύ των στηλών οριζοντίων διατρημάτων 
        self.spacing_rows=[]           # Η απόσταση μεταξύ των οριζοντίων διατρημάτων σε κάθε σειρά 
        self.corner_holes=[]          # Η απόσταση των γωνιακών διατρημάτων από τα επόμενα, στα Lifters
        self.Spacing=[]                # Απόσταση στηλών καθέτων διατρημάτων
        self.cols_downwards=[]        # Αριθμός στηλών καθέτων διατρημάτων
        self.number_stoping1=[]
        self.number_roof1=[]
        self.number_lifters1=[]
        self.test_no=[]
        self.test_total=[]            # Λίστες για τετραγωνική στοά 3.5 m x 4 m !!! ΟΧΙ ΥΠΟΧΡΕΩΤΙΚΟ
        self.test_mass=[]
        
        
    def addcartridge(self, name, diameter, length):
        self.cartridges.append({"name":name, "diameter":diameter,"length":length })

        # Για κάθε φυσίγγιο εκρηκτικού που δηλώνω στο αρχείο .json, καταχωρούνται οι τιμές του (όνομα, διάμετρος, μήκος) στη λίστα self.cartridges.

    def charge_concentration(self):
        for x in self.cartridges:
            d=x["diameter"]
            l=round(((math.pi*(d**2))/4)*self.Density,2)
            self.charge.append(l)

        # Υπολογισμός γραμμικής πυκνότητας γόμωσης I για κάθε φυσίγγιο που έχει καταχωρηθεί και τοποθέτηση τους στη λίστα self.charge . [((π*d^2)*ρ)/4].
          
    def calculation(self):
        Semex=round(((5*self.Q)/(6*5))+((1*self.V)/(6*0.85)),2)
        self.Sanfo=round(Semex/0.84,2)
        self.hdepth=round(0.15+(34.1*self.emptyf)-(39.4*(self.emptyf**2)),2)
        self.advance=round(0.95*self.hdepth,2)
        for i in range(len(self.cartridges)):
            a=self.cartridges[i]['diameter']*1000,"mm"
            x=0
            self.diam.append(a)
            self.number_first.append(x)
            self.number_second.append(x)
            self.number_third.append(x)
            self.number_fourth.append(x)
            self.number_lifters.append(x)
            self.number_roof.append(x)
            self.number_wall.append(x)
            self.number_stoping.append(x)
            self.number_stoping1.append(x)
            self.number_roof1.append(x)
            self.number_lifters1.append(x)
        # Υπολογισμός σχετικής ισχύος εκρηκτικής ύλης ως προς LBF και μετά (/0.84) ως προς ANFO.
        # Ο υπολογισμός αυτός γίνεται με βάση το Q και το V του εκρηκτικού που χρησιμοποιώ.
            
        # Οι παρακάτω λίστες θα χρησιμοποιηθούν για την καταγραφή των φυσιγγίων που θα χρησιμοποιηθούν στα διατρήμματα.
        # Για παράδειγμα , αν στα stoping holes έχω 4 φυσίγια "α", 0 φυσίγγια "β" και 3 φυσίγγια "γ", η λίστα θα γράφει [4,0,3].
        # Δηλώνω αρχική τιμή της λίστας το 0 (x), για να ξεκινάνε με [0,0,0] και να μεταβάλλονται παρακάτω ανάλογα με τα διατρήματα.
            
    def first_quadrangle(self):
        V1max=round(1.7*self.emptyf,2)                                                           # Μέγιστο φορτίο
        #if (((self.a*self.hdepth)+self.b)*10)<1:                                        # Έλεχγος για το άν η απόκλιση είναι κάτω απο 1% για τον υπολογισμό του πρακτικού φορτίου . 
           #V1=round(1.5*self.emptyf,2)
        #else:
        V1=round((V1max-((self.a*self.hdepth)+self.b)),2) #a,b (m)
        charge=round((((55*self.hdiam)*((round(V1max,2)/self.emptyf)**1.5)*(round(V1max,2)-(self.emptyf/2))*(self.c/0.4))/self.Sanfo),2) # γραμμική πυκνότητα γόμωσης ανάλογα του φορτίου
        minimum=1000
        th=0
        for i in range(len(self.charge)):
            if abs(self.charge[i]-charge)<minimum and (self.charge[i]<=charge):         # Επιλογή του φυσιγγίου του οποίου η γραμμ. πυκνότητα γόμωσης είναι η πλησιέστερη (προς τα κάτω) με αυτή που υπολογίστηκε
                minimum=abs(self.charge[i]-charge)                                      
                th=i
        h=10*self.hdiam                                                                 # Επιγόμωση (10d)
        B1=round(math.sqrt(2)*V1,2)                                                     # Πλευρά τετραγώνου 
        No_first=round((self.hdepth-h)/self.cartridges[th]["length"]*2)/2               #Αριθμός φυσιγγίων
        mass1=round(((self.charge[th])*(self.cartridges[th]["length"])*(No_first)),2)   #Μάζα γόμωσης ανά διάτρημα
        self.massph.append(mass1)                                                       #Λίστα μάζας γόμωσης/διάτρημα                                                                 
        self.B.append(B1)                                                               # Λίστα Πλευράς τετραγώνου
        self.practicalb.append(V1)                                                      # Εισαγωγή πρακτικού φορτίου στην λίστα 
        Holes_first=4                                                                   # Αριθμός διατρημάτων
        self.holes.append(Holes_first)
        self.test_no.append(Holes_first)
        self.test_mass.append(mass1)
        # Λίστα αριθμών διατρημάτων
        for i in range(len(self.number_first)): 
            self.number_first[th]=No_first                                              # Για κάθε τύπο φυσιγγίου , τοποθετείται στη λίστα ο αριθμός που θα χρησιμοποιηθεί πχ.[4,0,4]
        
        # Υπολογισμός αρχικά του πρακτικού φορτίου ανάλογα με την απόκλιση της διάτρησης και ανάλογα της διαμέτρου του κενού αρχικού διατρήματος

        # Έπειτα υπολογίζω την γραμμική πυκνότητα γόμωσης του μέγιστου φορτίου και επιλέγει το φυσίγγιο με την πλησιέστερη πυκνότητα γόμωσης

        # Υπολογίζω επιγόμωση, πλευρά τετραγώνου, αριθμό φυσιγγίων και διατρημάτων, μάζα ανά διάτρημα και τα βάζω στις αντίστοιχες λίστες για να τα χρησιμοποιήσω αργότερα
        
   
    def second_quadrangle(self):
        B2temp=round((math.sqrt(2))*(self.practicalb[0]-((self.a*self.hdepth)+self.b)),2)   # Θεωρητική πλευρά τετραγώνου
        practicalb=[] 
        minimum=1000
        th=0
        for i in range(len(self.charge)):
                V2max=round((8.8*0.01)*math.sqrt((B2temp*self.charge[i]*self.Sanfo)/(self.hdiam*self.c)),2)
                Vpractical=round(V2max-((self.a*self.hdepth)+self.b),2)                     # Με βάση την θεωρητική πλευρά τετραγώνου υπολογίζω το μέγιστο φορτίο και το πρακτικό φορτίο για κάθε τύπο φυσιγγίου
                practicalb.append(Vpractical)                                               # Άν το πρακτικό φορτίο είναι <=2Β και >0.5Β ,επιλέγει το αντίστοιχο φυσίγγιο 
                if Vpractical<(2*B2temp) and  abs(Vpractical-2*B2temp)<minimum and Vpractical>0.5*B2temp:
                       minimum=abs(Vpractical-2*B2temp)
                       th=i
        V2=practicalb[th]                                                                   # Καταχώρηση του πρακτικού φορτίου ανάλογα στη θέση (th) του φυσιγγίου που επιλέχθηκε
        self.practicalb.append(V2)                                                          # Λίστα πρακτικών φορτίων
        h=10*self.hdiam                                                                     # Επιγόμωση
        B2=round(math.sqrt(2)*(round(V2,2)+(self.B[0]/2)),2)                                # Πλευρά τετραγώνου
        self.B.append(B2)                                                                   # Λίστα πλευράς τετραγώνου
        No_second=round((self.hdepth-h)/(self.cartridges[th]["length"])*2)/2                # Αριθμός φυσιγγίων
        mass2=round(((self.charge[th])*(self.cartridges[th]["length"])*(No_second)),2)      # Μάζα γόμωσης ανά διάτρημα
        self.massph.append(mass2)                                                           # Λίστα μάζας γόμωσης/διάτρημα
        Holes_second=4                                                                      # Αριθμός διατρημάτων
        self.holes.append(Holes_second)                                                     # Λίστα αριθμού διατρημάτων (4 επειδή ειναι τετράγωνα)
        self.test_no.append(Holes_second)
        self.test_mass.append(mass2)
        for i in range(len(self.number_second)):   
            self.number_second[th]=No_second                                                # Για κάθε τύπο φυσιγγίου , τοποθετείται στη λίστα ο αριθμός που θα χρησιμοποιηθεί πχ.[4,0,4]
        
        # Η διαδικασία είναι η ίδια με του πρώτου τετραγώνου .

        # Η μόνη διαφορά είναι ότι η την επιλογή του αντίστοιχου φυσιγγίου που θα χρησιμοποιήσω θα γίνει με βάση τη θεωρητική πλευρά τετραγώνου
        
    def third_quadrangle(self):
        B3temp=round(math.sqrt(2)*(round(self.practicalb[1],2)+(round(self.B[0]/2,2))-(self.a*self.hdepth+self.b)),2)
        practicalb=[]
        minimum=1000
        th=0
        for i in range(len(self.charge)):
                V3max=round((8.8*0.01)*math.sqrt((B3temp*self.charge[i]*self.Sanfo)/(self.hdiam*self.c)),2)
                Vpractical=round(V3max-((self.a*self.hdepth)+self.b),2)
                practicalb.append(Vpractical)
                if Vpractical<=(2*B3temp) and  abs(Vpractical-2*B3temp)<minimum and Vpractical>0.5*B3temp:
                       minimum=abs(Vpractical-2*B3temp)
                       th=i
        V3=practicalb[th]
        self.practicalb.append(V3)
        h=10*self.hdiam
        B3=round(math.sqrt(2)*(V3+(self.B[1]/2)),2)
        self.B.append(B3)
        No_third=round((self.hdepth-h)/(self.cartridges[th]["length"])*2)/2
        mass3=round(((self.charge[th])*(self.cartridges[th]["length"])*(No_third)),2)
        self.massph.append(mass3)
        Holes_third=4
        self.holes.append(Holes_third)
        self.test_no.append(Holes_third)
        self.test_mass.append(mass3)
        for i in range(len(self.number_third)):
            self.number_third[th]=No_third
        
     # Ομοίως με τα παραπάνω τετράγωνα  
        
        
    def fourth_quadrangle(self):
        B4temp=round(math.sqrt(2)*(round(self.practicalb[2],2)+(round(self.B[1],2)/2)-(self.a*self.hdepth+self.b)),2)
        practicalb=[]
        minimum=1000
        th=0
        for i in range(len(self.charge)):
                V4max=round((8.8*0.01)*math.sqrt((round(B4temp,2)*self.charge[i]*self.Sanfo)/(self.hdiam*self.c)),2)
                Vpractical=round(V4max-((self.a*self.hdepth)+self.b),2)
                practicalb.append(Vpractical)
                if Vpractical<=(2*B4temp) and  abs(Vpractical-2*B4temp)<minimum and Vpractical>0.5*B4temp:
                       minimum=abs(Vpractical-2*B4temp)
                       th=i
        V4=practicalb[th]
        B4=round(math.sqrt(2)*(V4+(self.B[2]/2)),2)
        self.practicalb.append(V4)      
        if self.abutmentH>=4.5 or self.abutmentH+self.archHeight>=4.5:
            h=10*self.hdiam
            self.B.append(B4)
            No_fourth=round((self.hdepth-h)/(self.cartridges[th]["length"])*2)/2
            mass4=round(((self.charge[th])*(self.cartridges[th]["length"])*(No_fourth)),2)
            self.massph.append(mass4)
            Holes_fourth=4
            self.holes.append(Holes_fourth)
            self.test_no.append(Holes_fourth)
            self.test_mass.append(mass4)
            for i in range(len(self.number_fourth)):
                self.number_fourth[th]=No_fourth
        else:
            self.practicalb.pop(3)
            self.B.append(self.B[2])
            self.practicalb.append(self.practicalb[2])
            h=10*self.hdiam
            B4==self.B[2]
            No_fourth=0
            mass4=0
            self.massph.append(mass4)
            Holes_fourth=0
            self.holes.append(Holes_fourth)
            self.test_no.append(Holes_fourth)
            self.test_mass.append(mass4)
            for i in range(len(self.number_fourth)):
                self.number_fourth[th]=No_fourth
        # Ομοίως με τα παραπάνω τετράγωνα
        
    
    def lifters(self):
        x=round(0.6*self.hdepth,2)                                                                  # Το πρακτικό φορτίο των Lifters πρέπει να είναι μικρότερο ή ίσο με 0.6 φορές το Βάθος του διατρήματος
        minimum=1000     
        th=0
        for i in range(len(self.charge)):
            v1max=round(0.9*math.sqrt((self.charge[i]*self.Sanfo)/(1.25*(self.c+0.05)*1.25)),2)
            if (v1max<=x) and (x-v1max)<minimum:
                vl=round(0.9*math.sqrt((self.charge[i]*self.Sanfo)/(1.25*(self.c+0.05)*1.25)),2)    # Παράλληλα , χρησιμοποιούμε το φυσίγγιο με τη μέγιστη δυνατή γραμμική πυοκνότητας γόμωσης 
                minimum=(x-v1max)
                th=i
        vl=round(0.9*math.sqrt((self.charge[th]*self.Sanfo)/(1.45*(self.c+0.05))),2)
        if vl>=1.4:
            VLmax=vl                                                                                # Αν το πρακτικό φορτίο είναι μεγαλύτερο από 1.4 , η διορθωμένη σταθερά c αλλάζει
        else:
            VLmax=round(0.9*math.sqrt((self.charge[th]*self.Sanfo)/(1.45*(self.c+(0.07/vl)))),2)
        N=int(((self.width+2*self.hdepth*math.sin(self.g))/VLmax)+1)                                # Αριθμός διατρημάτων δαπέδου
        El=round(((self.width+2*self.hdepth*math.sin(self.g))/(N-1)),2)                             # Απόσταση διατρημάτων δαπέδου
        corner_El=round(El-(self.hdepth*math.sin(self.g)),2)                                        # Απόσταση γωνιακών διατρημάτων δαπέδου
        VL=round(VLmax-(self.hdepth*math.sin(self.g))-(self.a*self.hdepth+self.b),2)                # Πρακτικό φορτίο (Μέγιστο - F)
        self.practicalb.append(VL)  
        hb=round(1.25*VL,2)                                                                         # Μήκος επιγόμωσης πυθμένα
        hc=self.hdepth-hb-(10*self.hdiam)                                                           # Μήκος επιγόμωσης στήλης
        charge_column=round(0.7*self.charge[th],2)                                                  # Γραμμική πυκνότητα γόμωσης στήλης                                
        minimum=1000
        th1=0
        for i in range(len(self.charge)):
            if abs(self.charge[i]-charge_column)<minimum and (self.charge[i]-0.05<=charge_column):  # Επιλογή φυσιγγίου για την γόμωση στήλης ανάλογα με την γραμμική πυκνότητα γόμωσης στήλης
                minimum=abs(self.charge[i]-charge_column)
                th1=i
        No_cartridges_bottom= round((hb/self.cartridges[th]["length"])*2)/2                         # Αριθμός φυσιγγίων πυθμένα    
        No_cartridges_column= round((hc/self.cartridges[th1]["length"])*2)/2                        # Αριθμός φυσιγγίων στήλης
        massL=round((((self.charge[th])*(self.cartridges[th]["length"])*(No_cartridges_bottom))+((self.charge[th1])*(self.cartridges[th1]["length"])*(No_cartridges_column))),2)
        self.massph.append(massL)                                                                   # Λίστα μάζας γόμωσης/διάτρημα 
        Holes_lifters=N                                                                             # Αριθμός διατρημάτων δαπέδου
        self.holes.append(Holes_lifters)                                                            # Λίστα αριθμού διατρημάτων
        for i in range(len(self.number_lifters)):
             if th==th1:                                                                            # Αν τα φυσίγγια στήλης είναι τα ίδια με τα φυσίγγια πυθμένα (th1,th) πρέπει να προστεθούν οι αριθμοί και όχι να καταχωρυθεί μόνο το ένα
                self.number_lifters[th]=No_cartridges_bottom+No_cartridges_column
                self.number_lifters[th1]=No_cartridges_bottom+No_cartridges_column
             else:
                self.number_lifters[th]=No_cartridges_bottom                                        # Για κάθε τύπο φυσιγγίου , τοποθετείται στη λίστα ο αριθμός που θα χρησιμοποιηθεί πχ.[4,0,4]
                self.number_lifters[th1]=No_cartridges_column
        self.spacing.append(El)                                                                     #Λίστα απόστασης διατρημάτων
        self.corner_holes.append(corner_El)                                                         #Λίστα απόστασης γωνιακών διατρημάτων

        # Αφού υπολογίζεται το πρακτικό φορτίο , τον αριθμό των διατρημάτων και τις αποστάσεις, σειρά έχει το μήκος επιγόμωσης πυθμένα και στήλης.
        # Αυτό γίνεται γιατί χρησιμοποιούνται διαφορετικά φυσίγγια στο καθένα , ανάλογα με τη γραμμική πυκνότητα γομώσής τους.
        
        
    def roof(self):
        #k=secure_random.uniform(15,16)
        k=15                                                                                        #Smooth blasting
        E=round(k*self.hdiam,2)                                                                     # Spacing                                                     
        VRmax=round((E/0.8),2)                                                                      # Μέγιστο φορτίο
        VR=round(VRmax-(self.hdepth*math.sin(self.g))-(self.a*self.advance+self.b),2)               # Πρακτικό φορτίο
        self.practicalb.append(VR)
        R=round(((self.archHeight**2+((self.width/2)**2))/self.archHeight)/2,2)
        angle_rad=round(math.acos((R-self.archHeight)/R)*2,2)
        angle_deg=round((angle_rad*180)/math.pi,2)
        Lr=round(angle_deg*(math.pi/180)*R,2)
        No_holes_roof=int(((Lr+(self.abutmentH*math.sin(self.g)))/E)+1)
        spacing_roof=round(Lr/(No_holes_roof-1),2)
        min_charge=round(90*(self.hdiam**2),2)                                                      # Ελάχιστη γραμμική πυκνόητητα γόμωσης για smooth blasting
        minimum=1000
        th=0
        for i in range(len(self.charge)):
            if abs(self.charge[i]-min_charge)<minimum and (self.charge[i]>min_charge):              # Επιλογή φυσιγγίου ανάλογα με την ελάχιστη γραμμική πυκνότητα γόμωσης
                minimum=abs(self.charge[i]-min_charge)
                th=i
        No_cartridges_roof=int(self.hdepth/self.cartridges[th]["length"])                           # Αριθμός φυσιγγίων. Δεν έχει επιγόμωση 
        massR=round(((self.charge[th])*(self.cartridges[th]["length"])*(No_cartridges_roof)),2)     # Μάζα γόμωσης ανά διάτρημα
        self.massph.append(massR)  
        No_holes_roof=int(((self.abutmentH+(self.abutmentH*math.sin(self.g))+self.archHeight)/E)+2) #Συν 2 ,γιατί αλλιώς βγαίνει 7,91 .επομένως επιλέγει το 7 αντί του 8!!!!
        Holes_roof=No_holes_roof                                                                    # Αριθμός διατρημάτων οροφής
        self.holes.append(Holes_roof)
        for i in range(len(self.number_roof)):
            self.number_roof[th]=No_cartridges_roof                                                 # Λίστα ποσότητας κάθε τύπου φυσιγγίων
        self.spacing.append(spacing_roof)
        
        
    def wall(self):
        distance=round(self.abutmentH-round(self.practicalb[4],2)-round(self.practicalb[5],2),2)    # Χώρος που απομένει για τα διατρήματα τοίχου
        x=round(0.6*self.hdepth,2)  
        minimum=1000
        th=0
        for i in range(len(self.charge)):
            VWmax=round(0.9*math.sqrt((self.charge[i]*self.Sanfo)/(1.2*(self.c+0.05)*1.25)),2)      # Ίδιο μοτίβο με διατρήματα δαπέδου
            if (VWmax<=x) and (x-VWmax)<minimum:
                vw=round(0.9*math.sqrt((self.charge[i]*self.Sanfo)/(1.2*(self.c+0.05)*1.25)),2)
                minimum=(x-vw)
                th=i
        V=vw                                                                                        # Μέγιστο φορτίο με άλλη ονομασία για να μην συγχωνευτεί με το VRmax του βρόγχου
        VW=round(V-(self.hdepth*math.sin(self.g))-((self.a*self.advance)+self.b),2)
        self.practicalb.append(VW)
        No_holes_wall=2*(int((distance/(VW*1.25)+2)))
        Spacing=round(distance/((No_holes_wall/2)-1),2)                                             # Απόσταση διατρημάτων τοίχου
        hb=round(1.25*VW,2)                                                                         # Μήκος επιγόμωσης πυθμένα
        hc=self.hdepth-hb-(10*self.hdiam)                                                           # Μήκος επιγόμωσης στήλης
        charge_column=round(0.5*self.charge[th],2)                                                  # charge_column=0.5*(charge_bottom) γραμμική πυκνότητα στήλης
        minimum=1000
        th1=0                     
        for i in range(len(self.charge)):
            if abs(self.charge[i]-charge_column)<minimum and (self.charge[i]-0.05<=charge_column):  # Επιλογή φυσιγγίου γόμωσης στήλης 
                minimum=abs(self.charge[i]-charge_column)
                th1=i
        No_cartridges_bottom=round((hb/self.cartridges[th]["length"])*2)/2
        No_cartridges_column=round((hc/self.cartridges[th1]["length"])*2)/2
        massW=round((((self.charge[th])*(self.cartridges[th]["length"])*(No_cartridges_bottom))+((self.charge[th1])*(self.cartridges[th1]["length"])*(No_cartridges_column))),2)
        self.massph.append(massW)
        Holes_wall=No_holes_wall
        self.holes.append(Holes_wall)
        for i in range(len(self.number_wall)):
            if th==th1:
                self.number_wall[th]=No_cartridges_bottom+No_cartridges_column
            else:
                self.number_wall[th]=No_cartridges_bottom
                self.number_wall[th1]=No_cartridges_column
        self.spacing.append(Spacing)
 
    def stoping(self):
        x=round(0.6*self.hdepth,2)
        #Horizontal cartridges

        minimum=1000
        th=0
        for i in range(len(self.charge)):
            VHmax=round(0.9*math.sqrt((self.charge[i]*self.Sanfo)/(1.25*(self.c+0.05)*1.25)),2)                
            if (VHmax<=x) and (x-VHmax)<minimum:
                vh=round(0.9*math.sqrt((self.charge[i]*self.Sanfo)/(1.25*(self.c+0.05)*1.25)),2)                      
                minimum=(x-VHmax)
                th=i
        distance_h=round(self.width-round(self.B[3],2)-(2*round(self.practicalb[6],2)),2)           # Χώρος που απομένει για τα οριζόντια διατρήματα διερεύνησης
        Vhmax=round(0.9*math.sqrt((self.charge[th]*self.Sanfo)/(1.45*(self.c+0.05)*1.25)),2)        # Μέγιστο φορτίο φυσιγγίου που επιλέχθηκε
        VH=round(Vhmax-(self.a*self.advance+self.b),2)                                              # Πρακτικό φορτίο 
        cols_h=0
        rows_h=0
        if VH>=distance_h:                                                                          # VH πρακτικό φορτίο, Vh νέο πρακτικό φορτίο αν ισχύει η συνθήκη              
            VH=round(distance_h+0.01,2)
            cols_h=1                                                                                # Αριθμός στηλών
            Spacing_columns_h=VH                                                                    # Απόσταση διατρημάτων στήλης 
        else: 
            cols_h=int(distance_h/VH)
            Spacing_columns_h=VH
            if (cols_h)*Spacing_columns_h<distance_h:
                cols_h=int(distance_h/VH)+1
                VH=round(distance_h/cols_h,2)
                Spacing_columns_h=VH
            else:
                cols_h=int(distance_h/VH)
        if (1.25*round(Vhmax-(self.a*self.advance+self.b),2))>=self.B[3]:
            rows_h=2
            Spacing_rows_h=self.B[3]
        else:
            VH=(round(Vhmax-(self.a*self.advance+self.b),2))
            rows_h=int((self.B[3]/(0.9*VH))+1)
            Spacing_rows_h=round(0.9*VH,2)
            if (rows_h-1)*Spacing_rows_h<self.B[3]:
                rows_h=rows_h+1
                VH=round(self.B[3]/(rows_h-1),2)
                Spacing_rows_h=VH
            else:
                rows_h=int((self.B[3]/(0.9*VH)))
        No_holes_h=cols_h*rows_h                                                                    # Αριθμός διατρημάτων οριζοντίων . στήλες x σειρές
        Spacing_horizontal_columns=Spacing_columns_h                                                # Απόσταση στηλών οριζοντίων διατρημάτων για το διάγραμμα
        Spacing_horizontal_rows=Spacing_rows_h                                                      # Απόσταση σειρών οριζοντίων διατρημάτων για το διάγραμμα
        self.No_columns.append(cols_h)                                                              # Λίστα αριθμού στηλών
        self.No_rows.append(rows_h)                                                                 # Λίστα αριθμού σειρών
        self.spacing_columns.append(Spacing_horizontal_columns)                                     # Λίστες αποστάσεων στηλών / σειρών
        self.spacing_rows.append(Spacing_horizontal_rows)
        self.practicalb.append(VH)
        
        
        #Downward Cartrtidges

        height_d=round((self.abutmentH+self.archHeight)-round(self.B[3],2)-round(self.practicalb[4],2)-round(self.practicalb[5],2),2)
        VDmax=round(0.9*math.sqrt((self.charge[th]*self.Sanfo)/(1.2*(self.c+0.05)*1.25)),2)
        VD=round(VDmax-(self.a*self.advance+self.b),2)
        xS1=0+self.practicalb[6]                                                                    # Αρχικές συντεταγμένες για τα κάθετα διατρήματα διεύρυνσης, το πάνω αριστερό άκρο του 4ου τετραγώνου του cut
        yS1=0+self.practicalb[4]+self.B[3]
        carts=0
        if VD>height_d:
            vd=round(height_d,2)                                                                    # Αν το πρακτικό φορτίο είναι μεγαλύτερο από το διαθέσιμο χώρο, τότε χρησιμοποείται νέο πρακτικό φορίτο όσο ο διαθέσιμος χώρος
            if (self.width-2*self.practicalb[6])<(2*VD):
                cols_d=3
            else:
                cols_d=int(((self.width-2*self.practicalb[6])/(1*VD))+1)                            # Στήλες καθέτων διατρημάτων
            Spacing_columns_d=round((self.width-2*self.practicalb[6])/(cols_d-1),2)                 # Απόσταση στηλών καθέτων διατρημάτων
            for i in range(0,cols_d):
                XS=xS1+(i*Spacing_columns_d)
                YS=0+self.practicalb[4]+self.B[3]
                a3= self.width/2
                b3 =(self.abutmentH+self.archHeight)-(self.abutmentH-self.practicalb[5])-self.practicalb[5] 
                x03 =self.width/2
                y03 =self.abutmentH-self.practicalb[5]
                x3 = XS
                y3 = b3 * np.sqrt(1 - ((x3-x03) / a3) ** 2) + y03                                   # Το πρακτικό φορτίο οροφής είναι μια καμπύλη επομένως πρέπει ο διαθέσιμος χώρος να υπολογιστεί βάσει της καμπύλης
                d=int(((y3+0.1-YS)/vd))                                                                 
                if d<1:
                    carts=carts+1
                else:
                    if (d)*vd<(y3-YS-0.3):
                        carts=carts+d+1
                    else:
                        carts=carts+d                                                            
        else:
            vd1=VD
            #cols_d=int(((self.width-2*self.practicalb[6])/(1*VD))+1)
            if (self.width-2*self.practicalb[6])<(2*VD):
                cols_d=3
            else:
                cols_d=int(((self.width-2*self.practicalb[6])/(1*VD))+1)                            # Στήλες καθέτων διατρημάτων
            Spacing_columns_d=round((self.width-2*self.practicalb[6])/(cols_d-1),2)
            d=int((height_d/vd1)+1)
            if d*vd1>height_d:
                vd=round((height_d/d),2)
            else:
                vd=vd1
            for i in range(0,cols_d):
                XS=xS1+(i*Spacing_columns_d)
                YS=0+self.practicalb[4]+self.B[3]
                a3= self.width/2
                b3 =(self.abutmentH+self.archHeight)-(self.abutmentH-self.practicalb[5])-self.practicalb[5] 
                x03 =self.width/2
                y03 =self.abutmentH-self.practicalb[5]
                x3 = XS
                y3 = b3 * np.sqrt(1 - ((x3-x03) / a3) ** 2) + y03
                d=int((y3+0.1-YS)/vd)
                if d<1:
                    carts=carts+1
                else:
                    if (d)*vd<(y3-YS-0.3):
                        carts=carts+d+1
                    else:
                        carts=carts+d                
        No_holes_d= carts
        No_holes_stoping=No_holes_d+No_holes_h                                                      #Συνολικός αριθμός διατρημάτων διεύρυνσης
        self.holes.append(No_holes_stoping)
        self.spacing_columns.append(Spacing_columns_d)
        self.cols_downwards.append(cols_d)
        self.practicalb.append(vd)
        
        
        #Cartridges Calculation

        hb=round(1.25*VH,2)                                                                         # Μήκος επιγόμωσης πυθμένα 
        hc=round(self.hdepth-round(hb,2)-(10*self.hdiam),2)                                         # Μήκος επιγόμωσης στήλης
        charge_column=round(0.5*self.charge[th],2)                                                  # Γραμμική πυκνότητα γόμωσης στήλης
        minimum=1000
        th1=0
        for i in range(len(self.charge)):
            if abs(self.charge[i]-charge_column)<minimum and (self.charge[i]-0.05<=charge_column):  # Επιλογή φυσιγγίου για επιγόμωση στήλης
                minimum=abs(self.charge[i]-charge_column)
                th1=i
        No_cartridges_bottom= round((hb/self.cartridges[th]["length"])*2)/2                               
        No_cartridges_column= round((hc/self.cartridges[th1]["length"])*2)/2
        massS=round((((self.charge[th])*(self.cartridges[th]["length"])*(No_cartridges_bottom))+((self.charge[th1])*(self.cartridges[th1]["length"])*(No_cartridges_column))),2)
        self.massph.append(massS)
        for i in range(len(self.number_stoping)):
            if th==th1:
                self.number_stoping[th]=No_cartridges_bottom+No_cartridges_column
            else:
                self.number_stoping[th]=No_cartridges_bottom
                self.number_stoping[th1]=No_cartridges_column


    def sum(self):
        for i in range(len(self.massph)):
            x=round((self.massph[i]*self.holes[i]),2)
            self.total.append(x)
           
        # Υπολογισμός συνολικής μάζας εκρηκτικών ( μάζα εκρηκτικών ανά διάτρημα x διατρήματα)

        
        
    def table1(self):
        li=[self.number_first,self.number_second,self.number_third,self.number_fourth,self.number_lifters,self.number_roof,self.number_wall,self.number_stoping]
        data=pd.DataFrame(li)                                                                       # Δημιουργία DataFrame σαν συγκεντρωτικός πίνακας
        data.columns=[self.diam]   
        data.index=["First Quadrangle","Second Quandrangle","Third Quandrangle","Fourth Quandrangle","Lifters","Roof","Wall","Stoping"]  # Σειρές πίνακα, μέρη της διάτρησης
        data.insert(0,"No. Holes",self.holes,True)                                                  # Εισαγωγή στηλών πίνακα ( αριθμός διατρημάτων, γραμμική πυκνότητα ανά διάτρημα, συνολική μάζα )
        data.insert(1,"Charge per Hole , kg",self.massph,True)
        data.insert(2,"Total , kg",self.total,True)
        print(tabulate(data,headers='keys',tablefmt ='fancy_grid'))                                 # Μορφή κελιών πίνακα (pretty ή fancy_grid)



        # Τελικός πίνακας 
    def table2(self):
        Total_weight = round(sum(self.total),2)                                                     # Συνολική μάζα εκρηκτικών
        Total_holes = sum(self.holes)                                                               # Συνολικά διατρήματα (πρόσθεση των διατρημάτων στη λίστα διατρημάτων)
        R=round(((self.archHeight**2+((self.width/2)**2))/self.archHeight)/2,2)                     # Ακτίνα κύκλου
        angle_rad=round(math.acos((R-self.archHeight)/R)*2,2)                                       # Γωνία ακτίνας σε rad
        angle_deg=round((angle_rad*180)/math.pi,2)
        Cross_sectional_area=round((self.width*self.abutmentH)+((angle_rad/2)*(R**2))-((R-self.archHeight)*(0.5*self.width)),2)  # Συνολικό εμβαδό μετώπου 
        Specific_charge= round((Total_weight/(Cross_sectional_area*self.advance)),2)                # Ειδική κατανάλωση
        Specific_drilling= round(((Total_holes*self.hdepth)/(Cross_sectional_area*self.advance)),2) # Ειδική διάτρηση
        li=[Total_weight,Total_holes,self.advance,self.hdepth,Cross_sectional_area,Specific_charge,Specific_drilling] # Στήλες Πίνακα , τιμές στοιχείων
        data=pd.DataFrame(li)
        data.index=['Total charge weight (kg)','Total No. of holes ','Advance (m)','Hole depth (m)','Cross sectional area (m2)','Specific charge (kg/m3)','Specific drilling (m/m3)']
        print(tabulate(data, tablefmt ='fancy_grid'))

       

        # ΠΑΡΑΔΕΙΓΜΑ ΤΕΤΡΑΓΩΝΙΚΗΣ ΣΤΟΑΣ 3.5 m X 4 m 
    def case_study2(self):
         
        fig, ax = plt.subplots(1, 1)
        ax.set_aspect('equal')
        x_asix = np.array([self.width])
        y_asix = np.array([self.abutmentH])
        x_coordenates = np.concatenate([ x_asix])
        y_coordenates = np.concatenate([y_asix])
        ax.set_facecolor('whitesmoke')
        ax.plot(x_coordenates, y_coordenates, color= 'black')
        x=round(0.6*self.hdepth,2)
        if self.abutmentH>=4.5 or self.abutmentH+self.archHeight>=4.5:
            xQ=(self.width/2)                                                           # Συντεταγμένες αρχής cut (τέρμα  αριστερά δίπλα απο το πρακτικό φορτίο του τοίχου)
            yQ=(self.abutmentH/2)                                                       # Ορίζεται αρχικό σημείο το κενό διάτρημα που βρίσκεται στο μέσο του cut.
                                                                                                        # Συντεταγμένη ψ υπολογίζεται από το τέλος του πρακτικού φορτίου των lifters και το μισό από την πλευρά του 4ου τετραγώνου
            plt.scatter(xQ,yQ)                                                                          # Συντεταγμένη χ υπολογίζεται από το τέλος του πρακτικού φορτίου του τοίχου και το μισό από την πλευρά του 4ου τετραγώνου

            x1=[xQ-(round(self.B[0],2)*math.cos(0.25*math.pi)),xQ,xQ+(round(self.B[0],2)*math.cos(0.25*math.pi)),xQ,xQ-(round(self.B[0],2)*math.cos(0.25*math.pi))]
            y1=[yQ,yQ+(round(self.B[0],2)*math.sin(0.25*math.pi)),yQ,yQ-(round(self.B[0],2)*math.sin(0.25*math.pi)),yQ] 

        # Με αρχικές συντεταγμένες τα xQ, yQ, υπολογίζονται οι συντεταγμένες του κάθε σημείου του τετραγώνου
        # Ο υπολογισμός γίνεται με τα συνημίτονα και τα ημίτονα των γωνιών και τις αντίστοιχες πλευρές του κάθε τετραγώνου self.B
        
            x2=[(xQ-((round(self.practicalb[1],2)+(round(self.B[0],2)/2))*math.cos(0.25*math.pi))),(xQ-((round(self.practicalb[1],2)+(round(self.B[0],2)/2))*math.cos(0.25*math.pi)))+round(self.B[1],2),(xQ-((round(self.practicalb[1],2)+(round(self.B[0],2)/2))*math.cos(0.25*math.pi)))+round(self.B[1],2),(xQ-((round(self.practicalb[1],2)+(round(self.B[0],2)/2))*math.cos(0.25*math.pi))),(xQ-((round(self.practicalb[1],2)+(round(self.B[0],2)/2))*math.cos(0.25*math.pi)))]
            y2=[(yQ+((round(self.practicalb[1],2)+(round(self.B[0],2)/2))*math.sin(0.25*math.pi))),(yQ+((round(self.practicalb[1],2)+(round(self.B[0],2)/2))*math.sin(0.25*math.pi))),(yQ+((round(self.practicalb[1],2)+(round(self.B[0],2)/2))*math.sin(0.25*math.pi)))-round(self.B[1],2),(yQ+((round(self.practicalb[1],2)+(round(self.B[0],2)/2))*math.sin(0.25*math.pi)))-round(self.B[1],2),(yQ+((round(self.practicalb[1],2)+(round(self.B[0],2)/2))*math.sin(0.25*math.pi)))]

            x3=[xQ-(round(self.practicalb[2],2)+(round(self.B[1],2)/2)),xQ,xQ+(round(self.practicalb[2],2)+(round(self.B[1],2)/2)),xQ,xQ-(round(self.practicalb[2],2)+(round(self.B[1],2)/2))]
            y3=[yQ,yQ+(round(self.practicalb[2],2)+(round(self.B[1],2)/2)),yQ,yQ-(round(self.practicalb[2],2)+(round(self.B[1],2)/2)),yQ]


            x4=[(xQ-((round(self.practicalb[3],2)+(round(self.B[2],2)/2))*math.cos(0.25*math.pi))),(xQ-((round(self.practicalb[3],2)+(round(self.B[2],2)/2))*math.cos(0.25*math.pi)))+round(self.B[3],2),(xQ-((round(self.practicalb[3],2)+(round(self.B[2],2)/2))*math.cos(0.25*math.pi)))+round(self.B[3],2),(xQ-((round(self.practicalb[3],2)+(round(self.B[2],2)/2))*math.cos(0.25*math.pi))),(xQ-((round(self.practicalb[3],2)+(round(self.B[2],2)/2))*math.cos(0.25*math.pi)))]
            y4=[(yQ+((round(self.practicalb[3],2)+(round(self.B[2],2)/2))*math.sin(0.25*math.pi))),(yQ+((round(self.practicalb[3],2)+(round(self.B[2],2)/2))*math.sin(0.25*math.pi))),(yQ+((round(self.practicalb[3],2)+(round(self.B[2],2)/2))*math.sin(0.25*math.pi)))-round(self.B[3],2),(yQ+((round(self.practicalb[3],2)+(round(self.B[2],2)/2))*math.sin(0.25*math.pi)))-round(self.B[3],2),(yQ+((round(self.practicalb[3],2)+(round(self.B[2],2)/2))*math.sin(0.25*math.pi)))]

            plt.scatter(x1,y1,color='olive')
            plt.scatter(x2,y2,color='olive')
            plt.scatter(x3,y3,color='olive')
            plt.scatter(x4,y4,color='olive')
            plt.plot(x1,y1,color='black')                                                               # Δημιουργία ευθειών ανάμεσα στα διατρήματα για την απεικόνιση τετραγώνων!!!
            plt.plot(x2,y2,color='black')
            plt.plot(x3,y3,color='black')
            plt.plot(x4,y4,color='black')
            ax.annotate(self.B[2],(xQ-(x3[3]-x3[2]/2),y3[4]-y3[3]/2))
            ax.annotate(self.B[3],(x4[0]+self.B[3]/2,y4[0]))                                            # ΄Οπου annotate, η απεικόνιση της πλευράς του κάθε τετραγώνου!!!
            ax.annotate(self.B[1],(xQ,yQ+self.B[1]/2))
            ax.annotate(self.B[0],(xQ-(x1[2]-x1[1]),yQ-(y1[1]-y1[2])))
            ax.annotate(self.emptyf,(xQ,yQ),color='blue')

        else:
            xQ=(self.width/2)                                                           # Συντεταγμένες αρχής cut (τέρμα  αριστερά δίπλα απο το πρακτικό φορτίο του τοίχου)
            yQ=(self.abutmentH/2)                                                       # Ορίζεται αρχικό σημείο το κενό διάτρημα που βρίσκεται στο μέσο του cut.
            x1=[(xQ-((round(self.practicalb[0],2))*math.cos(0.25*math.pi))),(xQ-((round(self.practicalb[0],2))*math.cos(0.25*math.pi)))+round(self.B[0],2),(xQ-((round(self.practicalb[0],2))*math.cos(0.25*math.pi)))+round(self.B[0],2),(xQ-((round(self.practicalb[0],2))*math.cos(0.25*math.pi))),(xQ-((round(self.practicalb[0],2))*math.cos(0.25*math.pi)))]
            y1=[(yQ+((round(self.practicalb[0],2))*math.sin(0.25*math.pi))),(yQ+((round(self.practicalb[0],2))*math.sin(0.25*math.pi))),(yQ+((round(self.practicalb[0],2))*math.sin(0.25*math.pi)))-round(self.B[0],2),(yQ+((round(self.practicalb[0],2))*math.sin(0.25*math.pi)))-round(self.B[0],2),(yQ+((round(self.practicalb[0],2))*math.sin(0.25*math.pi)))]

            x2=[xQ-(round(self.B[1],2)*math.cos(0.25*math.pi)),xQ,xQ+(round(self.B[1],2)*math.cos(0.25*math.pi)),xQ,xQ-(round(self.B[1],2)*math.cos(0.25*math.pi))]
            y2=[yQ,yQ+(round(self.B[1],2)*math.sin(0.25*math.pi)),yQ,yQ-(round(self.B[1],2)*math.sin(0.25*math.pi)),yQ]
            
            x3=[(xQ-((round(self.practicalb[2],2)+(round(self.B[1],2)/2))*math.cos(0.25*math.pi))),(xQ-((round(self.practicalb[2],2)+(round(self.B[1],2)/2))*math.cos(0.25*math.pi)))+round(self.B[2],2),(xQ-((round(self.practicalb[2],2)+(round(self.B[1],2)/2))*math.cos(0.25*math.pi)))+round(self.B[2],2),(xQ-((round(self.practicalb[2],2)+(round(self.B[1],2)/2))*math.cos(0.25*math.pi))),(xQ-((round(self.practicalb[2],2)+(round(self.B[1],2)/2))*math.cos(0.25*math.pi)))]
            y3=[(yQ+((round(self.practicalb[2],2)+(round(self.B[1],2)/2))*math.sin(0.25*math.pi))),(yQ+((round(self.practicalb[2],2)+(round(self.B[1],2)/2))*math.sin(0.25*math.pi))),(yQ+((round(self.practicalb[2],2)+(round(self.B[1],2)/2))*math.sin(0.25*math.pi)))-round(self.B[2],2),(yQ+((round(self.practicalb[2],2)+(round(self.B[1],2)/2))*math.sin(0.25*math.pi)))-round(self.B[2],2),(yQ+((round(self.practicalb[2],2)+(round(self.B[1],2)/2))*math.sin(0.25*math.pi)))]

            plt.scatter(x1,y1,color='olive')
            plt.scatter(x2,y2,color='olive')
            plt.scatter(x3,y3,color='olive')
            plt.plot(x1,y1,color='black')                                                               # Δημιουργία ευθειών ανάμεσα στα διατρήματα για την απεικόνιση τετραγώνων!!!
            plt.plot(x2,y2,color='black')
            plt.plot(x3,y3,color='black')
            ax.annotate(self.B[2],(xQ,yQ+self.B[2]/2))                                                  # ΄Οπου annotate, η απεικόνιση της πλευράς του κάθε τετραγώνου!!!
            ax.annotate(self.B[1],(xQ,yQ+self.B[1]/2))
            ax.annotate(self.B[0],(xQ-(x1[2]-x1[1]),yQ-(y1[1]-y1[2])))
            ax.annotate(self.emptyf,(xQ,yQ),color='blue') 

            
        # Lifters
        x=round(0.6*self.hdepth,2)                                                                  # Το πρακτικό φορτίο των Lifters πρέπει να είναι μικρότερο ή ίσο με 0.6 φορές το Βάθος του διατρήματος
        minimum=1000     
        th=0
        for i in range(len(self.charge)):
            v1max=round(0.9*math.sqrt((self.charge[i]*self.Sanfo)/(1.25*(self.c+0.05)*1.25)),2)
            if (v1max<=x) and (x-v1max)<minimum:
                vl=round(0.9*math.sqrt((self.charge[i]*self.Sanfo)/(1.25*(self.c+0.05)*1.25)),2)    # Παράλληλα , χρησιμοποιούμε το φυσίγγιο με τη μέγιστη δυνατή γραμμική πυοκνότητας γόμωσης 
                minimum=(x-v1max)
                th=i
        vl=round(0.9*math.sqrt((self.charge[th]*self.Sanfo)/(1.45*(self.c+0.05))),2)
        if vl>=1.4:
            VLmax=vl                                                                                # Αν το πρακτικό φορτίο είναι μεγαλύτερο από 1.4 , η διορθωμένη σταθερά c αλλάζει
        else:
            VLmax=round(0.9*math.sqrt((self.charge[th]*self.Sanfo)/(1.45*(self.c+(0.07/vl)))),2)
        N=int(((self.width+2*self.hdepth*math.sin(self.g))/VLmax)+1)                                # Αριθμός διατρημάτων δαπέδου
        El=round(((self.width+2*self.hdepth*math.sin(self.g))/(N-1)),2)                             # Απόσταση διατρημάτων δαπέδου
        corner_El=round(El-(self.hdepth*math.sin(self.g)),2)                                        # Απόσταση γωνιακών διατρημάτων δαπέδου
        VL=round(VLmax-(self.hdepth*math.sin(self.g))-(self.a*self.hdepth+self.b),2)                # Πρακτικό φορτίο (Μέγιστο - F)
        self.practicalb.append(VL)  
        hb=round(1.25*VL,2)                                                                         # Μήκος επιγόμωσης πυθμένα
        hc=self.hdepth-hb-(10*self.hdiam)                                                           # Μήκος επιγόμωσης στήλης
        charge_column=round(0.7*self.charge[th],2)                                                  # Γραμμική πυκνότητα γόμωσης στήλης                                
        minimum=1000
        th1=0
        for i in range(len(self.charge)):
            if abs(self.charge[i]-charge_column)<minimum and (self.charge[i]-0.05<=charge_column):  # Επιλογή φυσιγγίου για την γόμωση στήλης ανάλογα με την γραμμική πυκνότητα γόμωσης στήλης
                minimum=abs(self.charge[i]-charge_column)
                th1=i
        No_cartridges_bottom= round((hb/self.cartridges[th]["length"])*2)/2                         # Αριθμός φυσιγγίων πυθμένα    
        No_cartridges_column= round((hc/self.cartridges[th1]["length"])*2)/2                        # Αριθμός φυσιγγίων στήλης
        massL=round((((self.charge[th])*(self.cartridges[th]["length"])*(No_cartridges_bottom))+((self.charge[th1])*(self.cartridges[th1]["length"])*(No_cartridges_column))),2)
        self.test_mass.append(massL)                                                                # Λίστα μάζας γόμωσης/διάτρημα 
        Holes_lifters=N                                                                             # Αριθμός διατρημάτων δαπέδου
        self.test_no.append(Holes_lifters)                                                          # Λίστα αριθμού διατρημάτων
        for i in range(len(self.number_lifters)):
             if th==th1:                                                                            # Αν τα φυσίγγια στήλης είναι τα ίδια με τα φυσίγγια πυθμένα (th1,th) πρέπει να προστεθούν οι αριθμοί και όχι να καταχωρυθεί μόνο το ένα
                self.number_lifters1[th]=No_cartridges_bottom+No_cartridges_column
                self.number_lifters1[th1]=No_cartridges_bottom+No_cartridges_column
             else:
                self.number_lifters1[th]=No_cartridges_bottom                                       # Για κάθε τύπο φυσιγγίου , τοποθετείται στη λίστα ο αριθμός που θα χρησιμοποιηθεί πχ.[4,0,4]
                self.number_lifters1[th1]=No_cartridges_column

        # Lifters Design        
        l=Holes_lifters                                                                             # Αριθμός διατρημάτων δαπέδου
        for i in range(0,l+1):
            if i==0:                                                                                # Τοποθέτηση του πρώτου αρχικού διατρήματος στην άκρη
                x1=0
                y1=0
            else:
                if i==1:                                                                            # Τοποθέτηση του αμέσως επόμενου διατρήματος με απόσταση γωνιακών διατρημάτων Lifters
                    x1=0+corner_El
                    y1=0
                    ax.annotate(corner_El,(x1/2,y1+0.1))                                            # Τοποθέτηση της απόστασης των γωνιακών διατρημάτων σαν διάσταση ανάμεσα στα διατρήματα
                else:
                    if i==l:                                                                        # Τοποθέτηση του τελευταίου διατρήματος στο τέλος των Lifters
                        x1=self.width
                        y1=0
                    else:
                        if i==l-1:                                                                  # Τοποθέτηση του προτελευταίου διατρήματος με απόσταση γωνιακών διατρημάτων δαπέδου από το τελευταίο
                            x1=self.width-corner_El
                            y1=0
                            ax.annotate(corner_El,(self.width-corner_El/2,y1+0.1))                  # Τοποθέτηση διάστασης ανάμεσα στα διατρήματα
                        else:
                            x1=corner_El+(i-2)*self.spacing[0]                                      # Τα ενδιάμεσα διατρήματα με κανονική απόσταση διατρημάτων Lifters
                            y1=0
                            ax.annotate(El,(x1+El/2,y1+0.1))                                        # Τοποθέτηση διάστασης ανάμεσα στα διατρήματα
            plt.scatter(x1,y1,color='navy')

           
        # Roof
        k=15                                                                                        
        E=round(k*self.hdiam,2)                                                                                                                     
        VRmax=round((E/0.8),2)                                                                      
        VR=round(VRmax-(self.hdepth*math.sin(self.g))-(self.a*self.advance+self.b),2)               
        
        min_charge=round(90*(self.hdiam**2),2)                                                      # Ελάχιστη γραμμική πυκνόητητα γόμωσης για smooth blasting
        minimum=1000
        th=0
        for i in range(len(self.charge)):
            if abs(self.charge[i]-min_charge)<minimum and (self.charge[i]>min_charge):              # Επιλογή φυσιγγίου ανάλογα με την ελάχιστη γραμμική πυκνότητα γόμωσης
                minimum=abs(self.charge[i]-min_charge)
                th=i
        No_cartridges_roof=int(self.hdepth/self.cartridges[th]["length"])                               
        massR=round(((self.charge[th])*(self.cartridges[th]["length"])*(No_cartridges_roof)),2)         
        No_holes_roof=int(self.width/E)+1
        spacing=round(self.width/(No_holes_roof-1),2)
        Holes_roof=No_holes_roof                                                                    
        self.test_no.append(Holes_roof)
        self.test_mass.append(massR)
        total=massR*No_holes_roof
        for i in range(len(self.number_roof)):
            self.number_roof1[th]=No_cartridges_roof                                                    
        for i in range(0,Holes_roof):
            xR=(0+(i)*spacing)
            yR=self.abutmentH
            plt.scatter(xR,yR,color='brown')
            xM=(self.width/2)
            yM=self.abutmentH-0.2
            ax.annotate(spacing,(xM,yM))
        
        # Horizontal stoping τετραγωνικής
        minimum=1000
        th=0
        for i in range(len(self.charge)):
            VHmax=round(0.9*math.sqrt((self.charge[i]*self.Sanfo)/(1.25*(self.c+0.05)*1.25)),2)                
            if (VHmax<=x) and (x-VHmax)<minimum:
                vh=round(0.9*math.sqrt((self.charge[i]*self.Sanfo)/(1.25*(self.c+0.05)*1.25)),2)                      
                minimum=(x-VHmax)
                th=i
        distance_h=round(((0+self.width/2)-(self.B[3]/2)),2)
        Vhmax=round(0.9*math.sqrt((self.charge[th]*self.Sanfo)/(1.45*(self.c+0.05)*1.25)),2)
        VH=round(Vhmax-(self.a*self.advance+self.b),2)
        cols_h=0
        rows_h=0
        if VH>=distance_h:                                                                                       
            VH=round(distance_h+0.01,2)
            cols_h=1                                                                               
            Spacing_columns_h=VH                                                                    
        else: 
            cols_h=int((distance_h/VH)+1)
            Spacing_columns_h=VH
            if (cols_h-1)*Spacing_columns_h<distance_h:
                cols_h=int((distance_h/VH)+1)
                VH=round(distance_h/cols_h,2)
                Spacing_columns_h=VH
            else:
                cols_h=int(distance_h/VH)
        if (1.25*round(Vhmax-(self.a*self.advance+self.b),2))>=self.B[3]:
            rows_h=2
            Spacing_rows_h=self.B[3]
        else:
            VH=(round(Vhmax-(self.a*self.advance+self.b),2))
            rows_h=int((self.B[3]/(0.9*VH))+1)
            Spacing_rows_h=round(0.9*VH,2)
            if (rows_h-1)*Spacing_rows_h<self.B[3]:
                rows_h=rows_h+1
                VH=round(self.B[3]/(rows_h-1),2)
                Spacing_rows_h=VH
            else:
                rows_h=int((self.B[3]/(0.9*VH)))
        No_holes_h=2*(cols_h*rows_h)                                                                   
        xS=(self.width/2)-(self.B[3]/2)                                                        
        yS=(self.abutmentH/2)+(self.B[3]/2)
        xZ=(self.width/2)+(self.B[3]/2)
        yZ=(self.abutmentH/2)+(self.B[3]/2)
        c1=cols_h                                                                       
        r1=rows_h                                                                              
        for i in range(0,c1):
            xh=xS-((i+1)*Spacing_columns_h)                                                       
            yh=yS
            xz=xZ+((i+1)*Spacing_columns_h)
            yz=yZ
            plt.scatter(xh,yh,color='red')
            plt.scatter(xz,yz,color='red')
            for z in range(0,r1):                                                                       
                xh1=xh
                yh1=yS-((z)*Spacing_rows_h)
                xz1=xz
                yz1=yZ-((z)*Spacing_rows_h)
                plt.scatter(xh1,yh1,color='red')
                plt.scatter(xz1,yz1,color='red')
            plt.scatter(xh,yh,color='red')
        for i in range(0,c1):                                                                           
            x1=xS-(i*VH)
            y1=yS
            xz1=xZ+(i*VH)
            yz1=yS
            if i==0:
                ax.annotate(VH,(x1-Spacing_columns_h/2,y1),color='blue')
                ax.annotate(VH,(xz1+Spacing_columns_h/2,y1),color='blue')
        for z in range(0,r1-1):
            x2=xS-c1*Spacing_columns_h
            y2=yS-z*Spacing_rows_h
            xz2=xZ+c1*Spacing_columns_h
            yz2=yZ-z*Spacing_rows_h
            if z==0:
                ax.annotate(Spacing_rows_h,(x2,y1-Spacing_rows_h/2),color='black')
                ax.annotate(Spacing_rows_h,(xz2,y1-Spacing_rows_h/2),color='black')
    
        
        # Downwards stoping τετραγωνικής
        height_d1=round(self.abutmentH-VR-((self.abutmentH/2)+(self.B[3]/2)),2)
        VDmax=round(0.9*math.sqrt((self.charge[th]*self.Sanfo)/(1.2*(self.c+0.05)*1.25)),2)
        VD=round(VDmax-(self.a*self.advance+self.b),2)
       
        cols_d1=0
        rows_d1=0
        if VD>height_d1:
            vd=round(height_d1,2)
            if (self.width<(2*VD)):
                cols_d1=3
            else:
                cols_d1=int((self.width/(1*VD))+1)
            Spacing_columns_d1=round((self.width/(cols_d1-1)),2)
            rows_d1=1
            Spacing_rows_d1=vd
        else:
            vd=VD
            if (self.width<(2*VD)):
                cols_d1=3
            else:
                cols_d1=int((self.width/(1*VD))+1)
            Spacing_columns_d1=round((self.width/(cols_d1-1)),2)
            rows_d1=int(height_d1/vd)
            Spacing_rows_d1=vd
            if (rows_d1*Spacing_rows_d1)<height_d1:
                rows_d1=rows_d1+1
                Spacing_rows_d1=round((height_d1/rows_d1),2)

        x0=0
        y0=(self.abutmentH/2)+(self.B[3]/2)
        r1=rows_d1
        c1=cols_d1
        for i in range(0,r1):
            xd1=x0
            yd1=y0+((i+1)*(Spacing_rows_d1))
            plt.scatter(xd1,yd1,color='red')
            if i==0:
                xAnnot1=x0
                yAnnot1=y0+((i+1)*(Spacing_rows_d1)/2)
                ax.annotate(Spacing_rows_d1,(xAnnot1,yAnnot1),color='blue')
            for p in range(0,c1):
                xd2=x0+(p)*(Spacing_columns_d1)
                yd2=yd1
                plt.scatter(xd2,yd2,color='red')
                if p==0:
                    xAnnot2=xd2+((p)*(Spacing_columns_d1)/2)
                    yAnnot2=yd1+0.1
                    ax.annotate(Spacing_columns_d1,(xAnnot2,yAnnot2),color='black')          
        height_d2=(self.abutmentH/2)-(self.B[3]/2)-VL
        cols_d2=0
        rows_d2=0
        if height_d2>0.1:
            cols_d2=cols_d1
            rows_d2=0
            if VD>height_d2:
                vd2=round(height_d2,2)
                cols_d2=cols_d1
                Spacing_columns_d2=Spacing_columns_d1
                rows_d2=1
                Spacing_rows_d2=vd2
            else:
                vd2=VD
                cols_d2=cols_d1
                Spacing_columns_d2=Spacing_columns_d1
                rows_d2=int(height_d2/vd2)
                Spacing_rows_d2=vd
                if (rows_d2*Spacing_rows_d2)<height_d2:
                    rows_d2=rows_d2+1
                    Spacing_rows_d2=round((height_d2/rows_d2),2)
            xO=0
            yO=(self.abutmentH/2)-(self.B[3]/2)
            r2=rows_d2
            c2=cols_d2
            for i in range(0,r2):
                xd3=xO
                yd3=yO-((i+1)*(Spacing_rows_d2))
                plt.scatter(xd3,yd3,color='green')
                if i==0:
                    xAnnot3=xO
                    yAnnot3=yO-((i+1)*(Spacing_rows_d1)/2)
                    ax.annotate(Spacing_rows_d2,(xAnnot3,yAnnot3),color='blue')
                for p in range(0,c2):
                    xd4=xO+(p)*(Spacing_columns_d2)
                    yd4=yd3
                    plt.scatter(xd4,yd4,color='red')
                    if p==0:
                        xAnnot4=xO+(i+1)*(Spacing_columns_d2/2)
                        yAnnot4=yd4
                        ax.annotate(Spacing_columns_d2,(xAnnot4,yAnnot4),color='blue')
        xL=[0,self.width]
        yL=[0+VL,0+VL]
    
        print(cols_d1)
        
        # Cartridges Calculation τετραγωνικής
        hb=round(1.25*VD,2)
        hc=round(self.hdepth-round(hb,2)-(10*self.hdiam),2)
        charge_column=round(0.5*self.charge[th],2)
        minimum=1000
        th1=0
        for i in range(len(self.charge)):
            if abs(self.charge[i]-charge_column)<minimum and (self.charge[i]-0.05<=charge_column):
                minimum=abs(self.charge[i]-charge_column)
                th1=i
        No_cartridges_bottom= round((hb/self.cartridges[th]["length"])*2)/2                               
        No_cartridges_column= round((hc/self.cartridges[th1]["length"])*2)/2
        massS=round((((self.charge[th])*(self.cartridges[th]["length"])*(No_cartridges_bottom))+((self.charge[th1])*(self.cartridges[th1]["length"])*(No_cartridges_column))),2)
        No_holes=(2*(cols_h*rows_h))+(cols_d1*rows_d1)+(cols_d2*rows_d2)
        self.test_no.append(No_holes)
        self.test_mass.append(massS)
        total=massS*No_holes
        for i in range(len(self.number_stoping1)):
            if th==th1:
                self.number_stoping1[th]=No_cartridges_bottom+No_cartridges_column
            else:
                self.number_stoping1[th]=No_cartridges_bottom
                self.number_stoping1[th1]=No_cartridges_column
               
        for i in range(len(self.test_mass)):
            x=round((self.test_mass[i]*self.test_no[i]),2)
            self.test_total.append(x)
        
        # 1ος Πίνακας τετραγωνικής
        li=[self.number_first,self.number_second,self.number_third,self.number_fourth,self.number_lifters1,self.number_roof1,self.number_stoping1]
        data=pd.DataFrame(li)
        data.columns=[self.diam]   
        data.index=["First Quadrangle","Second Quandrangle","Third Quandrangle","Fourth Quandrangle","Lifters","Roof","Stoping"]
        data.insert(0,"No. Holes",self.test_no,True)
        data.insert(1,"Charge per Hole , kg",self.test_mass,True)
        data.insert(2,"Total , kg",self.test_total,True)
        print(tabulate(data,headers='keys',tablefmt ='fancy_grid'))
        
        
        # 2ος Πίνακας τετραγωνικής
        Total_weight = round(sum(self.test_total),2)
        Total_holes = sum(self.test_no)
        Cross_sectional_area=round((self.abutmentH*self.width),2)                                                        # Εμβαδό τετραγωνικής
        Specific_charge= round((Total_weight/(Cross_sectional_area*self.advance)),2)
        Specific_drilling= round(((Total_holes*self.hdepth)/(Cross_sectional_area*self.advance)),2)
        li=[Total_weight,Total_holes,self.advance,self.hdepth,Cross_sectional_area,Specific_charge,Specific_drilling]
        data=pd.DataFrame(li)
        data.index=['Total charge weight (kg)','Total No. of holes ','Advance (m)','Hole depth (m)','Cross sectional area (m2)','Specific charge (kg/m3)','Specific drilling (m/m3)']
        print(tabulate(data, tablefmt ='fancy_grid'))
        
        plt.show()
        

    def plot(self):
        
     #ARCH DESIGN
        
        fig, ax = plt.subplots(1, 1)
        ax.set_aspect('equal')
        x_asix = np.array([0,0,0+self.width,0+self.width])                                          # Δημιουργία μετώπου με συντεταγμένες χ,ψ ανάλογα με το πλάτος και το μήκος
        y_asix = np.array([0+self.abutmentH,0,0,0+self.abutmentH])
        x_coordenates = np.concatenate([ x_asix])
        y_coordenates = np.concatenate([y_asix])
        ax.plot(x_coordenates, y_coordenates, color= 'black')
        
        a= self.width/2                                              
        b = self.archHeight
        x0 = self.width/2
        y0 = self.abutmentH
        x = np.linspace(-a + x0, a + x0)
        y = b * np.sqrt(1 - ((x - x0) / a) ** 2) + y0
        ax.plot(x,y,color='black')
        ax.set_facecolor('whitesmoke')
        
    #LIFTERS

        xL=[0,0+self.width]                                                                         # Δημιουργία της γραμμής που απεικονίζει το όριο των Lifters
        yL=[0+self.practicalb[4],0+self.practicalb[4]]
        plt.plot(xL,yL,color="black")
        l=self.holes[4]                                                                             # Αριθμός διατρημάτων δαπέδου
        for i in range(0,l+1):
            if i==0:                                                                                # Τοποθέτηση του πρώτου αρχικού διατρήματος στην άκρη
                x1=0
                y1=0
            else:
                if i==1:                                                                            # Τοποθέτηση του αμέσως επόμενου διατρήματος με απόσταση γωνιακών διατρημάτων Lifters
                    x1=0+self.corner_holes[0]
                    y1=0
                    ax.annotate(self.corner_holes[0],(x1/2,y1+0.1))                                 # Τοποθέτηση της απόστασης των γωνιακών διατρημάτων σαν διάσταση ανάμεσα στα διατρήματα
                else:
                    if i==l:                                                                        # Τοποθέτηση του τελευταίου διατρήματος στο τέλος των Lifters
                        x1=self.width
                        y1=0
                    else:
                        if i==l-1:                                                                  # Τοποθέτηση του προτελευταίου διατρήματος με απόσταση γωνιακών διατρημάτων δαπέδου από το τελευταίο
                            x1=self.width-self.corner_holes[0]
                            y1=0
                            ax.annotate(self.corner_holes[0],(self.width-self.corner_holes[0]/2,y1+0.1)) # Τοποθέτηση διάστασης ανάμεσα στα διατρήματα
                        else:
                            x1=self.corner_holes[0]+(i-2)*self.spacing[0]                           # Τα ενδιάμεσα διατρήματα με κανονική απόσταση διατρημάτων Lifters
                            y1=0
                            ax.annotate(self.spacing[0],(x1+self.spacing[0]/2,y1+0.1))              # Τοποθέτηση διάστασης ανάμεσα στα διατρήματα
            plt.scatter(x1,y1,color='navy')                                                         # Απεικόνιση διατρημάτων σαν κουκίδες στο διάγραμμα
            
    #ROOF HOLES
            
        a1= self.width/2
        b1 =(self.abutmentH+self.archHeight)-(self.abutmentH-self.practicalb[5])-self.practicalb[5] # Δημιουργία κυκλικού τμήματος παράλληλου της οροφής , που απεικονίζει το πρακτικό φορτίο της οροφής
        x01 =self.width/2
        y01 =self.abutmentH-self.practicalb[5]
        x1 = np.linspace(-a1 + x01, a1 + x01)
        y1 = b1 * np.sqrt(1 - ((x1-x01) / a1) ** 2) + y01
        ax.plot(x1,y1,color='black')
        r=self.holes[5]                                                                             # Αριθμός διατρημάτων οροφής
        for i in range(0,r):                                                                        # Τοποθέτηση διατρημάτων οροφής κατά την απόσταση διατρημάτων οροφής στο κυκλικό τμήμα
            xr = np.linspace(-a1 + x01, a1 + x01,r)
            yr=(self.archHeight * np.sqrt(1 - ((xr-x0) / a) ** 2) + self.abutmentH)
            plt.scatter(xr,yr,color='brown')                                                        # Απεικόνιση
            x2 = self.width/2
            y2=(self.abutmentH+self.archHeight)+0.1
            ax.annotate(self.spacing[1],(x2,y2))                                                    # Τοποθέτηση απόστασης διατρημάτων πάνω από τα διατρήματα οροφής
            
    #WALL HOLES

        xW1=[self.practicalb[6],self.practicalb[6]]                                                 # Συντεταγμένες πρακτικού φορτίου διατρημάτων τοίχου 
        yW1=[0+self.practicalb[4],b1 * np.sqrt(1 - ((self.practicalb[6] - x01) / a1) ** 2) + y01]
        plt.plot(xW1,yW1, color='black')
        xW2=[self.width-self.practicalb[6],self.width-self.practicalb[6]]                           # Οι ίδιες συντεταγμένες , για τον δεξιό τοίχο του μετώπου 
        yW2=[0+self.practicalb[4],b1 * np.sqrt(1 - ((self.practicalb[6] - x01) / a1) ** 2) + y01]
        plt.plot(xW2,yW2,color='black')
        w=self.holes[6]//2                                                                          # Αριθμός διατρημάτων τοίχου δια 2. Για τον κάθε τοίχο δηλαδή 
        for i in range(0,w):
            x1=0
            y1=self.practicalb[4]+(i*self.spacing[2])                                               # Τοποθέτηση διατρημάτων εκατέρωθεν , με την απόσταση διατρημάτων τοίχου 
            x2=self.width
            y2=self.practicalb[4]+(i*self.spacing[2])
            plt.scatter(x1,y1,color='green')
            plt.scatter(x2,y2, color='green')
            for i in range(0,w-1):
                x3=0
                y3=self.practicalb[4]+(i*self.spacing[2])
                x4=self.width
                y4=self.practicalb[4]+(i*self.spacing[2])
                ax.annotate(self.spacing[2],(x3+0.1,y3+(self.spacing[2]/2)))                         # Τοποθέτηση απόστασης ανάμεσα στα διατρήματα
                ax.annotate(self.spacing[2],(self.width-self.practicalb[6]/2,y4+(self.spacing[2]/2)))# Τοποθέτηση απόστασης ανάμεσα στα διατρήματα
     
    #CUT HOLES
        
        if self.abutmentH>=4.5 or self.abutmentH+self.archHeight>=4.5:
            xQ=(0+self.practicalb[6]+self.B[3]/2)                                                       # Συντεταγμένες αρχής cut (τέρμα  αριστερά δίπλα απο το πρακτικό φορτίο του τοίχου)
            yQ=(0+self.practicalb[4]+self.B[3]/2)                                                       # Ορίζεται αρχικό σημείο το κενό διάτρημα που βρίσκεται στο μέσο του cut.
                                                                                                        # Συντεταγμένη ψ υπολογίζεται από το τέλος του πρακτικού φορτίου των lifters και το μισό από την πλευρά του 4ου τετραγώνου
            plt.scatter(xQ,yQ)                                                                          # Συντεταγμένη χ υπολογίζεται από το τέλος του πρακτικού φορτίου του τοίχου και το μισό από την πλευρά του 4ου τετραγώνου

            x1=[xQ-(round(self.B[0],2)*math.cos(0.25*math.pi)),xQ,xQ+(round(self.B[0],2)*math.cos(0.25*math.pi)),xQ,xQ-(round(self.B[0],2)*math.cos(0.25*math.pi))]
            y1=[yQ,yQ+(round(self.B[0],2)*math.sin(0.25*math.pi)),yQ,yQ-(round(self.B[0],2)*math.sin(0.25*math.pi)),yQ] 

            # Με αρχικές συντεταγμένες τα xQ, yQ, υπολογίζονται οι συντεταγμένες του κάθε σημείου του τετραγώνου
            # Ο υπολογισμός γίνεται με τα συνημίτονα και τα ημίτονα των γωνιών και τις αντίστοιχες πλευρές του κάθε τετραγώνου self.B
        
            x2=[(xQ-((round(self.practicalb[1],2)+(round(self.B[0],2)/2))*math.cos(0.25*math.pi))),(xQ-((round(self.practicalb[1],2)+(round(self.B[0],2)/2))*math.cos(0.25*math.pi)))+round(self.B[1],2),(xQ-((round(self.practicalb[1],2)+(round(self.B[0],2)/2))*math.cos(0.25*math.pi)))+round(self.B[1],2),(xQ-((round(self.practicalb[1],2)+(round(self.B[0],2)/2))*math.cos(0.25*math.pi))),(xQ-((round(self.practicalb[1],2)+(round(self.B[0],2)/2))*math.cos(0.25*math.pi)))]
            y2=[(yQ+((round(self.practicalb[1],2)+(round(self.B[0],2)/2))*math.sin(0.25*math.pi))),(yQ+((round(self.practicalb[1],2)+(round(self.B[0],2)/2))*math.sin(0.25*math.pi))),(yQ+((round(self.practicalb[1],2)+(round(self.B[0],2)/2))*math.sin(0.25*math.pi)))-round(self.B[1],2),(yQ+((round(self.practicalb[1],2)+(round(self.B[0],2)/2))*math.sin(0.25*math.pi)))-round(self.B[1],2),(yQ+((round(self.practicalb[1],2)+(round(self.B[0],2)/2))*math.sin(0.25*math.pi)))]

            x3=[xQ-(round(self.practicalb[2],2)+(round(self.B[1],2)/2)),xQ,xQ+(round(self.practicalb[2],2)+(round(self.B[1],2)/2)),xQ,xQ-(round(self.practicalb[2],2)+(round(self.B[1],2)/2))]
            y3=[yQ,yQ+(round(self.practicalb[2],2)+(round(self.B[1],2)/2)),yQ,yQ-(round(self.practicalb[2],2)+(round(self.B[1],2)/2)),yQ]


            x4=[(xQ-((round(self.practicalb[3],2)+(round(self.B[2],2)/2))*math.cos(0.25*math.pi))),(xQ-((round(self.practicalb[3],2)+(round(self.B[2],2)/2))*math.cos(0.25*math.pi)))+round(self.B[3],2),(xQ-((round(self.practicalb[3],2)+(round(self.B[2],2)/2))*math.cos(0.25*math.pi)))+round(self.B[3],2),(xQ-((round(self.practicalb[3],2)+(round(self.B[2],2)/2))*math.cos(0.25*math.pi))),(xQ-((round(self.practicalb[3],2)+(round(self.B[2],2)/2))*math.cos(0.25*math.pi)))]
            y4=[(yQ+((round(self.practicalb[3],2)+(round(self.B[2],2)/2))*math.sin(0.25*math.pi))),(yQ+((round(self.practicalb[3],2)+(round(self.B[2],2)/2))*math.sin(0.25*math.pi))),(yQ+((round(self.practicalb[3],2)+(round(self.B[2],2)/2))*math.sin(0.25*math.pi)))-round(self.B[3],2),(yQ+((round(self.practicalb[3],2)+(round(self.B[2],2)/2))*math.sin(0.25*math.pi)))-round(self.B[3],2),(yQ+((round(self.practicalb[3],2)+(round(self.B[2],2)/2))*math.sin(0.25*math.pi)))]

            plt.scatter(x1,y1,color='olive')
            plt.scatter(x2,y2,color='olive')
            plt.scatter(x3,y3,color='olive')
            plt.scatter(x4,y4,color='olive')
            plt.plot(x1,y1,color='black')                                                               # Δημιουργία ευθειών ανάμεσα στα διατρήματα για την απεικόνιση τετραγώνων!!!
            plt.plot(x2,y2,color='black')
            plt.plot(x3,y3,color='black')
            plt.plot(x4,y4,color='black')
            ax.annotate(self.B[2],(xQ-(x3[3]-x3[2]/2),y3[4]-y3[3]/2))
            ax.annotate(self.B[3],(x4[0]+self.B[3]/2,y4[0]))                                            # ΄Οπου annotate, η απεικόνιση της πλευράς του κάθε τετραγώνου!!!
            ax.annotate(self.B[1],(xQ,yQ+self.B[1]/2))
            ax.annotate(self.B[0],(xQ-(x1[2]-x1[1]),yQ-(y1[1]-y1[2])))
            ax.annotate(self.emptyf,(xQ,yQ),color='blue')

        else:
            xQ=(0+self.practicalb[6]+self.B[2]/2)                                                       # Συντεταγμένες αρχής cut (τέρμα  αριστερά δίπλα απο το πρακτικό φορτίο του τοίχου)
            yQ=(0+self.practicalb[4]+self.B[2]/2)                                                       # Ορίζεται αρχικό σημείο το κενό διάτρημα που βρίσκεται στο μέσο του cut.
            x1=[(xQ-((round(self.practicalb[0],2))*math.cos(0.25*math.pi))),(xQ-((round(self.practicalb[0],2))*math.cos(0.25*math.pi)))+round(self.B[0],2),(xQ-((round(self.practicalb[0],2))*math.cos(0.25*math.pi)))+round(self.B[0],2),(xQ-((round(self.practicalb[0],2))*math.cos(0.25*math.pi))),(xQ-((round(self.practicalb[0],2))*math.cos(0.25*math.pi)))]
            y1=[(yQ+((round(self.practicalb[0],2))*math.sin(0.25*math.pi))),(yQ+((round(self.practicalb[0],2))*math.sin(0.25*math.pi))),(yQ+((round(self.practicalb[0],2))*math.sin(0.25*math.pi)))-round(self.B[0],2),(yQ+((round(self.practicalb[0],2))*math.sin(0.25*math.pi)))-round(self.B[0],2),(yQ+((round(self.practicalb[0],2))*math.sin(0.25*math.pi)))]

            x2=[xQ-(round(self.B[1],2)*math.cos(0.25*math.pi)),xQ,xQ+(round(self.B[1],2)*math.cos(0.25*math.pi)),xQ,xQ-(round(self.B[1],2)*math.cos(0.25*math.pi))]
            y2=[yQ,yQ+(round(self.B[1],2)*math.sin(0.25*math.pi)),yQ,yQ-(round(self.B[1],2)*math.sin(0.25*math.pi)),yQ]
            
            x3=[(xQ-((round(self.practicalb[2],2)+(round(self.B[1],2)/2))*math.cos(0.25*math.pi))),(xQ-((round(self.practicalb[2],2)+(round(self.B[1],2)/2))*math.cos(0.25*math.pi)))+round(self.B[2],2),(xQ-((round(self.practicalb[2],2)+(round(self.B[1],2)/2))*math.cos(0.25*math.pi)))+round(self.B[2],2),(xQ-((round(self.practicalb[2],2)+(round(self.B[1],2)/2))*math.cos(0.25*math.pi))),(xQ-((round(self.practicalb[2],2)+(round(self.B[1],2)/2))*math.cos(0.25*math.pi)))]
            y3=[(yQ+((round(self.practicalb[2],2)+(round(self.B[1],2)/2))*math.sin(0.25*math.pi))),(yQ+((round(self.practicalb[2],2)+(round(self.B[1],2)/2))*math.sin(0.25*math.pi))),(yQ+((round(self.practicalb[2],2)+(round(self.B[1],2)/2))*math.sin(0.25*math.pi)))-round(self.B[2],2),(yQ+((round(self.practicalb[2],2)+(round(self.B[1],2)/2))*math.sin(0.25*math.pi)))-round(self.B[2],2),(yQ+((round(self.practicalb[2],2)+(round(self.B[1],2)/2))*math.sin(0.25*math.pi)))]

            plt.scatter(x1,y1,color='olive')
            plt.scatter(x2,y2,color='olive')
            plt.scatter(x3,y3,color='olive')
            plt.scatter(xQ,yQ)
            plt.plot(x1,y1,color='black')                                                               # Δημιουργία ευθειών ανάμεσα στα διατρήματα για την απεικόνιση τετραγώνων!!!
            plt.plot(x2,y2,color='black')
            plt.plot(x3,y3,color='black')
            ax.annotate(self.B[2],(xQ,yQ+self.B[2]/2))                                                  # ΄Οπου annotate, η απεικόνιση της πλευράς του κάθε τετραγώνου!!!
            ax.annotate(self.B[1],(xQ,yQ+self.B[1]/2))
            ax.annotate(self.B[0],(xQ-(x1[2]-x1[1]),yQ-(y1[1]-y1[2])))
            ax.annotate(self.emptyf,(xQ,yQ),color='blue')                                               # Απεικόνιση διαμέτρου αρχικού κενού διατρήματος
            
    #STOPING HOLES

        xS=0+self.practicalb[6]+self.B[3]                                                               # Αρχικές συντεταγμένες για τα διατρήματα διεύρυνσης , στο πάνω δεξιά άκρο του 4ου τετραγώνου του cut
        yS=0+self.practicalb[4]+self.B[3]       
        c1=self.No_columns[0]                                                                           # Αριθμός στηλών οριζοντίων διατρημάτων
        r1=self.No_rows[0]                                                                              # Αριθμός σειρών οριζοντίων διατρημάτων
        for i in range(0,c1):
            xh=xS+((i+1)*self.spacing_columns[0])                                                       # Συντεταγμένες κάθε στήλης οριζοντίων διατρημάτων
            yh=yS
            plt.scatter(xh,yh,color='red')
            for z in range(0,r1):                                                                       # Συντεταγμένες κάθε σειράς οριζοντίων διατρημάτων
                xh1=xh
                yh1=yS-((z)*self.spacing_rows[0])
                plt.scatter(xh1,yh1,color='red')
            plt.scatter(xh,yh,color='red')
        for i in range(0,c1):                                                                           # Απεικόνιση αποστάσεων γραμμών/στηλών οριζοντίων διατρημάτων
            x1=xS+(i*self.practicalb[7])
            y1=yS
            if i==0:
                ax.annotate(self.spacing_columns[0],(x1+self.spacing_columns[0]/2,y1),color='blue')
        for z in range(0,r1-1):
            x2=xS+c1*self.spacing_columns[0]
            y2=yS-z*(self.spacing_rows[0])
            if z==0:
                ax.annotate(self.spacing_rows[0],(x2,y1-self.spacing_rows[0]/2),color='black')
        xS1=0+self.practicalb[6]                                                                        # Αρχικές συντεταγμένες για τα κάθετα διατρήματα διεύρυνσης, το πάνω αριστερό άκρο του 4ου τετραγώνου του cut
        yS1=0+self.practicalb[4]+self.B[3]       
        r2=self.spacing_columns[1]
        c2=self.cols_downwards[0]
        for i in range(0,c2):
            XS=xS1+(i*r2)
            YS=0+self.practicalb[4]+self.B[3]
            a3= self.width/2
            b3 =(self.abutmentH+self.archHeight)-(self.abutmentH-self.practicalb[5])-self.practicalb[5] 
            x03 =self.width/2
            y03 =self.abutmentH-self.practicalb[5]
            x3 = XS
            y3 = b3 * np.sqrt(1 - ((x3-x03) / a3) ** 2) + y03
            d=int((y3-YS)/(self.practicalb[8]))
            for i in range(0,c2-1):
                x4=0+self.practicalb[6]+(i*self.spacing_columns[1])
                y4=0+self.practicalb[4]+self.B[3]
                if i==0:
                    ax.annotate(self.spacing_columns[1],(x4+self.spacing_columns[1]/2,y4+self.practicalb[8]+0.1),color='black')
                    x6=0+self.practicalb[6]
                    y6=0+self.practicalb[4]+self.B[3]
                    ax.annotate(self.practicalb[8],(x6,y6+(self.practicalb[8]/2)),color='blue')
                if d==1 and d*self.practicalb[8]>=y3-YS-0.1:
                    XS1=XS
                    YS1=y3
                    plt.scatter(XS1,YS1,color="red")                                       
                else:
                    for p in range(0,d):
                        XS1=XS
                        YS1=YS+((p+1)*self.practicalb[8])
                        plt.scatter(XS1,YS1,color='red')
                        x6=0+self.practicalb[6]
                        y6=0+self.practicalb[4]+self.B[3]
            if d*self.practicalb[8]<y3-YS-0.3:
                XS2=XS
                YS2=y3
                plt.scatter(XS2,YS2,color='red')
        plt.show()
        
    
# Το πρακτικό φορτίο οροφής είναι της μορφής καμπύλης, επομένως ο κώδικας πρέπει να διακρίνει την απόσταση μεταξύ του κάθε σημείου της καμπύλης με το αντίστοιχο του τετραγώνου προεκσκαφης και να υπολογίζει με ακρίβεια τα διατρήματα και τις αποστάσεις τους.

# Για παράδειγμα, το τμήμα πάνω από το τετράγωνο προεκσκαφής ίσως απαιτεί λιγότερα διατρήματα σε σχέση με το κεντρικό τμήμα της διάτρησης. Γιατί εκεί η καμπύλη πρακτικού φορτίου της οροφής είναι πιο χαμηλά

#ΕΚΚΙΝΗΣΗ ΚΩΔΙΚΑ

import json
import math                                                                                         # Ακολουθούν οι βιβλιοθήκες που απαιτώνται 
import matplotlib.pyplot as plt
from matplotlib.patches import Rectangle
import numpy as np
import pandas as pd
from tabulate import tabulate
import random
secure_random = random.SystemRandom()                                                               #για να μη βγάζει ψευδοτυχαίους
from scipy.optimize import curve_fit                                                                #για την καμπύλη της οροφής

explosives = Blaster()                                                                              # Ο όρος explosives «διαβάζει» την κλάση Blaster()του προγράμματος


with open("config.json" , 'r') as f:                                                                # Αρχείο .json, καταχώρηση σταθερών τιμών 
            json_str = f.read()
            json_value = json.loads(json_str)         
            explosives.name = json_value["name"]                                                    # Αντιστοίχιση στοιχείων του προγράμματος με τις τιμές που δηλώνονται στο .json
            explosives.hdiam =json_value["geometry"]["hdiam"]
            explosives.emptyf =json_value["geometry"]["emptyf"]
            explosives.width =json_value["geometry"]["width"]
            explosives.abutmentH =json_value["geometry"]["abutmentH"]
            explosives.archHeight =json_value["geometry"]["archHeight"]
            explosives.g =json_value["geometry"]["g"]
            explosives.a =json_value["geometry"]["a"]
            explosives.b =json_value["geometry"]["b"]
            explosives.Q =json_value["geometry"]["Q"]
            explosives.V =json_value["geometry"]["V"]
            explosives.Density =json_value["geometry"]["Density"]
            explosives.c =json_value["geometry"]["c"]
            for x in json_value["cartridges"]:
                explosives.addcartridge(x["name"], x["diameter"], x["length"])                      # Για κάθε φυσίγγιο καταγραφή ονόματος, διαμέτρου, μήκους
            explosives.charge_concentration()
            explosives.calculation()
            explosives.first_quadrangle()
            explosives.second_quadrangle()                                                          # Για να «τρέξει» τις διάφορες συναρτήσεις def() του προγράμματος. 
            explosives.third_quadrangle()
            explosives.fourth_quadrangle()
            explosives.lifters()
            explosives.roof()
            explosives.wall()
            explosives.stoping()
            explosives.sum()
            explosives.table1()
            explosives.table2()
            #explosives.case_study2()                                                               # Παράδειγμα τετραγωνικής στοάς - Αποτελέσματα
            explosives.plot()