Dataprogram för beräkning av pålfundament och felslagning av pålar
Computer program to calculate piling foundation and mispiling
Ett examensarbete utfört i byggkonstruktion på Byggnadsingenjörslinjen
LiTH-ITN-EX-141-SE 2002-06-07 Av: Thomas Dahlqvist
Förord
Detta examensarbete har skrivits på uppdrag av KM (Kjessler & Mannerstråle). Arbetet har genomförts under en mycket givande och lärorik period, vårterminen 2000. Vi har fått förståelse för möjligheter och svårigheter med programmeringsspråket Visual Basic, framförallt i samband med konstruktionsberäkningar.
Studien hade inte kunnat genomföras utan det fina bemötande, präglat av ödmjukhet och ett stort engagemang som vi fått av de anställda på KM Konstruktion. Vi riktar därför ett stort tack till alla medmänniskor som deltagit i studien. Ett speciellt tack tillägnas vår handledare Patrik Samuelsson på KM Konstruktion.
Linköping den 21 juni 2000
Sammanfattning
Uppdragsgivarens önskemål till detta examensarbete är att producera ett dataprogram som dimensionerar pålfundament samt beräknar felslagning av pålar. Ett pålfundaments funktion är att via pålar överföra laster till berg eller fasta jordlager. Felslagning inträffar då pålar inte hamnat på rätt koordinater eller glidit snett ned i marken och ej kan användas. Med hjälp av felslagningsprogrammet erhålles nya pålkoordinater för nästkommande påle, vilken måste placeras ut så att tyngdpunkten för hela pålsystemet skall hamna rätt. Syftet med programmet är att KM (Kjessler & Mannerstråle) kan automatisera tidigare manuella beräkningar.
Examensarbetet är uppdelat i fem delar. Den första delen är en introduktionsdel. Här redogörs bakgrund och syfte med rapporten, vår metodbeskrivning och vilka avgränsningar vi gjort. Vårt tillvägagångssätt är att teoretiskt få kunskap om dimensionering av pålfundament och beräkning av felslagning, samt lära oss programmeringsspråket Visual Basic. Med hjälp av de teoretiska kunskaperna gjorde vi sedan vårt dataprogram. Eftersom tiden var begränsad var vi tvungna att göra en del avgränsningar. Ett exempel på detta är att programmet endast kan utföra beräkningar på 2-,3- och 4-pålsfundament.
I del två, Teori, redovisas teorin om dimensionering av pålfundament och beräkning av felslagning. Här ges även en inblick i hur programmeringsspråket Visual Basic fungerar. Vi förklarar och redogör beräkningsgångarna i ett antal beräkningsexempel.
I den tredje delen, Empiri, beskrivs hur vi omvandlar teoretiska beräkningar till databeräkningar. I denna del visar och beskriver vi vår programkod.
I del fyra, Analys & diskussion, jämför vi empirin med teorin. I denna del diskuteras även för-och nackdelar med vårt dataprogram.
I den sista delen, Slutsats, beskriver vi vår slutsats. Genom att göra dataprogram som utför beräkningar, istället för att göra manuella beräkningar kan en konstruktör spara mycket tid. Han/hon anger ett antal nödvändiga värden till programmet. Därefter utför programmet de olika beräkningarna och slutligen erhålles ett svar.
Summary
The requirement on this report from the client side has been to produce a computer program that dimension piling foundations and calculates mispiling. The piling foundation serves the purpose to transfer forces to bedrock or layer of fixed earth through piles. Mispiling appears when piles haven’t ended up in the correct co-ordinates or when they slide slantingly into the earth and consequently become useless. With assistance from the mispiling program you get new co-ordinates for the following pile, which must be placed to get the correct centre of gravity in the whole piling system. The purpose of the program is that KM (Kjessler & Mannerstråle) can atomise previous manual calculations.
The report is divided into five parts. The first part is an introduction. The background and the purpose of the report, a description of chosen methodology and the delimitations we have defined are all described here. Our procedure is to learn the theory of dimension of piling foundations and calculation of mispiling and also to learn about the programming language Visual Basic. Based on the support of the theoretical knowledge we developed our computer program. Due to time limitations we had to define some delimitations. An example is that the program can accomplish calculations on 2-, 3- and 4-piling foundations only.
In part two, Theory, the theory of dimension of piling foundations and calculations of mispiling are described. You also acquire knowledge about how the programming language Visual Basic works in this part. Finally the calculations are described in a few examples. In the third part, Empiri, it is described how theory is transformed into computer calculations. In this part we also show and describe our program code.
In part four, Analysis & discussion, we do a comparison between empiric and theory. In this part the pros and cons of our computer program are also discussed.
In the last part, Conclusion, we describe our conclusion. By developing computer programs that automatically calculates, instead of doing calculations by hand, the constructor can save a lot of time. He/she only feeds the program with a few values necessary as input. Thereafter the program does the different calculations and finally an answer is given.
Innehållsförteckning
Del 1 Introduktion
1 INLEDNING... 1 1.1 BAKGRUND... 1 1.2 FÖRUTSÄTTNINGAR... 1 1.3 SYFTE... 2 1.4 AVGRÄNSNINGAR... 2 1.5 METODBESKRIVNING... 3 1.6 UPPLÄGG... 3Del 2 Teori
2 PÅLFUNDAMENT ... 42.1 PÅLNING OCH PÅLFUNDAMENT... 4
2.2 DIMENSIONERING AV PÅLFUNDAMENT MED LITEN UTSTRÄCKNING... 5
2.2.1 Dimensioner och armering ... 5
2.2.2 Förankring... 6 2.2.3 Sprickbildning ... 7 2.2.4 Spjälkning ... 9 2.3 BERÄKNINGSEXEMPEL... 10 2.3.1 4-pålarsystem... 10 2.3.2 2-pålarsystem... 14 2.3.3 3-pålarsystem... 14 3 FELSLAGNING... 16 3.1 ALLMÄNT OM FELSLAGNING... 16 3.2 BERÄKNINGSEXEMPEL... 16 4 VISUAL BASIC ... 17 4.1 VAD ÄR VISUAL BASIC? ... 17
Del 3 Empiri
5 OMVANDLING AV TEORETISKA BERÄKNINGAR TILL KODER I VISUAL BASIC 19 5.1 ALLMÄNT OM KODSKRIVNING... 19 5.2 PROGRAMMERING AV PÅLFUNDAMENT... 20 5.2.1 4-Pålarsystem ... 20 5.2.2 2-Pålarsystem ... 28 5.2.3 3-Pålarsystem ... 29 5.2.4 Varningsskyltar... 305.2.5 Resultat och utskrift ... 32
5.3 PROGRAMMERING AV FELSLAGNING... 33
5.3.1 Beräknings- och programmeringsgång ... 34
5.3.2 Resultat och utskrift ... 35
Del 4 Analys & Diskussion
6 ANALYS- OCH DISKUSSIONSAVSNITT ... 36Del 5 Slutsats
7 SLUTSATSAVSNITT ... 37 REFERENSER ... 38 BILAGOR
Figurförteckning
Figur 1: PålfundamentFigur 2: Genomstansningsbrott Figur 3: Pålfundament sett uppifrån
Figur 4: Vidhäftningshållfasthet och förankringslängd Figur 5: Täckskikt
Figur 6: Drag i underkant
Figur 7: Effektiv betongarea (Aef)
Figur 8: Spjälkning
Figur 9a: Armering i tre riktningar Figur 9b: Armering i två riktningar Figur 10: Visual Basic´s layout
Figur 11: Fönster med funktionsknappar
Figur 12: Layout för ingångsdata, pålfundament Figur 13: Varningsskylt
Figur 14: Resultat pålfundament Figur 15: Informationsruta
Figur 16: Layout för ingångsdata, felslagning Figur 17: Resultat felslagning
Bilagor
Bilaga 1 Vidhäftningsfaktor
Bilaga 2 Betongens dimensionerande tryck- och draghållfasthet Bilaga 3 Armeringens dimensionerande draghållfasthet
Bilaga 4 Täckskikt Bilaga 5 Armering Bilaga 6 Sprickbildning
Bilaga 7 Programmeringskoder
Bilaga 8a Utskrift pålfundament, 4-pålarsystem Bilaga 8b Utskrift pålfundament, 2-pålarsystem Bilaga 8c Utskrift pålfundament, 3-pålarsystem Bilaga 9 Utskrift felslagning
Bilaga 10 Miljöklasser Bilaga 11 Ordförklaringar
Bilaga 12 Algoritm för pålfundament Bilaga 13 Manual
1
Inledning
Syftet med detta kapitel är att beskriva bakgrunden till vårt ämnesval och de förutsättningar vi arbetar efter samt att utveckla examensarbetets problemområden, syfte och avgränsningar.
1.1
Bakgrund
Manuella beräkningar av pålfundament och felslagning är relativt tidskrävande i jämförelse med databeräkningar. Detta har medfört att dataprogram har börjat nyttjas mer och mer inom byggbranschen istället för manuella beräkningar.
Beträffande beräkning av pålfundament är det för konstruktörer tidskrävande, eftersom de måste genomgå en rad olika beräkningar för att komma fram till en lösning.
Vid pålning inträffar det ofta att pålarna inte kommer på rätt plats eller att pålarna går snett ner i marken. Detta kan i sin tur leda till att pålgruppens gemensamma tyngdpunkt kommer fel. För att tyngdpunkten skall komma på rätt position igen måste ytterligare påle/pålar slås ned i marken. Någon från byggarbetsplatsen kontaktar då konstruktören för att ta reda på koordinaterna för nästa påle. Vid detta tillfälle är det lämpligt att använda sig av ett dataprogram, på grund av att det inte är lika tidskrävande som att handberäkna.
Byggarbetsplatsen kan få reda på nästa koordinat direkt över telefon, istället för att vänta på att konstruktören skall utföra beräkningarna för hand.
1.2
Förutsättningar
Uppdragsgivare
KM Konstruktion Linköping Handledare
Patrik Samuelsson, KM Konstruktion Linköping Examinator
Anders Johansson, Universitetslärare på Campus Norrköping, Linköpings Universitet. Uppdraget från KM (Kjessler & Mannerstråle)
Målet med vårt examensarbete är att KM vill erhålla ett beräkningsprogram för pålfundament och ett för felslagning. Vi har fått arbeta med fria händer, KM har bara talat om vilka resultat de vill ha fram med programmet.
Tidsomfattning
Examensarbetet omfattar 10 poäng och skall ta cirka 10 veckor att utföra. Resurser
De resurser vi använt oss av är dataprogrammet Visual Basic, KM:s bibliotek, KM:s egna erfarenheter samt våra egna erfarenheter. KM har stått till förfogande med kontor, dator och material.
2
1.3
Syfte
Det primära målet med examensarbetet är att skapa två användbara dataprogram, ett för pålfundament och ett för felslagning.
För att uppnå det primära målet krävs några delmål i form av att få kunskaper i
programmering (i vårt fall Visual Basic), samt förståelse för de teoretiska beräkningarna för pålfundament och felslagning.
Ett annat mål med arbetet är att förstå skillnaden mellan teori och verklighet.
1.4
Avgränsningar
På grund av att vi har haft begränsat med tid under examensarbetets gång, har vi valt att göra en del avgränsningar. Om inte avgränsningar hade gjorts, skulle vi inte kunnat följa vår tidplan. De avgränsningar som har gjorts är:
• Har endast producerat ett dataprogram för beräkning av 2-,3- och 4-pålarsfundament. • Vid beräkning av pålfundament har vi bara berört pålfundament med liten
utsträckning.
• Har bara programmerat för kvadratiska pelare. Vid rektangulära pelare måste programmet ”köras” två gånger på grund av att sidorna är olika långa. Detta skall göras för att få rätt armeringsmängd i respektive riktning. Användaren av
pålfundamentprogrammet skall då inte ta del av texten ”I varje riktning!”. Runda pelare måste konstruktören själv räkna om till kvadratiska.
• Vid litet ingjutningsdjup, ≤ 50 mm kan svaret bli något missvisande eftersom vi alltid använt oss av förstoringsfaktor 1,5, se Betonghandboken (1990) 6.9:32
”Dimensionering av pålplintar och pålplattor”.
• Ingen hänsyn tas till om tillgänglig förankringssträcka är otillräcklig. Enligt
överenskommelse med Patrik Samuelsson (KM) får konstruktören själv ansvara för att uppbockning av armering sker. Vi har dock tagit hänsyn till eventuell uppbockning vid beräkning av fundamentets bredd och längd.
• Vid beräkning av förankringslängd tas ingen hänsyn till ∆fb, se Langesten (1995).
• Har endast programmerat för kamstänger, på grund av att det är den vanligaste förekommande armeringen.
• Gör inte några beräkningar för hur mycket armering som krävs för att undvika spjälkning[11]. Vi tittar bara på om det råder risk för spjälkning.
• Har antagit att koefficienten som beaktar den dragna betongens medverkan mellan sprickorna, ν, alltid är ett. Genom att göra detta antagande betyder det att vi alltid är på den säkra sidan, se Betonghandboken (1990).
• Räknar alltid med täckskikt (c) från tabell 1, 2 och 3 [4]. Det är oftast detta värde som är avgörande. Täckskiktet mellan armeringsjärnen kan vara mindre än ”vårt”
täckskikt, och om så är fallet får konstruktören själv beakta det.
1.5
Metodbeskrivning
Examensarbetet inleddes med införskaffning av litteratur inom programmering i Visual Basic. Vi blev rekommenderade att läsa Peterson, Robin och Tjernlund (1997), en bok som
behandlar programmering i Visual Basic från första början, samt Microsoft Corporation (1991) och (1992).
Första tiden tillbringades i hemmet, där vi läste litteratur och utförde en rad olika
övningsexempel angående programmering i Visual Basic. Resterande tid var vi på KM:s kontor i Linköping för att kunna nyttja deras bibliotek och resurser. Under tiden på KM har vi haft daglig kontakt med vår handledare Patrik Samuelsson.
Vi har gjort teoretiska studier angående beräkning av pålfundament och felslagning. Den litteratur vi framförallt använt oss av är Betonghandboken (1990).
1.6
Upplägg
• Första delen är en introduktion som skall få läsaren att sätta sig in i examensarbetet. • Andra delen innehåller den teoretiska delen av rapporten. Här beskrivs utifrån
litteratur beräkning av pålfundament och felslagning samt allmänt om pålning och programmering.
• Del tre behandlar det praktiska arbetet, empirin. Här förklaras och visas hur vi omvandlat teoretiska beräkningar till databaserade beräkningar.
• I del fyra analyseras och diskuteras den teoretiska delen med vad vi upplevt av det praktiska arbetet.
• I den avslutande delen beskriver vi vår slutsats.
• Hänvisningar till bilagor visas med hjälp av hakparanteser. Exempel: …… täckskikt (c) från tabell 1, 2 och 3 [4].
2
Pålfundament
Syftet med detta kapitel är att i allmänhet förklara vad pålning är samt beskriva den teoretiska beräkningen av pålfundament.
2.1
Pålning och pålfundament
Vid grundläggning på pålar överförs pålkrafterna (Qp) till ett pålfundament, genom att
pålskallarna ingjuts i denna (se Figur 1). Samtidigt överförs kraften (Q) uppifrån genom pelare eller dylikt ner i pålfundamentet. Fundamentet fördelar de angripande lasterna över antalet pålar som ingår i pålgruppen. Pålarnas funktion är att överföra laster från fundament till berg eller fasta jordlager. Pålning används oftast vid dåliga marker, men kan även användas som grundläggningselement för konstruktioner i vatten som till exempel brostöd, kajer och hamnpirar. (Holm, Olsson, 1993 samt Betonghandboken, 1990)
Figur 1: Pålfundament. Källa: Dahlqvist & Parbrand (2000).
Vid användning av träpålar skall pålavskärningen, det vill säga pålarnas ingjutna överytor (se Figur 1), placeras under lägsta grundvattenytan. Vid användning av betongpålar kan
pålavskärningen förläggas på en ur konstruktiv synpunkt lämplig nivå, även över markytan. (Betonghandboken, 1990)
Pålarnas ingjutningsdjup (se Figur 1), bör vara minst 50 -100 mm vid tryckta pålar. Detta för att säkra kraftöverföringen i både längs- och sidled. Vid dragna pålar måste pålen förankras i fundamentet för att överföra den dimensionerande dragkraften i pålen. (Betonghandboken, 1990)
Pålfundamentets storlek bestäms av: • pålarnas antal
• centrumavstånd (se Figur 1) • ingjutningsavstånd (se Figur 1)
5
För att undvika stansbrott, en form av skjuvbrott, skall pålplattan skjuta ut 15-20 cm (stansningsmått, se Figur 1) utanför den yttersta pålen (Betonghandboken, 1990). Då en betongplatta utsätts för koncentrerade laster kan ett lokalt skjuvbrott uppstå runt det belastade området. Detta brott kallas genomstansningsbrott (se Figur 2), ett typ av stansbrott, och kännetecknas av att en volym i form av en stympad kon stansas ur plattan. Ett sådant här brott kan leda till katastrofala följder (Kölfors, 1993).
Figur 2: Genomstansningsbrott. Källa: Kölfors (1993).
2.2
Dimensionering av pålfundament med liten utsträckning
Vid våra beräkningar har vi endast berört 2-, 3- och 4-pålarsystem, se 1.4 ”Avgränsningar”. Detta medför att vi endast studerat pålfundament med liten utsträckning, se 1.4
”Avgränsningar”. Vid 2-, 3- och 4-pålarsystem, där pålarna placeras i två rader, blir
fundamentets bredd relativt liten i förhållande till tjockleken. Pålfundamentets höjd väljs så att den sneda trycksträva, som utbildas mellan den nedförda lasten och lasten från yttersta pålen (se Figur 1), har en lutning ≥ 45°. För att detta krav skall uppfyllas måste den effektiva platthöjden, d ≥ a√2 vid 4-pålarsystem och vid 2- och 3-pålarsystem måste d ≥ a.
Våra beräkningar på 2- och 4-pålarsystem följer Betonghandbokens (1990) tillvägagångssätt i kapitel 6.9:322 ”Pålplintar med liten utsträckning”, exempel 6.9:4, samt kapitel 3.10:2
”Spjälkning under lokalt tryck”. Vad gäller 3-pålarsystem har vi följt vår handläggares, Patrik Samuelsson, tillvägagångssätt med inslag från tillvägagångssätten för 2- och 4-pålarsystem.
2.2.1 Dimensioner och armering
Pålfundamentet dimensioneras för reaktionskrafterna från pålarna (Qp), som uppkommer då
dimensionerande laster från byggnaden nedförs till pålgrunden i brottgränstillstånd [11]. Pålarna antas vara ledat infästade [11] i fundamentet. Dragkraften i armeringen mellan varje påle (Ft,p) beräknas med hjälp av följande formel:
Ft,p = (Qp * a) / z
Qp = Pålkraft
¼-punkt. Tolerans för felslagning skall vara minst 50 mm och bör adderas. I Betonghandboken (1990) används en tolerans för felslagning på 100 mm. (se Figur 1)
z = Inre hävarm som kan uppskattas till 0,9 * d (se Figur 1) d = Effektiv platthöjd (se Figur 1)
Eftersom z uppskattas till ett värde kan man räkna ut ett nytt Ft,p:
x = Ft,p / (fcc * bp)
x = Tryckzonshöjd (se Figur 3)
fcc = Dimensionerande tryckhållfasthet för betong
bp = Tryckzonsbredd (se Figur 3)
Ft,p = (Qp * a) / (d – x / 2)
Figur 3: Pålfundament sett uppifrån. Källa: Betonghandboken (1990).
2.2.2 Förankring
Vidhäftningen mellan betong och armeringstänger har en avgörande betydelse vid förankring av armeringsstänger. För att erhålla en bra vidhäftning [11] bör friktionen mellan armeringen och betongen vara så hög som möjligt. Vidhäftningshållfastheten kan förklaras enligt Figur 4. Armeringsstången måste ha ett så pass bra fäste i betongen, att den klarar av att överföra den dragkraft (Fs) som svarar mot den dimensionerande draghållfastheten (fst).
Förankringslängden (lb) är den sträcka utmed vilken den mot Fs mothållande kraften fördelas i
betongen.
7
Vid beräkning av förankringslängd används följande formel: lb = (fst / fb) * (∅ / 4)
fst beror på armeringsval, armeringsdiameter och säkerhetsklass [11]. Värdet
fås i från tabell 2 [3]. ∅ = armeringsdiameter
fb = η1 ( η * η2 *η3* fct + ∆fb ) På grund av risken för rent utdragsbrott
[11] får fb inte överstiga 3fct.
η1 = 1,0 för kamstänger som har ett täckskikt, c1≤ 100 mm, se [1]
η = 1,4 för kamstänger
η2 = 1 / 3 * (1 + 2c / ∅) Förstoringsfaktor då täckskiktet är större än
armeringsdiametern (∅). Detta medför att vidhäftningsförmågan ökar.
c = Minsta måttet av c1, c2 och 0.5cs
c1 och c2 Täckskiktets tjocklek i höjdled och sidled
cs Fria avståndet mellan
närliggande armeringsstänger i samma lager
Figur 5: Täckskikt. Källa: Langesten (1995).
η3 Förstoringsfaktor som används vid glest liggande armering,
förekommer ofta i plattor och väggar. Ingen hänsyn tas till denna faktor vid beräkning av pålfundament.
fct = Dimensionerande draghållfasthet för betong. Beror på betongkvalitet
och säkerhetsklass.
∆fb Förstoringsfaktor som används vid användning av byglar eller då
tvärgående armering är placerad utanför den längsgående armeringen. Denna faktor tas ingen hänsyn till vid beräkning av pålfundament, se 1.4 ”Avgränsningar”.
2.2.3 Sprickbildning
Då sprickor bildas i betong löper armeringen stor risk att utsättas för rostskador. För att undvika detta problem är det nödvändigt att bestämma hur breda sprickor som kan uppstå i den dragna delen av konstruktionen (se Figur 6).
Figur 6: Drag i underkant. Källa: Langesten (1995).
Den karakteristiska [11] sprickbredden (Wk) beräknas för långtidslast i bruksgränstillstånd
[11]:
Wk = 1,7 * ν * Srm * (σs / Es)
ν Koefficient som beaktar den dragna betongens medverkan mellan sprickorna. Vid val av ν = 1 fås maximal sprickbredd, vilket medför dimensionering för det värsta fallet. (se 1.4 ”Avgränsningar”) Srm = 50 + κ1 * κ2 * (∅ / ρr)
Srm = Medelsprickavståndet
κ1 = En koefficient som beaktar armeringens vidhäftning, 0,8 för
kamstänger. Beräknar bara efter kamstänger, se 1.4 ”Avgränsningar”.
κ2 = 0,25 * (1 – ((u + a) / (h – x))
κ2 = En koefficient som beaktar töjningsfördelningen inom den
effektiva betongarean (Aef) (se Figur 7)
u = Täckskikt a = ∅ / 2 h = Fundamentets tjocklek x = Tryckzonshöjd ∅ = Armeringsdiameter ρr = Total As / Aef ρr = Geometriska armeringsinnehållet
Total As = Den totala vidhäftande dragarmeringsarean
Aef = (c + ∅ / 2) * 2 * b
Aef = Effektiv betongarea
c = Ingjutningsdjup ∅ = Armeringsdiameter b = Fundamentets bredd
9
Figur 7: Effektiv betongarea (Aef). Källa: Langesten (1995).
σs = (Ft,p * (QL / Qb)) / Total As
Ft,p = (Qp * a) / (d – x / 2)
QL = Långtidslastandel i bruksgränstillstånd
Qb = Last i brottgränstillstånd
Total As = Den totala vidhäftande dragarmeringsarean
Es = Armeringens elasticitetsmodul [11]
Sprickbredden (Wk) får ej överskrida sprickbreddsbegränsningen (Wk,tillåten), se exempel 6.9:4
i Betonghandboken (1990), 6.9:322 ”Pålplintar med liten utsträckning”.
2.2.4 Spjälkning
Spjälkning uppkommer då en lokal yta blir utsatt för en tryckkraft, vilket medför att dragpåkänningar uppstår i övriga delar av konstruktionen.
Spjälkning förutsätts inte inträffa om tryckkraften (Fs) är mindre än fundamentets kapacitet
(FR), som har det största av följande värden:
FR = 0,75 * a * b * fct
FR = (0,5 + β) * A * fcc
Fs = Qb
a = a1, a2 och a3, längden av den kortaste spjälksprickan genom tyngdpunkten
Figur 8: Spjälkning. Källa Betonghandboken (1990).
b = Dubbla avståndet från tryckytans [11] tyngdpunkt till konstruktionens närmaste kant. b behöver inte ges mindre värde än 8 * tryckytans längd (b1)
i samma riktning. b får dock inte ha ett större värde än 30 * b1. (se Figur 8)
fct= Dimensionerande draghållfasthet för betong
β = Den andel av tryckytan som faller innanför en med konstruktionsytan likformig yta A1.
A1 = 0,6 * fundamentets längd * 2 + 0,6 * fundamentets bredd * 2
A = Tryckytan
fcc= Dimensionerande tryckhållfasthet för betong
Qb= Last i brottgränstillstånd
2.3
Beräkningsexempel
2.3.1 4-pålarsystem
Exempel 6.9.4 i Betonghandboken (1990). Pelardimension: 450 x 450 mm
Laster: QL = 1200 kN (långtidslastandel i bruksgränstillstånd)
Qb = 2000 kN (brottgränstillstånd)
(Pålfundamentets egentyngd antas inräknad i lasten) Betongpålar: 4 stycken 250x250 mm, centrumavstånd (s) = 900 mm Säkerhetsklass: SK2
Betong: K30 fcc = 13,0 MPa (dimensionerande tryckhållfasthet, se [2])
11
Armering: Ks400 fst = 331 MPa (dimensionerande draghållfasthet, se [3])
Armeringsdiameter (∅) = 16 mm
Täckskikt: Minsta basmått (c), för täckande betongskikt i mm
c = 54 mm, halva fria avståndet för ∅ 16 s125. (se Figur 5) Dimensioner och armering
Fundamentets mått antas till: b = 1500 mm
l = 1500 mm h = 0,75 m
Pållasten (Qp) blir i brottstadium:
Qp = (2000 / 4) = 500 kN
Om pålens felslagning uppskattas till 100 mm, blir hävarmen (a):
a = (s / 2) – (pelardimension / 4) + uppskattad felslagning = (0,9 / 2) – (0,45 / 4) + + 0,1 = 0,438 m (se Figur 1)
Effektiv platthöjd (d):
d = a * √2 = 0,438 * √2 = 0,62 m (se Figur 1)
Tryckzonshöjd (x): Tryckzonsbredden (bp) motsvarande båda pålarna kan uppskattas till
cirka:
bp = pelardimensionen + 2 * uppskattat x = 0,45 + (2 * 0,1) = 0,65 m
Inre hävarm (z):
antas till 0,9 * d (se Figur 1) Dragkraft i armeringen (Ft,p):
Ft,p= 2 * Qp * (a / z) = 2 * 500 * (0,438 / (0,9 * 0,62)) = 785 kN
Uppskattningen av z = 0,9 * d är i allmänhet tillräckligt noggrann, men kan beräknas noggrannare enligt följande:
Ft,p= fcc * x * bp ⇒ x = Ft,p / (fcc * bp) = 0,785 /(13,0 * 0,65) = 0,09 m
Ft,p= 2 * Qp * (a / (d – (x / 2))) = 2 * 500 * (0,438 / (0,62 – (0,09 / 2))) = 762 kN
As = Ft,p / fst = 762 * 10³ / 331 = 2302 mm² ⇒
⇒ Armeringsmängd 12 ∅ 16 i varje riktning ⇒ ⇒ Total armeringsarea (Total As) = 2412 mm², se [5]
Armeringens centrumavstånd (cc):
cc = (fundamentets längd – (2c) –3∅) / (n – 1) = (1500 – (2 * 54) – (3 * 16)) / (12 – 1) = 122 mm
Armeringen placeras i båda riktningarna! Kontroll av förankring
Vidhäftningshållfasthet (fb):
fb = η1(η * η2 * η3 * fct + ∆fb) = 1,4 * 1 / 3 * (1 + 2 * 54 / 16) * fct> 3fct = 2,91 MPa
fb = Vidhäftningshållfasthet
η1 = Ingen inverkan (se 2.2.2 ”Förankring”)
η = 1,4 (kamstång) η2 = 1 / 3 * (1 + 2c / ∅)
c = 54 mm ∅ = 16 mm
η3 = Ingen inverkan (se 2.2.2 ”Förankring”)
fct = 13,0 MPa
∆fb= Ingen inverkan (se 2.2.2 ”Förankring”)
Förankringslängd (lb):
lb = (As / Total As) * (fst / 3fct) * (∅ / 4) = (2302 / 2412) * (331 / 2,91) * (16 / 4) = 450 mm
Tillgänglig förankringssträcka är otillräcklig eftersom ingjutningsavståndet (se Figur 1) är 300 mm. Detta tas dock ingen hänsyn till, se 1.4 ”Avgränsningar”.
Kontroll av sprickbildning Medelsprickavståndet (Srm): Srm = 50 + κ1 * κ2 * (∅ / ρr) = 50 + 0,8 * 0,21 * (16 / 0,744 * 10-2) = 411 mm κ1 = 0,8 κ2 = 0,25 * (1 – ((u + a ) / (h – x)) = 0,25 * (1 – ((100 + 8) / (750 – 90) = 0,21 ρr = Total As / Aef = 2412 / 324 * 10³ = 0,744 * 10-2 Aef = (c + ∅ / 2) * 2 * b = (100 + 16 / 2) * 2 * 1500 = 324 * 10³ mm² c = 100 mm (ingjutningsdjup)
13 Armeringspåkänning i sprickan (σs): σs = Ft,p * (QL / Qb) * (1 / Total As) = 0,762 * (1,2 / 2,0) * (1 / 2412 * 10-6) = = 190 MPa Sprickbredden (Wk): Wk = 1,7 * ν * Srm * (σs / Es) = 1,7 * 1 * 411 * (190 / 200000) = 0,66 mm
Wk = 0,66 är större än tillåten sprickbredd (Wk ≤ 0,4 i det här fallet, se Boverket,
Byggavdelning (1994)). Vid sprickbredd större än tillåten sprickbredd används förstoringsfaktor 1,5, se 1.4 ”Avgränsningar”.
Armeringsarea med hänsyn till sprickbildning (As):
As = (Wk / Wk,tillåten) * Total As = (0,66 / (1,5 * 0,40)) = 2653 mm² ⇒
⇒ Armeringsmängd 14 ∅ 16 i varje riktning ⇒ ⇒ Total armeringsarea (Total As) = 2815 mm², se [5]
Wk,tillåten fås enligt Tabell 4.5.4 i BBK 94, se [6]
Armeringens centrumavstånd (cc):
cc = (fundamentets längd – (2c) –3∅) / (n – 1) = (1500 – (2 * 54) – (3 * 16)) / (14 – 1) = 103 mm
Armeringen placeras i båda riktningarna! Kontroll av spjälkning
FR = 0,75 * a * b * fct = 0,75 * 1500 * 3600 * 0,97 = 3929 kN
a = 525 + 450 + 525 = 1500 mm (se Figur 8)
b = 2 * 750 = 1500 mm < 8 * b1 = 8 * 450 = 3600 mm OK! (se Figur 8)
FR= (0,5 + β) * A * fcc = (0,5 + 0,5) * 202500 * 13,0 = 2633 kN
β = 0,5
A = Pdim * Pdim = 450 * 450 = 202500 mm² (Hela tryckytan hamnar inom ytan A1, se
2.2.4 ”Spjälkning”) Fs = Qb = 2000 kN < FR = 3929 kN OK! Ingen risk för spjälkning!
2.3.2 2-pålarsystem
Till skillnad från 3- och 4-pålarsystem är pålfundamentet vid 2-pålarsystem rektangulärformat.
Beräkningsgång av 2-pålarsystem sker enligt 2.3.1 ”4-Pålarsystem”. Det krävs dock några korrigeringar av vissa formler:
• Betongpålar: 2 stycken 250x250 mm
• Pållasten (Qp) i brottstadiet: Qp = (2000 / 2) kN
• Effektiv platthöjd (d): d = a
• Dragkraften i armeringen (Ft,p): Ft,p = Qp * (a / z)
Ft,p = Qp * (a / (d – x / 2))
• Dragkraft i armeringen (Ft,p) vid sprickbildning:
Ft,p = (QL / 2) * (a / z)
Ft,p = (QL / 2) * (a / (d – x / 2))
Det krävs även nya beräkningar av övriga formler, på grund av att ovanstående formler i sin tur ingår i andra formler.
2.3.3 3-pålarsystem
Beräkningsgång av 3-pålarsystem sker enligt 2.3.1 ”4-Pålarsystem”. Det krävs dock några korrigeringar av vissa formler:
• Betongpålar: 3 stycken 250x250 mm
• Pållasten (Qp) i brottstadiet: Qp = (2000 / 3) kN
• Hävarm (a): a = (2 / 3) * (s * sin 60°) – (Pdim / 4) * 0,1
60° = Vinkeln i en liksidig triangel • Effektiv platthöjd (d): d = a
• Dragkraft i armering (Ft,p): Ft,p = Qp * (a / z)
Ft,p = Qp * (a / (d – x / 2))
• Dragkraft i armering (Ft,p) vid sprickbildning:
Ft,p = (QL / 3) * (a / z)
Ft,p = (QL / 3) * (a / (d – x / 2))
På grund av att ovanstående formler i sin tur ingår i andra formler, krävs det även vid 3-pålarsystem nya beräkningar av övriga formler.
Enligt beräkningarna ovan räknar man med att armeringen ligger i tre riktningar (se Figur 9a). KM (Kjessler & Mannerstråle), vår uppdragsgivare, vill istället att armeringen skall placeras i två riktningar (se Figur 9b). För detta krävs en förändring i beräkningarna. Armeringsarean beräknas i två riktningar, As1 och As2. As1 beräknas som tidigare medan As2 beräknas enligt
följande:
15
Figur 9a: Armering i tre riktningar. Figur 9b: Armering i två riktningar Källa: Dahlqvist & Parbrand (2000). Källa: Dahlqvist & Parbrand (2000).
3
Felslagning
Syftet med detta kapitel är att i allmänhet förklara vad felslagning av pålar är samt beskriva den teoretiska beräkningen av felslagning.
3.1
Allmänt om felslagning
Vid utsättning av pålar, händer det ibland att pålarna inte hamnar där man önskar, de glider fel vid slagning. Efter utsättning kontrolleras de slagna pålarnas koordinater i x- och y-led genom inmätning med exempelvis en totalstation [11]. Detta görs för att se om pålarna hamnat inom tillåten felmarginal, 100 mm. Om påle/pålar inte hamnat inom tillåten felmarginal måste ytterligare påle/pålar slås ner för att pålgruppens gemensamma tyngdpunkt skall komma rätt. För att beräkna den nya pålens koordinater måste man veta koordinaterna för de redan slagna pålarna, dess pålkrafter, nya pålens pålkraft samt den önskade gemensamma tyngdpunkten för pålgruppen.
3.2
Beräkningsexempel
Antal slagna pålar: 3 stycken
Önskad tyngdpunkt: xtp = 133,56 m ytp = 24,75 m
Data om slagna pålar:
Ny påle med kapaciteten F: 200 kN Beräkning av ny tyngdpunkt:
xtp = ∑(Fi * x) / ∑F ⇒ 133,56 = (80378 + 200x) / 800 ⇒ x = 132,35
ytp = ∑(Fi * y) / ∑F ⇒ 24,75 = (14283 + 200y) / 800 ⇒ y = 27,585
För att pålgruppens gemensamma tyngdpunkt skall hamna över rätt koordinater, skall den nya pålen ha följande koordinater: x = 132,35 m , y = 27,585 m
Påle Pålkraft, F (kN) x-koordinat y-koordinat 1 100 132,47 25,33 2 200 132,99 22,75 3 300 135,11 24,00 Påle Pålkraft, F (kN) x-koordinat y-koordinat Fi * x Fi * y 1 100 132,47 25,33 13247 2533 2 200 132,99 22,75 26598 4550 3 300 135,11 24,00 40533 7200 NY 200 X y 200x 200y ∑F = 800 ∑Fi * x = 80378 + 200x ∑Fi * y = 14283 + 200y
17
4
Visual Basic
Syftet med detta kapitel är att i stora drag förklara vad programmeringsspråket Visual Basic är.
4.1
Vad är Visual Basic?
Visual Basic är ett programmeringsprogram framtaget av Microsoft. Programmet är ett verktyg som har tagits fram för att enkelt och snabbt kunna göra egna Windowsprogram. Visual Basic är ett system utvecklat för framförallt skapande av grafiska applikationer [11]. En fördel med Visual Basic jämfört med många andra programmeringsspråk är att inga avancerade programmeringskunskaper behövs för att kunna använda det. En bra kunskap som dock kan vara bra att ha, är att vara bekant med grunderna i programmeringsspråket BASIC och känna till hur man använder Windows.
Till skillnad från många andra programmeringsspråk där endast egna skrivna koder används, bygger Visual Basic på redan färdiga kommandon. Språket kretsar runt två typer av objekt:
1. Fönster 2. Kontroller
Fönster kallas ”form” och på de olika ”formerna” placeras olika objekt in, så kallade
kontroller. Efter utplacering av kontroller, programmeras hur formerna och kontrollerna skall agera vid användning av det färdiga programmet. I Figur 10 visas ett exempel på hur Visual Basic´s layout kan se ut:
E B C D A F G
A. Huvudmeny Innehåller samtliga funktioner. B. Fönster (Form) Här görs programmets layout. C. Verktygsfält Innehåller vissa funktioner, ikoner.
D. Projektfönster Visar vad ett projekt innehåller. Här väljs fönster. E. Verktygslåda Här hämtas funktionsknappar, färdiga kommandon. F. Kodfönster Markeras vid programmering av koder.
G. Egenskapsfönster Här kan ett objekts egenskaper ändras. Nedan visas ett exempel på hur ett fönster med dess funktionsknappar kan se ut:
Figur 11: Fönster med funktionsknappar. Källa: Dahlqvist & Parbrand (2000).
Label (Etikett) = Innehållet i en etikett kan ej ändras av användaren och
används därför med fördel till att visa utdata.
TextBox (Textruta) = Används till att visa information eller för att låta användaren skriva in information.
Frame (Ram) = Ramen används för att skapa en
funktionell och / eller visuell gruppering av kontroller.
ComboBox (Kombinationsruta) = Fungerar som en rullgardinsmeny där olika värden kan väljas. Texten i textrutan visar set alternativ som valts, eller det alternativ som
användaren skrivit in. Command button (Kommandoknapp) = Används till att utföra
kommandon. När användaren väljer en kommandoknapp inträffar en klickhändelse. Option button (Alternativknapp) = Innehåller ett val som kan sättas
på eller stängas av.
Alternativknappen fungerar så väl enskilt som i grupp.
5
Omvandling av teoretiska beräkningar till koder i
Visual Basic
Syftet med detta kapitel är att förklara hur vi har omvandlat teoretiska beräkningar till koder i Visual Basic.
5.1
Allmänt om kodskrivning
Vår beräkningsgång av pålfundament ser i stort sett ut som beräkningsgången enligt 2.3.1 ”4-Pålarsystem”, 2.3.2 ”2-Pålarsystem” eller 2.3.3 ”3-Pålarsystem”. Det som skiljer dem åt är att vi i våra beräkningar gör vissa förändringar i enstaka formler. Vilka dessa förändringar är beskrivs i kommande avsnitt. Varför vi gör dem beror på att KM (Kjessler & Mannerstråle) vill att programmet skall baseras på deras sätt att beräkna pålfundament. Hur upplägget av programmeringsgången ser ut i stora drag finns att följa i [12]. Programmets samtliga koder finns att studera i [7].
Beträffande felslagning gör vi inga förändringar, utan följer beräkningsgången enligt 3.2 ”Beräkningsexempel”.
Alla variabler i beräkningsexemplen deklareras till nya variabler, se exempel 5:1, för att formler och uttryck skall bli lättförståliga i programkoderna. Hur en formel i teorin omvandlas till en programmeringskod beskrivs i exempel 5:2. När vi omvandlar de teoretiska
beräkningarna till koder, har vi valt att skriva koden med fet stil för att enkelt kunna se vad som är vad.
Exempel 5:1
Teori ⇒ Kod
Wk ⇒ Global WkAs Single
Srm ⇒ Global SrmAs Single
σs ⇒ Global SIGMAsAs Single
√2 ⇒ Global Const rot2 = 1.414213562
Genom att deklarera [11] en variabel som Global kan den användas över hela programmet. Om koden avslutas med As Single, betyder det att variabeln är deklarerad som ett tal med oberoende storhet.
Vill man deklarera en variabel som en konstant, måste man skriva syntaxen Const innan variabeln. Efter variabeln skrivs vilket värde konstanten skall ha.
Exempel 5:2
Wk = 1,7 * ν * Srm * (σs / Es) ⇒ Wk = 1.7 * 1 * Srm * (SIGMAs / 200000)
I Figur 12 kan ses hur några olika kommandorutor ser ut. Vid beräkning av pålfundament deklarerar vi några kommandorutor som variabler, för att lättare hålla reda på vad som ingår i de olika formlerna som vi använder i vårt program. Till skillnad från programmering av pålfundament, namnger vi vid felslagning kommandorutorna direkt. Nedan visas skillnaden.
20
fi = Val(Combo6.Text) ComboBox deklareras som
armeringsdiametern (fi).
Val-funktionen returnerar ett numeriskt värde.
Combofi.Text Kombinationsrutan döps här direkt om till fi.
Genom att döpa om kombinationsrutan behöver man ej använda sig av lika många koder.
5.2
Programmering av pålfundament
I Figur 12 visas hur layouten för pålfundamentsprogrammet ser ut. Här skrivs vilken ingångsdata programmet skall beräkna efter. Vid uppstart av programmet finns redan
standardvärden ifyllda för att slippa ”debug” om man glömt fylla i något värde. Med ”debug” menas att dataprogrammet ej kan räkna vidare eftersom ingångsdata saknas.
Figur 12: Layout för ingångsdata, pålfundament. Källa: Dahlqvist & Parbrand (2000).
5.2.1 4-Pålarsystem
Dimensioner och armering
Beräkningsgång sker enligt 2.3.1 ”4-Pålarsystem”.
För att rätt enheter skall användas i programmet, har vi multiplicerat/dividerat enstaka tal med 1000 och 1 000 000.
Om antal pålar är valt till 4 stycken skall, programmet beräkna enligt 4-pålarsberäkning: If Combo4.Text = "4" Then
Hävarmen (a):
a = (s / 2) – (pelardimension / 4) + uppskattad felslagning ⇒ a = (s / 2) - (Pdim / 4) + + 0.1 Effektiv platthöjd (d): d = a * √2 ⇒ d = (a * rot2) Inre hävarm (z): z = 0,9 * d ⇒ z = 0.9 * d Fundamentets höjd (h):
h = d + 3∅ + 10 + Ingjutningsdjup ⇒ h = (d * 1000) + (3 * fi) + 10 + Ingjut Fundamentets bredd (b):
b = s + (2 * Ingjutningsavstånd) ⇒ b = (s * 1000) + (2*Ingjutningsavstand) Fundamentets längd (l):
l = b ⇒ langd = b (kvadratiskt fundament)
Fundamentets karakteristiska egenvikt (gk):
gk = b * h * l * 24 ⇒ egenvikt = (b / 1000) * (h / 1000) *
* (langd / 1000) * 24 24 = Betongens vikt i kN / m3
Dragkraft i armeringen (Ft,p):
Ft,p = 2 * Qp * (a / z) ⇒ Ftp1 = 2 * Mtp * (a / z)
Vid den teoretiska beräkningen beräknas Ft,p med hänsyn till den dimensionerande lasten från
byggnaden i brottgränstillståndet (Qb). Vi har i våra beräkningar istället använt oss av den
maximala totala kraft (Mtp) som respektive påle tål. Till skillnad från teorin, där
tryckzonsbredden (bp) är uppskattad, beräknar vi med ett exakt värde. På grund av detta får vi
lösa x med hjälp av en 2:a-gradsekvation, se nedan.
Enligt 2.3.1 ”4-Pålarsystem - Dimensioner och armering” kan ett noggrannare Ft,p beräknas:
Ft,p = fcc * x * bp ⇒ x = Ft,p / (fcc * bp) ⇒ x = Ft,p / (fcc * (Pdim + 2x))
⇒ x = (-Pdim / 4) +- √((-Pdim / 4)² + (Ft,p / 2 fcc)) I vårt fall kommer vi alltid att få
ett positivt och ett negativt x-värde i 2:a-gradsekvationen. Räknar dock bara med det positiva talet.
22 Ft,p = 2 * Qp * (a / (d – x / 2))
Vid omvandling av de teoretiska beräkningarna till koder i Visual Basic, använder vi oss av en så kallad ”loop”. Den gör att programmet ”kör” en speciell procedur om och om igen tills den uppnår ett önskat resultat. Med hjälp av det redan beräknade Ft,p-värdet (Ftp1), beräknas
ett x-värde (tryckzonshöjd). Detta x-värde används i sin tur för att beräkna ett noggrannare Ft,p
(Ftp2). Med hjälp av ”loopen” ”kör” programmet dessa koder om och om igen tills skillnaden (Felmarg) mellan Ftp1 och Ftp2 ≤ 0,001 kN. För att inte skillnaden mellan Ftp-värdena skall vara ≤ 0,001 kN innan ”loopen” startar, sätts Felmarg = 1.
Felmarg = 1 Do Until Felmarg <= 0.001 X2 = ((-Pdim / 4) + ((Pdim / 4) ^ 2 + ((Ftp1 / 1000) / (2 * fcc))) ^ 0.5) Ftp2 = Mtp * 2 * (a / (d - (X2 / 2))) Felmarg = Ftp1 - Ftp2 Ftp1 = Ftp2 Loop
Betongens tryckhållfasthet (fcc) kan läsas av i tabell1 [2]. Nedan visas en del av tabellen i
kodform, resterande finns i [7]. Den är uppbyggd med hjälp av ”If-satser”. Programmet läser av ett värde på fcc beroende på vilken betongkvalitet och säkerhetsklass som är vald. Med
kommandot Option7.Value = True menas att alternativknappen 7 (SK1) är aktiverad. If Combo2.Text = "K25" And Option7.Value = True Then
fcc = 12.0 End If
If Combo2.Text = "K25" And Option8.Value = True Then fcc = 10.9
End If
If Combo2.Text = "K25" And Option9.Value = True Then fcc = 10.0 End If Tryckzonsbredden (bp): bp = (Pdim + 2x) ⇒ bp1 = Pdim + (2 * X2) Armeringsarea (As): As = Ft,p / fst ⇒ ArmA = Ftp2 / fst * 1000
Dimensionerande draghållfasthet för armering (fst) fås ur tabell 2 [3]. Värdet baseras på
armering, säkerhetsklass och armeringsdiameter. Med hjälp av en ”If-sats” läser programmet av vilket värde fst skall ha. Nedan finns några exempel på hur en sådan ”If-sats” kan se ut.
Hela tabellen i kodform finns att skåda i [7].
If Combo1.Text = "Ks40S" And Option7.Value = True And Combo6.Text = "12" Then
fst = 357 End If
If Combo1.Text = "Ks40S" And Option7.Value = True And Combo6.Text = "16" Then
fst = 357 End If
If Combo1.Text = "Ks40S" And Option7.Value = True And Combo6.Text = "20" Then
fst = 339 End If
Antal armeringsjärn (n):
n = As / ((∅ * ∅ * π) / 4) Area på ett järn = (∅ * ∅ * π) / 4
n1 = Round(ArmA / ((fi * fi * pi) / 4)) Round = avrundning till heltal
Om avrundat antal armeringsjärn är < oavrundat antal armeringsjärn, blir alltid antal armeringsjärn (n) = n1 + 1. Om inte, är n = n1. Detta görs för att antal armeringsjärn alltid skall avrundas uppåt. Om inte blir armeringsmängden missvisande.
If n1 < ArmA / ((fi * fi * pi) / 4) Then n = n1 + 1 Else n = n1 End If Total Armeringsarea (As): Total As = n * ∅ * ∅ * π / 4 ⇒ TA = n * fi * fi * pi / 4 Armeringens centrumavstånd (cc):
cc = (fundamentets längd – (2c) –3∅) / (n – 1)⇒ cc = (langd - (2 * c) - (3 * fi)) / /(n - 1)
Val av minsta täckande betongskikt (c), beror på miljöklass [11], livslängdsklass [11], det ekvivalenta vattencementtalet (Vcte) [11] och armeringsdiameter. Värdet fås från [4]. För att
pålfundamentprogrammet skall använda sig av rätt täckskikt, har vi utifrån [4] skrivit koder i form av ”If-satser”. Nedan finns några exempel på hur de kan se ut, resterande koder finns i [7].
24 'A3 L1 VCT 0.45
'**************
If Option3.Value = True And Option5.Value = True And Combo5.Text = "0.45" And Combo6.Text = "10" Then
c = "35" End If
If Option3.Value = True And Option5.Value = True And Combo5.Text = "0.45" And Combo6.Text = "12" Then
c = "36" End If
If Option3.Value = True And Option5.Value = True And Combo5.Text = "0.45" And Combo6.Text = "16" Then
c = "38" End If
Vid de tillfällen då n = 1, blir n istället 2. Detta för att värdet på (n – 1) inte skall bli noll. Dessutom läggs aldrig ett enskilt armeringsjärn ensamt.
If n = 1 Then n = 2 End If
I vilken riktning armeringen ligger i, beror på fundamentets geometri. Vid 3- och 4-pålarsystem läggs armeringen i båda riktningarna och vid 2-4-pålarsystem i längsgående riktning.
If Combo4.Text = "4" Then
Label18.Caption = "I varje riktning!" End If
If Combo4.Text = "2" Then
Label18.Caption = "I längsgående riktning!" End If
Vid 3-pålarsystem är det olika armeringsmängd beroende på riktning, a- och b-riktning. Se även 2.3.3 ”3-Pålarsystem”. Hur koden skrivs kan ses i [7].
Kontroll av förankring Vidhäftningshållfasthet (fb):
fb = η * η2 ⇒ fb1 = 1.4 * (1 / 3) * (1 + ((2 * c) / fi))
Enligt teorin skall det minsta täckskiktet (c) väljas (se Figur 5). I våra beräkningar räknar vi trots det, alltid med det värde som läses av i [4]. Se även 1.4 ”Avgränsningar”.
Om fb> 3 sätts fb = 3 * fct, om fb< 3 multipliceras fb med fct.
If fb1 > "3" Then fb = 3 * fct
Else
fb = fb1 * fct End If End If
Betongens draghållfasthet (fct) kan läsas av i tabell 1 [2]. Nedan visas en del av tabellen i
kodform. Den är uppbyggd, som övriga tabeller, med hjälp av ”If-satser”. Programmet läser av ett värde på fct, beroende på vilken betongkvalitet och säkerhetsklass som är vald.
If Combo2.Text = "K25" And Option7.Value = True Then fct = 0.93
End If
If Combo2.Text = "K25" And Option8.Value = True Then fct = 0.85
End If
If Combo2.Text = "K25" And Option9.Value = True Then fct = 0.78
End If
Förankringslängd (lb):
lb = (As / Total As) * (fst / fb) * (∅ / 4) ⇒ lb = (ArmA / TA) * (fst / fb) * (fi / 4)
Kontroll av sprickbildning Dragkraft i armeringen (Ft,p):
Ft,p = 2 * (Q / 4) * (a / z) ⇒ Ftp = 2 * (Q / 4) * (a / (0.9 *d))
Q = QL + fundamentets karakteristiska egenvikt Q = QL + egenvikt
Ft,p beräknas, vid sprickbildning, med hänsyn till den dimensionerande lasten från byggnaden
i bruksgränstillstånd.
Enligt 2.3.1 ”4-Pålarsystem - Dimensioner och armering” kan ett noggrannare Ft,p beräknas:
Ft,p = fcc * x * bp ⇒ x = Ft,p / (fcc * bp) ⇒ x = Ft,p / (fcc * (Pdim + 2x))
⇒ x = (-Pdim / 4) +- √((-Pdim / 4)² + (Ft,p / 2 fcc)) I vårt fall kommer vi alltid
att få ett positivt och ett negativt x-värde i 2:a-gradsekvationen. Räknar dock bara med det positiva talet.
Ft,p = 2 * (Q / 4) * (a / (d – x / 2))
Vid omvandling av de teoretiska beräkningarna till koder i Visual Basic, använder vi oss även här av en så kallad ”loop” för att få ett noggrannare värde på Ft,p.
26 Felmarg = 1 Do Until Felmarg <= 0.001 X1 = ((-Pdim / 4) + ((Pdim / 4) ^ 2 + ((Ftp1 / 1000) / (2 * fcc))) ^ 0.5) Ftp0 = ((Q / 4) * 2 * a) / (d - (X1 / 2)) Felmarg = Ftp – Ftp0 Ftp = Ftp0 Loop Tryckzonsbredden (bp): bp = (Pdim + 2x) ⇒ bp = Pdim + (2 * X1) Effektiv betongarea (Aef): Aef = (c + ∅ / 2) * 2 * b ⇒ Aef = (Ingjut + 1.5 * fi + 10) * 2 * b Geometriska armeringsinnehållet (ρr): ρr = Total As / Aef ⇒ Rår = TA / Aef * 1000
Koefficint som beaktar töjningsfördelningen inom Aef (κ2):
κ2 = 0,25 * (1 – ((u + a) / (h – x)) ⇒
KAPPA2 = 0.25 * (1 - ((Ingjut + 1.5 * fi + 10) / (h - X1 * 1000))) Medelsprickavståndet (Srm):
Srm = 50 + κ1 * κ2 * (∅ / ρr) ⇒ Srm = 50 + KAPPA1 * KAPPA2 * (fi /
/ (Rår / 1000)) Armeringspåkänning i sprickan (σs):
σs = Ft,p * (1 / Total As) ⇒ SIGMAs = (Ftp / 1000) * (1 / (TA /
/ 1000000)) Sprickbredden (Wk):
Wk = 1,7 * ν * Srm * (σs / Es) ⇒ Wk = 1.7 * 1 * Srm * SIGMAs / 200000
Armeringsarea med hänsyn till sprickbildning (As):
As = (Wk / Wk,tillåten) * Total As
Vilken armeringsarea som krävs med avseende på sprickbildning, beror på sprickbredden (Wk) och tillåten sprickbredd (Wk,tillåten). Eftersom armeringsarean beror på vilken
livslängdsklass och miljöklass konstruktionen dimensioneras för, har vi valt att använda oss av en ”If-sats” för att programmet skall välja rätt värden.
Vid beräkning med miljöklass A1 blir armeringsarean med avseende på sprickbildning den samma som den tidigare uträknade totala armeringsarean.
If Option1.Value = True Then NyttA = (Wk / Wk) * TA Wkmax = Wk
End If
Vid beräkning med miljöklass A2 och livslängdsklass L1 blir Wk,tillåten (Wkmax) = 1,5 * 0,4,
se [6]. Armeringsarean med avseende på sprickbildning beräknas vid dessa förutsättningar genom att först dividera Wk med Wk,tillåten och därefter multiplicera med den tidigare
uträknade totala armeringsarean.
If Option2.Value = True And Option5.Value = True Then NyttA = (Wk / (1.5 * 0.4)) * TA
Wkmax = 1.5 * 0.4 End If
Övriga kombinationer av miljöklasser och livslängdsklasser kan skådas i [7]
För att beräkna hur många armeringsjärn som krävs, använder vi oss av samma formler som i 2.3.1 ”4-Pålarsystem” (Dimensioner och armering – Antal armeringsjärn (n)).
Total armeringsarea (Total As):
Total As = n * ∅ * ∅ * π / 4 ⇒ NyttTA = Nyttn * fi * fi * pi / 4
Om Wk > Wk,tillåten beräknas ett nytt Wk med avseende på den totala armeringsarean för
sprickbildning. Beräkningarna från det geometriska armeringsinnehållet (ρr) till den totala
armeringsarean (Total As) upprepas tills Wk≤ Wk,tillåten. Vi gör detta för att inte onödigt
mycket armering skall användas. Vid programmeringen har vi använt oss av en ”loop” för att få programmet att räkna samma formler om och om igen tills Wk≤ Wk,tillåten. Hur ”loopen” ser
ut beskrivs i [7].
Armeringens centrumavstånd (cc):
Beräkningar enligt 2.3.1 ”4-Pålarsystem” (Dimensioner och armering – Armeringens centrumavstånd (cc)). Hur koderna är skrivna kan ses i [7].
28 Kontroll av spjälkning
FR = 0,75 * a * b * fct ⇒ Fr1 = 0.75 * e * g * fct
För att inte förväxla olika a- och b-värden, har vi valt att istället benämna dem med e respektive g
e = langd g = b
b får ej < 8 * b1 och ej > 30 * b1 ⇒ If g < (8 * Pdim * 1000) Then
g = (8 * Pdim * 1000) End If If g > (30 * Pdim * 1000) Then g = (30 * Pdim * 1000) End If FR= (0,5 + β) * A * fcc ⇒ Fr2 = (0.5 + Beta) * Tryckyta * fcc β = 0,5 ⇒ Beta = 0.5
Vi får alltid att tryckytan ligger inom ytan A1, se 2.2.4 ”Spjälkning”.
A = Pdim * Pdim ⇒ Tryckyta = (Pdim * 1000 * Pdim * 1000)
Till skillnad från 2.3.1 ”4-pålsystem - Spjälkning” beräknas Fs som Mtp * antal pålar, istället
för Qb.
Fs = Mtp * antal pålar ⇒ Fs = (Mtp * 1000 * Val(Combo4.Text))
Om Fs < FR finns ingen risk för spjälkning, men om Fs > FR finns det risk för spjälkning
If Fr1 > Fs Then
Label23.Caption = "Ingen risk för spjälkning!" Else
If Fr2 > Fs Then
Label23.Caption = "Ingen risk för spjälkning!" Else
Label23.Caption = "Risk för spjälkning!" End If
End If
5.2.2 2-Pålarsystem
Beräkningsgång sker enligt 2.3.2 “2-Pålarsystem” och programkoder skrivs enligt 5.2.1 ”4-Pålarsystem”, dock med vissa förändringar beroende på att det är 2-pålarsystem.
Om antalet pålar är valt till 2 stycken, skall programmet beräkna enligt 2-pålarsberäkning: If Combo4.Text = "2" Then
Effektiv platthöjd (d):
d = a ⇒ d = a
Fundamentets längd (l):
l = Ingjutningsavstånd * 2 ⇒ langd = Ingjutningsavstand * 2 Dragkraft i armeringen (Ft,p):
Ft,p = Qp * (a / z) ⇒ Ftp1 = Mtp * (a / z)
Ft,p = Qp * (a / (d – x / 2)) ⇒ Ftp2 = Mtp * (a / (d - (X2 / 2)))
Dragkraft i armeringen (Ft,p) vid sprickbildning:
Ft,p = (QL / 2) * (a / z) ⇒ Ftp = ((QL / 2) * a) / (0.9 * d)
Ft,p = (QL / 2) * (a / (d – x / 2)) ⇒ Ftp0 = ((QL / 2) * a) / (d - (X1 /
/ 2))
5.2.3 3-Pålarsystem
Beräkningsgång sker enligt 2.3.3 “3-Pålarsystem” och programkoder skrivs enligt 5.2.1 ”4-Pålarsystem”, dock med vissa förändringar beroende på att det är 3-pålarsystem.
Förändringarna är följande:
Om antalet pålar är valt till 3 stycken skall, programmet beräkna enligt 3-pålarsberäkning: If Combo4.Text = "3" Then
Inre hävarm (a):
a = (2 / 3) * (s * sin 60grader) – (Pdim / 4) * 0,1 ⇒ a = ((2 / 3) * s3) - (Pdim /
/ 4) + 0.1
s * sin 60grader ⇒ s3 = s * sin60
Effektiv platthöjd (d):
d = a ⇒ d = a
Dragkraft i armeringen (Ft,p):
30
Ft,p = Qp * (a / (d – x / 2)) ⇒ Ftp2 = Mtp * (a / (d –
- (X2 / 2))) Dragkraft i armeringen (Ft,p) vid sprickbildning:
Ft,p = (QL / 3) * (a / z) ⇒ Ftp = ((QL / 3) * a) /
/ (0.9 * d)
Ft,p = (QL / 3) * (a / (d – x / 2)) ⇒ Ftp0 = ((QL / 3) * a) /
/ (d - (X1 / 2))
5.2.4 Varningsskyltar
Vid ett fåtal tillfällen skall programmet angående pålfundament säga ifrån. Detta på grund av att det inte kan räkna med vissa värden. På skärmen ses detta i form av en varningsskylt (se Figur 13).
Figur 13: Varningsskylt. Källa: Dahlqvist & Parbrand (2000).
Ett tillfälle då en varningsskylt skall komma upp på skärmen som en MsgBox
(meddelanderuta), är när ett för högt ekvivalent Vattencementtal (Vcte) är valt tillsammans
med miljöklass A3 eller A4. I programmet skrivs detta med följande kod (lite förkortad variant, hela koden finns i [7]):
If Option3.Value = True And Combo5.Text > "0.45" Then msg = "För stort VCTe är valt."
msg = msg + Chr$(13)
msg = msg + "Vid miljöklass A3 får EJ VCTe vara > 0.45." MsgBox msg, 48, "VARNING"
Else
If Option4.Value = True And Combo5.Text > "0.40" Then msg = "För stort VCTe är valt."
msg = msg + Chr$(13)
msg = msg + "Vid miljöklass A4 får EJ VCTe vara > 0.40." MsgBox msg, 48, "VARNING"
End If End If
Ett annat tillfälle då en varningsskylt skall visas på skärmen är vid val av armeringsdiameter 32 mm och Ks60 / Ks60S då fst = 0. Detta på grund av att det blir division med noll i en
”lurar” vi programmet genom att sätta fst = 1. Programmet ”körs” då helt igenom och beräknar
olika ekvationer. Dessa är dock fel, på grund av att ett felaktigt fst används.
If Combo1.Text = "Ks60" And Combo6.Text = "32" Then fst = 1
End If
If Combo1.Text = "Ks60S" And Combo6.Text = "32" Then fst = 1
End If
Trots att programmet får fram en rad olika resultat, kommer resultatrutorna på skärmen att vara tomma (Text1.Text = ""). Följande kod skrivs för denna varningsskylt:
If Combo1.Text = "Ks60" And Combo6.Text = "32" Then msg = "För stor armeringsdiameter är vald."
msg = msg + Chr$(13)
msg = msg + "Armeringsdiamtern ska vara mellan" msg = msg + Chr$(13)
msg = msg + "10-25 mm vid val av armering Ks60" msg = msg + Chr$(13) msg = msg + "och Ks60S." MsgBox msg, 48, "VARNING" Text1.Text = "" Text8.Text = "" Text9.Text = "" Text12.Text = "" Text13.Text = "" Text15.Text = "" Text17.Text = "" Text18.Text = "" Text19.Text = "" Text23.Text = "" Text25.Text = "" Text26.Text = "" Else
If Combo1.Text = "Ks60S" And Combo6.Text = "32" Then msg = "För stor armeringsdiameter är vald."
msg = msg + Chr$(13)
msg = msg + "Armeringsdiamtern ska vara mellan" msg = msg + Chr$(13)
msg = msg + "10-25 mm vid val av armering Ks60" msg = msg + Chr$(13) msg = msg + "och Ks60S." MsgBox msg, 48, "VARNING" Text1.Text = "" Text8.Text = "" Text9.Text = "" Text12.Text = "" Text13.Text = "" Text15.Text = ""
32 Text17.Text = "" Text18.Text = "" Text19.Text = "" Text23.Text = "" Text25.Text = "" Text26.Text = "" End If End If
5.2.5 Resultat och utskrift
Resultatet som visas på skärmen är endast det väsentligaste (se Figur 14).
Figur 14: Resultat pålfundament. Källa: Dahlqvist & Parbrand (2000).
Vid utskrift av resultat på papper, har vi valt att visa den indata som skrivs in, samt ett resultat som är mer detaljerat än det som visas på skärmen. När utskriftsknappen aktiveras kommer ett nytt fönster att visas på skärmen. Här skrivs den information om arbetet som kommer att visas på utskriften (se Figur 15). Exempel på hur ett resultat kan se ut vid utskrift finns i [8].
Figur 15: Informationsruta. Källa: Dahlqvist & Parbrand (2000).
När vi programmerar koder för hur resultatet skall se ut vid utskrift, väljer vi att programmera på följande sätt:
Printer.Print "x", " = "; , Format(X1, "#0.000"); " m", , , , "(Tryckzonshöjd)" Printer.Print
Printer.Print "bp", " = "; , Format(bp, "#0.000"); " m", , , , "(Tryckzonsbredd)" Printer.Print = Kommando för utskrift
”x” = Visar vad som skall vara beskrivet på papper, i det här fallet x Format(X1, ”#0.000”)= Visar vilket värde x skall ha. I detta fall har resultatet valts att
visas med tre decimaler
Om man vill hoppa över en rad görs detta genom att endast skriva kommandot Printer.Print. Samtliga koder för utskrift finns i [7].
5.3
Programmering av felslagning
I Figur 17 visas hur layouten för felslagningsprogrammet ser ut. Här skrivs vilken ingångsdata programmet skall beräkna efter. Vid uppstart av programmet finns här, som i 5.2
34
Figur 16: Layout för ingångsdata, felslagning. Källa: Dahlqvist & Parbrand (2000).
5.3.1 Beräknings- och programmeringsgång
Beräkningsgången sker enligt 3.2 ”Beräkningsexempel” Följande indata skrivs in:
Antal pålar som pålgruppen innehåller (deras kapacitet och koordinater), önskade
tyngdpunktskoordinater för pålgruppen samt vilken kapacitet som den nya pålen skall ha. Vid val av n pålar finns det automatiskt utrymme för n pålar i ComboBoxen och påldata skall kunna fyllas i för varje påle i textrutor. Koden för detta är:
Private Sub textAntalpalar_Change() npalar = Val(TextAntalpalar.Text) ReDim F(npalar) ReDim X(npalar) ReDim Y(npalar) Combo1.Clear For i = 1 To npalar Combo1.AddItem i Next i Combo1.Text = "1" End Sub
Nedan visas hur ∑(Fi * x), ∑F och ∑(Fi * y) programmeras som koder. Hur dessa formler
SUMMAX = 0 SUMMAY = 0 SF = 0
For i = 1 To npalar
SUMMAX = SUMMAX + (F(i) * X(i)) SF = SF + F(i)
SUMMAY = SUMMAY + (F(i) * Y(i)) Next i
Från formeln xtp = ∑(Fi * x) / ∑F beräknas ett nytt x. Formeln tar hänsyn till den nya pålen.
Textnyttx.Text = Format((((Val(TextOnskatx.Text) * (SF + Val(TextFny.Text))) -- SUMMAX)) / Val(TextFny.Text), "#0.000")
Från formeln ytp = ∑(Fi * y) / ∑F beräknas ett nytt y. Formeln tar hänsyn till den nya pålen.
Textnytty.Text = Format((((Val(TextOnskaty.Text) * (SF + Val(TextFny.Text))) -- SUMMAY)) / Val(TextFny.Text), "#0.000")
5.3.2 Resultat och utskrift
Resultat och utskrift för felslagning utförs enligt 5.2.5 ”Resultat och utskrift”, dock med skillnaden att det utskrivna resultatet är det samma som visas på skärmen. Exempel på utskrift av felslagning kan skådas i [9].
6
Analys- och diskussionsavsnitt
Syftet med detta kapitel är att jämföra empirin med teorin. Vi kommer även att diskutera för-och nackdelar med vårt dataprogram.
6.1
Analys och diskussion av empirin jämfört med teorin
Vid jämförelse mellan teori och empiri, har en del ändringar gjorts på grund av att KM:s (Kjessler & Mannerstråle) beräkningsgång skiljer från betonghandbokens sätt att beräkna pålfundament.
Vid 3-pålarsystem kan fundamentet utformas kvadratiskt eller triangulärt. Vi har i samråd med KM valt att göra dem kvadratiska. Varför vi gjort dem kvadratiska, se 2.3.3 ”3-Pålarsystem”. I det teoretiska beräkningsexemplet, beträffande pålfundament, har
fundamentets bredd, längd och höjd antagits från början. Sett till verkligheten är detta inte realistiskt. Vi har istället räknat ut dessa mått. Det samma gäller vid beräkning av
pålfundamentets egenvikt, som i exemplet antagits vara medräknat i den totala kraften (Qp).
För att göra det enklare för konstruktören som använder dataprogrammet, har vi räknat ut egenvikten för sig och sedan adderat den med kraften (QL). En annan förändring vi gjort i
jämförelse med teorin, är att vi vid uträkning av armeringsarean i ”Dimensioner och
armering” har dimensionerat pålfundamentet för den maximala last som varje påle klarar av istället för den kraft som kommer uppifrån (pelarlast). Detta medför att pålarna och
pålfundamentet klarar av lika stora krafter. Ytterligare en detalj som vi beräknat, men som inte redovisas i teorin, är att vi redovisar centrumavståndet mellan armeringsjärnen. I 2.2.2 ”Förankring” beräknas förstoringsfaktorn, η2 med minsta täckskikt enligt figur 5. I våra
beräkningar använder vi oss här alltid av täckskikt, c1, oberoende om övriga täckskikt är
mindre. Detta har gjorts i samråd med KM för att förenkla våra programmeringskoder.
När det gäller beräkning av felslagning skiljer inget mellan empiri och teori, eftersom vi redan i teorin har följt KM:s beräkningsgång. I databeräkningarna för pålfundament har vi redan fyllt i standardvärden för att slippa ”debug”. Standardvärden har även fyllts i vid
databeräkningarna för felslagning, men i detta fall kan ej ”debug” förhindras om något värde glömts fyllas i. Vi har angett som standardvärde att programmet skall utföra beräkningar för två pålar men programmet räknar endast med en påle, eftersom vi inte har kunskap i att programmera standardvärden för mer än en påle.
Under arbetets gång har våra kunskaper i programmeringsspråket Visual Basic blivit bättre och bättre. Från att ha haft ytterst liten kännedom i programmeringsspråket har vi nu lärt oss grunderna. Hade vi haft dessa grunder att ”stå på” från början hade vi programmerat på ett annorlunda sätt. Som resultatet av dataprogrammet ser ut i färdigt skick, kan vi konstatera att stora nedskärningar av programkoder kan göras. Ett exempel på att vi utvecklats beskrivs i 5.1 ”Allmänt om kodskrivning”, där vi visar hur deklarationer kan göras på två olika sätt.
När vi antog detta examensarbete visste vi inte vilket programmeringsspråk vi skulle använda oss av. Varför vi valde Visual Basic beror på att KM använt sig av det tidigare, och att de tyckte att språket var relativt enkelt.
7 Slutsatsavsnitt
Syftet med detta kapitel är att framföra de slutsatser som vi kommit fram till under arbetets gång.
Efter att ha programmerat i Visual Basic under en längre tid, kan vi konstatera att det är relativt enkelt för nybörjare att lära sig grunderna i programmet. Dataprogram är ett väldigt bra hjälpmedel för konstruktörer. Mycket tid sparas in på grund av att vid databeräkningar anges endast vissa värden som programmet skall beräkna efter, istället för att konstruktören utför dessa beräkningar manuellt. Med hjälp av de angivna värdena utför programmet nödvändiga beräkningar och kommer fram till ett svar. Eftersom tid sparas blir kostnaderna betydligt lägre för de som anställer konsulter att utföra arbetet.
Ett annat konstaterande som vi gjort är att konstruktörer inte följer Betonghandboken till ”punkt och pricka”, utan beräknar även efter ”bättre metoder” från egna erfarenheter. Den slutliga slutsatsen är att vi efter 10 veckors arbete lyckats få fram ett dataprogram för beräkning av pålfundament och felslagning.
38
Referenser
Boverket, Byggavdelningen (1994) Boverkets handbok om betongkonstruktioner, Band 1 – Konstruktion. 1:a upplagan. Karlskrona. ISBN 91-7332-686-0.
Boverket, Byggavdelningen (1994) Boverkets handbok om betongkonstruktioner, Band 2 – Material, Utförande, Kontroll. 1:a upplagan. Karlskrona. ISBN 91-7332-687-9.
Cederwall, Lorentsen, Östlund (1990) Betonghandbok – Konstruktion. 2:a upplagan. Solna. ISBN 91-7332-533-3.
Dahlqvist & Parbrand (2000), Linköping.
Holm, Olsson (1993) Pålgrundläggning. Linköping. ISBN 91-7332-663-1. KM (Kjessler & Mannerstråle)
Kölfors, Johan (1993) Genomstansning av betongplattor – en jämförelse av några europeiska normer. Lund, Studentlitteratur. ISSN 0349-4969.
Langesten, Bengt (1995) Byggkonstruktion 3 – Betongkonstruktion. 5:e upplagan. Gävle. ISBN 91-634-1284-5.
Microsoft Corporation (1991) Microsoft Visual Basic – Language Reference. USA. Document Number DB20664-0491.
Microsoft Corporation (1992) Programmer´s Guide - Microsoft Visual Basic, Version 3.0. 2:a upplagan. USA. Document Number DB51410-0993.
Peterson, Robin, Tjernlund (1997) Visual Basic – programutveckling från början. Lund, Studentlitteratur. ISBN 91-44-38871-3
Bilagor
BILAGA 1 VIDHÄFTNINGSFAKTOR... I
BILAGA 2 BETONGENS DIMENSIONERANDE TRYCK- OCH DRAGHÅLLFASTHET...II
BILAGA 3 ARMERINGENS DIMENSIONERANDE DRAGHÅLLFASTHET ... III
BILAGA 4 TÄCKSKIKT... IV BILAGA 5 ARMERING ...V BILAGA 6 SPRICKBILDNING... VI BILAGA 7 PROGRAMMERINGSKODER ... VII BILAGA 8A UTSKRIFT PÅLFUNDAMENT, 4-PÅLARSYSTEM ... LIII BILAGA 8B UTSKRIFT PÅLFUNDAMENT, 2-PÅLARSYSTEM ... LIV BILAGA 8C UTSKRIFT PÅLFUNDAMENT, 3-PÅLARSYSTEM ... LV BILAGA 9 UTSKRIFT FELSLAGNING ... LVI BILAGA 10 MILJÖKLASSER ...LVII BILAGA 11 ORDFÖRKLARINGAR ... LVIII
BILAGA 12 ALGORITM FÖR PÅLFUNDAMENT... LX
I
Bilagor
Bilaga 1
Vidhäftningsfaktor
Bilaga 2
Betongens dimensionerande tryck- och
draghållfasthet
III
