#DM2 - hue11 - PARCO DORA, TURINO - final submission
#Gruppe Hirschberg 3
#Raphael Wieser - Stand: 16.03.2025

###############################################################################
#general setup
###############################################################################

import rhinoscriptsyntax as rs
import random as ran
import fantastic_stairs_lib as fs
import flipped_classroom_lib as fc

rs.DeleteObjects(rs.AllObjects())

rs.EnableRedraw(0)  #disables the live view of the code execution

###############################################################################
#INPUT RASTER
###############################################################################

A=3         #numberofcolumns in x-direction #testet up to 5
            #A needs to be a minimum of 2
B=10        #numberofcolumns in y-direction #testet up to 10
rastery=15  #spacebetween columns in x
rasterx=35   #spacebetween columns in y

###############################################################################
#INPUT COLUMN 
###############################################################################

xcol = 2            #length column in x
ycol = 0.4          #length column in y
zcol = 17           #hlength column in z
tsheet = 0.04       #thickness of columns steel sheets
hbase = tsheet*2    #thickness of columns sbaseplate
#numberofbulks 
#have to be full numbers
xbulk=2             #number of bulk metal sheets in x-direction
#PROVISORIUM #bulk=zcol/0.4      #number of bulk metal sheets in z-direction 

###############################################################################
#INPUT PRIMARY TRUSS & ROOFING
###############################################################################

spann=rasterx
trusstype=2     #trusstype "1" or "2"
                #type 1 - rectangular truss
                #type 2 - truss with triangular top
fieldsx=6       #subdivisions of truss - need to be multiple of 2
fieldsy=4       #numberoftrusses in y-direction #testedupto5
factor_h=1.5    #only for type 2 - factor for heightening the middle of the truss
beamx=0.4       #max width of beam part
beamz=0.4       #max thickness of beam part
coveringz=0.15  #thickness of roof covering

###############################################################################
#INPUT SECONDARY TRUSS & ROOFING
###############################################################################

spann2=rastery
fieldsx2=4   #subdivisions of truss
             #ATTENTION! need to be multiple of 2
beamx2=0.3   #max width of beam part
beamz2=0.2   #max thickness of beam part
hmin2=spann2/fieldsx*1.5

###############################################################################
#INPUT FOUNDATIONPLATE
###############################################################################

h_fdtplate=0.5
h_fdtreinf=1.5

###############################################################################
#TRUSS DERIVED VALUES
hmin=spann/12   #minimumheight of truss
if fieldsx%2==0:
    xdiv=fieldsx   #divide by even number in x-direction
else:
    print "ERROR please insert a number divideable by 2 as fieldsx)"
    exit()
hmin=round(hmin,1)  #round up to 1 decimal

print "A", A, "rasterx", rasterx, "m"
print "B", B, "rastery", rastery, "m"
print "spann", spann  #DEBUG
print "hmin", hmin
print "trusstype", trusstype

###############################################################################
#PROGRAMM EXECUTION
###############################################################################

    #####################################################################
    #CREATE COLUMNS
    #####################################################################


#define functions
def make_box(insertion=[0,0,0], xsize=10, ysize=10, zsize=10): 
    #by giving default values in the bracket when definening the func instead of
    #lower down you can only give the first value when executing the func
    
    #setup corners list
    corners = [ [0,0,0],[xsize,0,0],[xsize,ysize,0],[0,ysize,0],
            [0,0,zsize],[xsize,0,zsize],[xsize,ysize,zsize],[0,ysize,zsize] ]
    box=rs.AddBox(corners)
    rs.MoveObject(box, (-xsize/2,-ysize/2,0))   #moves object to center of insert point
    rs.MoveObject(box, insertion)
    return box

#####################################################################

l_column=[]   #create empty list

#generate vertical sheetmetal
#mainsheetvertical +x
cord1=[(-xcol/2),0,hbase]
side1=make_box(cord1, xsize=tsheet, ysize=ycol, zsize=zcol)
l_column.append(side1)


#mainsheetvertical -x
cord2=[(+xcol/2),0,(hbase)]
side2=make_box(cord2, xsize=tsheet, ysize=ycol, zsize=zcol)
l_column.append(side2)

#generate vertical bulks
for i in range(xbulk):
    cord3=[-xcol/2+xcol/xbulk*i,0,hbase]
    mid1=make_box(cord3, xsize=tsheet/2, ysize=ycol-(ycol*2/10), zsize=zcol)
    l_column.append(mid1)


#generate vertical centersheet
cord4=[0,0,(hbase)]
cent1=make_box(cord4,xsize=xcol, ysize=tsheet, zsize=zcol)
l_column.append(cent1)

#generate horizontal sheetmetal
#generate baseplate
basepl=make_box(xsize=xcol+xcol*2/10, ysize=ycol+ycol*2/10, zsize=hbase)
l_column.append(basepl)

#generate horizontal bulk
for i in range(zcol*2-1):
    stepheight=zcol/(zcol*2)
    cord4=[0, 0, hbase+stepheight*(1+i)]
    bulk=make_box(cord4, xsize=xcol-tsheet, ysize=ycol, zsize=tsheet)
    l_column.append(bulk)

#generate topplate
cord5=[0,0,(hbase+zcol)]
toppl=make_box(cord5,xsize=xcol+tsheet, ysize=ycol, zsize=tsheet)
l_column.append(toppl)

column1=rs.BooleanUnion(l_column,True)

#copy columns
columnrowy=[]
for i in range(A):
    columnrowy.append(   rs.CopyObject(column1,(rasterx*i,0,0))   )
    
for i in range(B):
    rs.CopyObject(columnrowy,(0,rastery*i,0))


#####################################################################
#CREATE TRUSSES
#####################################################################
#setup vectors for rotating objects
vecx=rs.VectorAdd((0,0,0),(1,0,0))
vecy=rs.VectorAdd((0,0,0),(0,1,0))
vecz=rs.VectorAdd((0,0,0),(0,0,1))

#################################################################### TYPE2

if trusstype==1:
    ### GEOMETRY INPUT###
    quad = [[0,0,0],[spann,0,0],[spann,0,hmin],[0,0,hmin]]
    P0,P1,P2,P3 = rs.AddPoints(quad)
    L0=rs.AddLine(P0,P1)
    L1=rs.AddLine(P1,P2)
    L2=rs.AddLine(P3,P2)
    L3=rs.AddLine(P0,P3)
    
    #####################################################################
    #define functions
    def make_beam(dimy, dimz, path,insertion = (0,0,0),rotation=0,axis=None):
        beamoutline=rs.AddPolyline( ([0,0,0], [0,dimy,0], [0,dimy,dimz], [0,0,dimz],[0,0,0]))
        rs.MoveObject(beamoutline,insertion)
        rs.MoveObject(beamoutline,(0,-dimy/2,-dimz/2))
        beam=rs.ExtrudeCurve(beamoutline,path)
        rs.CapPlanarHoles(beam)
        rs.RotateObject(beam,insertion,rotation,axis)
        rs.DeleteObject(beamoutline)
        return(beam)
        #end
    
    def make_vbeam(dimy, dimz, path,insertion = (0,0,0),rotation=0,axis1=-vecy,axis2=-vecz):
        beamoutline=rs.AddPolyline( ([0,0,0], [0,dimy,0], [0,dimy,dimz], [0,0,dimz],[0,0,0]))
        rs.MoveObject(beamoutline,insertion)
        rs.MoveObject(beamoutline,(0,-dimy/2,-dimz/2))
        rs.RotateObject(beamoutline,insertion,rotation,axis1)
        rs.RotateObject(beamoutline,insertion,rotation,axis2)
        beam=rs.ExtrudeCurve(beamoutline,path)
        rs.CapPlanarHoles(beam)
        rs.DeleteObject(beamoutline)
        return(beam)
        #end
    #####################################################################
    
    l_truss=[]   #create empty list
    
    #create truss
    untergurt = make_beam(beamx,beamz/2,L0,P0)
    l_truss.append(untergurt)
    obergurt = make_beam(beamx,beamz,L2,P3)
    l_truss.append(obergurt)
    
    #createoutermost vertical
    vertikalgurt=make_vbeam(beamx/2,beamx, L3, P0, 90,)
    l_truss.append(vertikalgurt)
    rs.MoveObject(vertikalgurt,(beamx/2/2,0,0))
    vertikalgurt=make_vbeam(beamx/2,beamx, L3, P1, 90,)
    l_truss.append(vertikalgurt)
    rs.MoveObject(vertikalgurt,(-beamx/2/2,0,0))
    
    #create other verticals
    for i in range(xdiv-1):
        vertikalgurt=make_vbeam(beamx/4,beamx, L3, P0, 90,)
        l_truss.append(vertikalgurt)
        #rs.MoveObject(vertikalgurt,(beamx/4,0))
        vdist=spann/xdiv
        rs.MoveObject(vertikalgurt,(vdist+vdist*i,0,0))
    #
    ##create diagonals
    #    diagonals=[]   #create empty list for diagonals
    #for i in range(xdiv):
    #    Upoints=rs.DivideCurve(L0,xdiv)
    #    Opoints=rs.DivideCurve(L2,xdiv)
    #    pipeline=diagonalline=rs.AddLine(Upoints[i],Opoints[i+1])
    #    pipe=rs.AddPipe(pipeline,0,beamz/10,cap=1)
    #    rs.MoveObject(pipe,(0,-beamz/20,0))
    #    diagonals.append(pipe)
    
    
    #create diagonals
        diagonals=[]   #create empty list for diagonals
        Upoints=rs.DivideCurve(L0,xdiv)
        Opoints=rs.DivideCurve(L2,xdiv)
    
    i=0
    while i<xdiv/2:
        pipeline=rs.AddLine(Upoints[i],Opoints[i+1])
        pipe=rs.AddPipe(pipeline,0,beamz/10,cap=1)
        l_truss.append(pipe)
        rs.MoveObject(pipe,(0,-beamz/20,0))
        diagonals.append(pipe)
        rs.DeleteObject(pipeline)
        i=i+1
        
    i=0
    while i<xdiv/2:
        pipeline=rs.AddLine(Upoints[i],Opoints[i+1])
        pipe=rs.AddPipe(pipeline,0,beamz/10,cap=1)
        l_truss.append(pipe)
        movepipe=rs.VectorSubtract(Upoints[i],Opoints[i+1])
        rs.RotateObject(pipe,Upoints[i],180,vecz)
        rs.MoveObject(pipe,((spann/xdiv)+spann/2,0,0))
        rs.MoveObject(pipe,(0,-beamz/20,0))
        diagonals.append(pipe)
        rs.DeleteObject(pipeline)
        i=i+1
        
    
    
    truss1=rs.BooleanUnion(l_truss,True)
    rs.MoveObjects(truss1,(0,0,zcol+beamz/2))
    
    trussrowy=[]
    for i in range(B*fieldsy-(fieldsy-1)):
        trussrowy.append(rs.CopyObject(truss1,(0,rastery*i/fieldsy,0)))
    
    for i in range(A-1):
        rs.CopyObject(trussrowy,(rasterx*i,0,0))

    l_covering=[]
    #create roof covering
    coveringy = rastery*(B-1)+1
    covering = make_beam(coveringy ,coveringz,L2,P3)
    l_covering.append(covering)
    rs.MoveObjects(l_covering,(0,coveringy/2-0.5,zcol+beamz))

    for i in range(A-1):
        rs.CopyObject(l_covering,(rasterx*i,0,0))

    rs.DeleteObject(pipeline)
    rs.DeleteObject(L0)
    rs.DeleteObject(L1)
    rs.DeleteObject(L2)
    rs.DeleteObject(L3)
    rs.DeleteObject(P0)
    rs.DeleteObject(P1)
    rs.DeleteObject(P2)
    rs.DeleteObject(P3)
    #ENDOFTRUSSFUNCTION

#################################################################### TYPE2
if trusstype==2:
    ### GEOMETRY INPUT###
    
    #start      middle          end         end up      middle up          start up
    quint = [[0,0,0],[spann/2,0,0],[spann,0,0],[spann,0,hmin],[spann/2,0,hmin*factor_h],[0,0,hmin]]
    
    P0,P1,P2,P3,P4,P5 = rs.AddPoints(quint)
    #always arrange poinst left to right and down to up
    L0=rs.AddLine(P0,P1) #low left
    L1=rs.AddLine(P1,P2) #low right
    L2=rs.AddLine(P2,P3) #right
    L3=rs.AddLine(P4,P3) #vertical right
    L4=rs.AddLine(P5,P4) #up left
    L5=rs.AddLine(P0,P5) #vertical left

    #####################################################################
    #DEFINE FUNCTIONS
    #####################################################################
    def make_beam(dimy, dimz, path,insertion = (0,0,0),rotation=0,axis=None):
        beamoutline=rs.AddPolyline( ([0,0,0], [0,dimy,0], [0,dimy,dimz], [0,0,dimz],[0,0,0]))
        rs.MoveObject(beamoutline,insertion)
        rs.MoveObject(beamoutline,(0,-dimy/2,-dimz/2))
        beam=rs.ExtrudeCurve(beamoutline,path)
        rs.CapPlanarHoles(beam)
        rs.RotateObject(beam,insertion,rotation,axis)
        rs.DeleteObject(beamoutline)
        return(beam)
        #end
    
    def make_vbeam(dimy, dimz, path,insertion = (0,0,0),rotation=0,axis1=-vecy,axis2=-vecz):
        beamoutline=rs.AddPolyline( ([0,0,0], [0,dimy,0], [0,dimy,dimz], [0,0,dimz],[0,0,0]))
        rs.MoveObject(beamoutline,insertion)
        rs.MoveObject(beamoutline,(0,-dimy/2,-dimz/2))
        rs.RotateObject(beamoutline,insertion,rotation,axis1)
        rs.RotateObject(beamoutline,insertion,rotation,axis2)
        beam=rs.ExtrudeCurve(beamoutline,path)
        rs.CapPlanarHoles(beam)
        rs.DeleteObject(beamoutline)
        return(beam)
        #end
    #####################################################################
    
    l_truss=[]   #create empty list
    
    #create truss
    untergurt = make_beam(beamx,beamz/2,L0,P0)
    l_truss.append(untergurt)
    untergurt = make_beam(beamx,beamz/2,L1,P1)
    l_truss.append(untergurt)
    obergurt = make_beam(beamx,beamz,L3,P4)
    l_truss.append(obergurt)
    obergurt = make_beam(beamx,beamz,L4,P5)
    l_truss.append(obergurt)
    
    #createoutermost vertical
    vertikalgurt=make_vbeam(beamx/2,beamx, L5, P0, 90,)
    l_truss.append(vertikalgurt)
    rs.MoveObject(vertikalgurt,(beamx/2/2,0,0))
    vertikalgurt=make_vbeam(beamx/2,beamx, L2, P2, 90,)
    l_truss.append(vertikalgurt)
    rs.MoveObject(vertikalgurt,(-beamx/2/2,0,0))

    #create diagonals
    diagonals=[]
    Upoints=[]
    Opoints=[]
    #create empty list for diagonals
    UpointsL=rs.DivideCurve(L0,xdiv/2)
    OpointsL=rs.DivideCurve(L4,xdiv/2)
    UpointsR=rs.DivideCurve(L1,xdiv/2)
    OpointsR=rs.DivideCurve(L3,xdiv/2)
    
    i=0
    while i<xdiv/2:
        pipelineL=rs.AddLine(UpointsL[i],OpointsL[i+1])
        pipelineR=rs.RotateObject(rs.AddLine(OpointsR[i+1],UpointsR[i],),UpointsR[i],180,vecz)
        rs.MoveObject(pipelineR,(spann/xdiv,0,0))
        rs.MoveObject(pipelineR,(-beamx/4,0,0))
        pipe=rs.AddPipe(pipelineL,0,beamz/10,cap=1)
        l_truss.append(pipe)
        pipe=rs.AddPipe(pipelineR,0,beamz/10,cap=1)
        l_truss.append(pipe)
        rs.DeleteObject(pipelineL)
        rs.DeleteObject(pipelineR)
        i=i+1

    #create other verticals
    i=0
    while i<xdiv/2:
        verticalL=rs.AddLine(UpointsL[i],OpointsL[i])
        verticalR=rs.AddLine(UpointsR[i],OpointsR[i])
        pipe=rs.AddPipe(verticalL,0,beamz/4,cap=1)
        l_truss.append(pipe)
        rs.MoveObject(pipe,(beamz/2,0,0))
        pipe=rs.AddPipe(verticalR,0,beamz/4,cap=1)
        l_truss.append(pipe)
        rs.MoveObject(pipe,(-beamz/2,0,0))
        rs.DeleteObject(verticalL)
        rs.DeleteObject(verticalR)
        i=i+1
    
    truss1=rs.BooleanUnion(l_truss,True)
    rs.MoveObjects(truss1,(0,0,zcol+beamz/2))
    
    trussrowy=[]
    for i in range(B*fieldsy-(fieldsy-1)):
        trussrowy.append(rs.CopyObject(truss1,(0,rastery*i/fieldsy,0)))
    
    for i in range(A-1):
        rs.CopyObject(trussrowy,(rasterx*i,0,0))

    l_covering=[]
    #create roof covering
    #coveringz
    coveringy = rastery*(B-1)+1
    coveringR = make_beam(coveringy ,coveringz,L3,P4)
    l_covering.append(coveringR)
    coveringL = make_beam(coveringy,coveringz,L4,P5)
    l_covering.append(coveringL)
    rs.MoveObjects(l_covering,(0,coveringy/2-0.5,zcol+beamz))
    covering1=rs.BooleanUnion(l_covering,True)

    for i in range(A-1):
        rs.CopyObject(covering1,(rasterx*i,0,0))

    rs.DeleteObject(L0)
    rs.DeleteObject(L1)
    rs.DeleteObject(L2)
    rs.DeleteObject(L3)
    rs.DeleteObject(L4)
    rs.DeleteObject(L5)
    rs.DeleteObject(P0)
    rs.DeleteObject(P1)
    rs.DeleteObject(P2)
    rs.DeleteObject(P3)
    rs.DeleteObject(P4)
    rs.DeleteObject(P5)
    #ENDOFTRUSSFUNCTION

#####################################################################
#####################################################################
#CREATE SECONDARY TRUSS 
#####################################################################

if True:
    ### GEOMETRY INPUT###
    quad = [[0,0,0],[spann2,0,0],[spann2,0,hmin2],[0,0,hmin2]]
    P0,P1,P2,P3 = rs.AddPoints(quad)
    L0=rs.AddLine(P0,P1)
    L1=rs.AddLine(P1,P2)
    L2=rs.AddLine(P3,P2)
    L3=rs.AddLine(P0,P3)
    
    #####################################################################
    #define functions
    def make_beam(dimy, dimz, path,insertion = (0,0,0),rotation=0,axis=None):
        beamoutline=rs.AddPolyline( ([0,0,0], [0,dimy,0], [0,dimy,dimz], [0,0,dimz],[0,0,0]))
        rs.MoveObject(beamoutline,insertion)
        rs.MoveObject(beamoutline,(0,-dimy/2,-dimz/2))
        beam=rs.ExtrudeCurve(beamoutline,path)
        rs.CapPlanarHoles(beam)
        rs.RotateObject(beam,insertion,rotation,axis)
        rs.DeleteObject(beamoutline)
        return(beam)
        #end
    
    def make_vbeam(dimy, dimz, path,insertion = (0,0,0),rotation=0,axis1=-vecy,axis2=-vecz):
        beamoutline=rs.AddPolyline( ([0,0,0], [0,dimy,0], [0,dimy,dimz], [0,0,dimz],[0,0,0]))
        rs.MoveObject(beamoutline,insertion)
        rs.MoveObject(beamoutline,(0,-dimy/2,-dimz/2))
        rs.RotateObject(beamoutline,insertion,rotation,axis1)
        rs.RotateObject(beamoutline,insertion,rotation,axis2)
        beam=rs.ExtrudeCurve(beamoutline,path)
        rs.CapPlanarHoles(beam)
        rs.DeleteObject(beamoutline)
        return(beam)
        #end
    #####################################################################
    
    l_truss2=[]   #create empty list
    
    #create truss
    untergurt = make_beam(beamx2,beamz2/2,L0,P0)
    l_truss2.append(untergurt)
    obergurt = make_beam(beamx2,beamz2/2,L2,P3)
    l_truss2.append(obergurt)
    
#    #createoutermost vertical
#    vertikalgurt=make_vbeam(beamx2/2,beamx2, L3, P0, 90,)
#    l_truss2.append(vertikalgurt)
#    rs.MoveObject(vertikalgurt,(beamx2/2/2,0,0))
#    vertikalgurt=make_vbeam(beamx2/2,beamx2, L3, P1, 90,)
#    l_truss2.append(vertikalgurt)
#    rs.MoveObject(vertikalgurt,(-beamx2/2/2,0,0))
    
    #create other verticals
    for i in range(fieldsx2-1):
        vertikalgurt=make_vbeam(beamx2/4,beamx2, L3, P0, 90,)
        l_truss2.append(vertikalgurt)
        vdist=spann2/fieldsx2
        rs.MoveObject(vertikalgurt,(vdist+vdist*i,0,0))

    #create diagonals
        diagonals=[]   #create empty list for diagonals
        Upoints=rs.DivideCurve(L0,fieldsx2)
        Opoints=rs.DivideCurve(L2,fieldsx2)
    
    i=0
    while i<fieldsx2/2:
        pipeline=rs.AddLine(Upoints[i],Opoints[i+1])
        pipe=rs.AddPipe(pipeline,0,beamz2/8,cap=1)
        l_truss2.append(pipe)
        rs.MoveObject(pipe,(0,-beamz2/20,0))
        diagonals.append(pipe)
        rs.DeleteObject(pipeline)
        i=i+1
        
    i=0
    while i<fieldsx2/2:
        pipeline=rs.AddLine(Upoints[i],Opoints[i+1])
        pipe=rs.AddPipe(pipeline,0,beamz2/8,cap=1)
        l_truss2.append(pipe)
        movepipe=rs.VectorSubtract(Upoints[i],Opoints[i+1])
        rs.RotateObject(pipe,Upoints[i],180,vecz)
        rs.MoveObject(pipe,((spann2/fieldsx2)+spann2/2,0,0))
        rs.MoveObject(pipe,(0,-beamz2/20,0))
        diagonals.append(pipe)
        rs.DeleteObject(pipeline)
        i=i+1

#create doubled trusses
    l_truss3=[]
    truss3=rs.BooleanUnion(l_truss2,True)
    rs.MoveObjects(truss3,(0,0,zcol+beamz/2-hmin2))
    rs.RotateObject(truss3,(0,0,0),90)
    rs.MoveObjects(truss3,(-xcol/2+beamx2/2,0,0))
    #copy truss and move it to make it a double truss
    truss4=rs.CopyObject(truss3,(xcol/2-beamx2/2,0,0))
    l_truss3.append(truss3)
    l_truss3.append(truss4)
    
    #copy the double truss and move it to the outermost position in y-direction
    for i in range(B-1):
        rs.CopyObject(l_truss3,(rasterx*(A-1)+xcol/2-beamx2/2,rastery*i,0))

    #copy the double truss to the other positions in y-direction
    for i in range(A-1):
        for j in range(B-1):
            rs.CopyObject(l_truss3,(rasterx*i+((xcol/2-beamx2/2)/2), rastery*j ,0))


#BUGGED SCRIPT - ONLY PARTS OF THE TRUSS ARE COPIED - KEPT FOR COORDINATE TRANSFORMATION VALUES

#    l_truss3.append(truss3)
#    truss3=rs.CopyObject(truss3,(xcol/2-beamx2/2,0,0))
#    l_truss3.append(truss3)
#
#    l_truss4=[]
#    for i in range (B-1):
#        truss3=rs.CopyObject(l_truss3,(0,rastery*(i),0))
#        l_truss4.append(truss3)
#
##create furthest truss in x-direction
#    rs.CopyObjects(l_truss3,(rasterx*(A-1)+xcol/2-beamx2/2,0,0))
#    rs.CopyObjects(l_truss4,(rasterx*(A-1)+xcol/2-beamx2/2,0,0))

##create other trusses x-direction
#    for i in range (B-1):
#        rs.CopyObjects(l_truss3,(rasterx*(i)+((xcol/2-beamx2/2)/2,0,0)))
#        rs.CopyObjects(l_truss4,(rasterx*(i)+((xcol/2-beamx2/2)/2,0,0)))


#        truss3=rs.CopyObject(l_trussend,(0,,0))


#    truss4=rs.CopyObject(l_truss3,(rasterx*(A-1)+xcol/2-beamx2/2,0,0))
#    l_truss4.append(truss4)

##create other secondary truss
#    l_truss5=[]
#    for i in range (A):
#        truss5=rs.CopyObject(l_truss3,((rasterx*(i)+((xcol/2-beamx2/2)/2)),0,0))
#        l_truss5.append(truss5)

#    for i in range (B-1):
#        rs.CopyObject(l_truss3,(0,rastery*(i),0))
#        rs.CopyObject(l_truss4,(0,rastery*(i),0))
#        rs.CopyObject(l_truss5,(0,rastery*(i),0))
    
    rs.DeleteObject(L0)
    rs.DeleteObject(L1)
    rs.DeleteObject(L2)
    rs.DeleteObject(L3)
    rs.DeleteObject(P0)
    rs.DeleteObject(P1)
    rs.DeleteObject(P2)
    rs.DeleteObject(P3)
#    trussrowy=[]
#    for i in range(B*fieldsy-(fieldsy-1)):
#        trussrowy.append(rs.CopyObject(truss1,(0,rastery*i/fieldsy,0)))
#    
#    for i in range(A-1):
#        rs.CopyObject(trussrowy,(rasterx*i,0,0))

#####################################################################
#CREATE FOUNDATION PLATE % 
#####################################################################
#createplate
fdtplatex= rasterx*(A-1) +xcol*2
fdtplatey= rastery*(B-1) +ycol*2

fdtplate=make_box(cord1, xsize=fdtplatex, ysize=fdtplatey, zsize=h_fdtplate)
rs.MoveObject(fdtplate,(fdtplatex/2-xcol/2,fdtplatey/2-ycol,-h_fdtplate-hbase))

#createplatereinforcement
fdtreinfx= xcol*2
fdtreinfy= ycol
#   h_fdtreinf=0.5
fdtreinf=make_box(cord1, xsize=fdtreinfx, ysize=fdtplatey, zsize=h_fdtreinf)
rs.MoveObject(fdtreinf,(xcol/2,fdtplatey/2-(ycol),-h_fdtplate-hbase-h_fdtreinf))

for i in range(A):
    rs.CopyObject(fdtreinf,(rasterx*i,0,0))

#####################

print "-------------------"
print "                   "
print "The program was executed succesfully!"
print "END"
print "                   "
print "-------------------"


rs.EnableRedraw(1)  #enables the live view of the code execution