Vertikal Kurva Kalkylator för Civilingenjörskonst

Introduktion

En vertikal kurva kalkylator är ett viktigt verktyg inom civilingenjörskonst som hjälper ingenjörer att designa smidiga övergångar mellan olika väggrader. Vertikala kurvor är paraboliska kurvor som används inom väg- och järnvägsdesign för att skapa en gradvis förändring mellan två olika lutningar eller lutningar, vilket säkerställer bekväma körförhållanden och korrekt dränering. Denna kalkylator förenklar de komplexa matematiska beräkningarna som krävs för att designa vertikala kurvor, vilket gör att civilingenjörer, vägdesigners och byggproffs snabbt kan bestämma nyckelparametrar som kurvans höjder, hög- och lågpunkter samt K-värden.

Oavsett om du designar en motorväg, lokal väg eller järnväg är vertikala kurvor avgörande för säkerhet, förarens komfort och korrekt hantering av regnvatten. Denna omfattande kalkylator hanterar både toppkurvor (där vägen stiger och sedan faller) och sänkta kurvor (där vägen sjunker ner och sedan stiger), och tillhandahåller all nödvändig information som behövs för korrekt vertikal justering i transportingenjörsprojekt.

Grundläggande om Vertikala Kurvor

Vad är en Vertikal Kurva?

En vertikal kurva är en parabolisk kurva som används i den vertikala justeringen av vägar, motorvägar, järnvägar och annan transportinfrastruktur. Den ger en smidig övergång mellan två olika grader eller lutningar, vilket eliminerar den plötsliga förändringen som skulle inträffa om lutningarna möttes vid en punkt. Denna smidiga övergång är avgörande för:

Förarens komfort och säkerhet
Korrekt siktavstånd för förare
Effektivitet i fordonets drift
Effektiv dränering
Estetiskt utseende av vägen

Vertikala kurvor är vanligtvis paraboliska i form eftersom en parabel ger en konstant förändringshastighet i lutning, vilket resulterar i en smidig övergång som minimerar de krafter som upplevs av fordon och passagerare.

Typer av Vertikala Kurvor

Det finns två huvudsakliga typer av vertikala kurvor som används inom civilingenjörskonst:

Toppkurvor: Dessa inträffar när den initiala lutningen är större än den slutliga lutningen (t.ex. går från +3% till -2%). Kurvan bildar en kulle eller hög punkt. Toppkurvor designas främst baserat på krav på stopp-siktavstånd.
Sänkta Kurvor: Dessa inträffar när den initiala lutningen är mindre än den slutliga lutningen (t.ex. går från -2% till +3%). Kurvan bildar en dal eller låg punkt. Sänkta kurvor designas vanligtvis baserat på siktavstånd för strålkastare och dräneringsöverväganden.

Nyckelparametrar för Vertikala Kurvor

För att helt definiera en vertikal kurva måste flera nyckelparametrar fastställas:

Initial Lutning (g₁): Lutningen av vägen innan den går in i kurvan, uttryckt i procent
Slutlig Lutning (g₂): Lutningen av vägen efter att den lämnat kurvan, uttryckt i procent
Kurvlängd (L): Det horisontella avståndet över vilket den vertikala kurvan sträcker sig, vanligtvis mätt i meter eller fot
PVI (Punkt för Vertikal Intersektion): Den teoretiska punkten där de två tangentlutningarna skulle korsa varandra om det inte fanns någon kurva
PVC (Punkt för Vertikal Kurva): Startpunkten för den vertikala kurvan
PVT (Punkt för Vertikal Tangent): Slutpunkten för den vertikala kurvan
K Värde: Det horisontella avståndet som krävs för att uppnå en 1% förändring i lutning, ett mått på kurvans platthet

Matematiska Formler

Grundläggande Vertikal Kurva Ekvation

Höjden vid vilken punkt som helst längs en vertikal kurva kan beräknas med hjälp av den kvadratiska ekvationen:

$y = y_{PVC} + g_1 \cdot x + \frac{A \cdot x^2}{2L}$

Där:

$y$ = Höjd vid avståndet $x$ från PVC
$y_{PVC}$ = Höjd vid PVC
$g_1$ = Initial lutning (decimaltal)
$x$ = Avstånd från PVC
$A$ = Algebraisk skillnad i lutningar ( $g_2 - g_1$ )
$L$ = Längd på den vertikala kurvan

K Värde Beräkning

K-värdet är ett mått på kurvans platthet och beräknas som:

$K = \frac{L}{|g_2 - g_1|}$

Där:

$K$ = Grad av vertikal krökning
$L$ = Längd på den vertikala kurvan
$g_1$ = Initial lutning (procent)
$g_2$ = Slutlig lutning (procent)

Högre K-värden indikerar plattare kurvor. Designstandarder specificerar ofta minimik-värden baserat på designhastighet och kurvtyp.

Hög-/Lågpunkt Beräkning

För toppkurvor där $g_1 > 0$ och $g_2 < 0$ , eller sänkta kurvor där $g_1 < 0$ och $g_2 > 0$ , kommer det att finnas en hög eller låg punkt inom kurvan. Stationen för denna punkt kan beräknas som:

$Station_{HL} = Station_{PVC} + \frac{-g_1 \cdot L}{g_2 - g_1}$

Höjden vid denna hög-/lågpunkt beräknas sedan med hjälp av den grundläggande vertikala kurvaekvationen.

PVC och PVT Beräkningar

Givet PVI-stationen och höjden kan PVC och PVT beräknas som:

$Station_{PVC} = Station_{PVI} - \frac{L}{2}$

$Elevation_{PVC} = Elevation_{PVI} - \frac{g_1 \cdot L}{200}$

$Station_{PVT} = Station_{PVI} + \frac{L}{2}$

$Elevation_{PVT} = Elevation_{PVI} + \frac{g_2 \cdot L}{200}$

Observera: Divisionen med 200 i höjdformlerna tar hänsyn till omvandlingen av lutning från procent till decimaltal och halvlängden av kurvan.

Gränsfall

Lika Lutningar (g₁ = g₂): När den initiala och slutliga lutningen är lika behövs ingen vertikal kurva. K-värdet blir oändligt, och "kurvan" är faktiskt en rak linje.
Mycket Små Lutningsskillnader: När skillnaden mellan lutningar är mycket liten blir K-värdet mycket stort. Detta kan kräva justeringar av kurvlängden för praktisk implementering.
Kurvor med Noll Längd: En vertikal kurva med noll längd är matematiskt ogiltig och bör undvikas i design.

Hur man Använder Vertikal Kurva Kalkylatorn

Vår vertikal kurva kalkylator förenklar dessa komplexa beräkningar och gör att du snabbt kan bestämma alla nyckelparametrar för din vertikala kurvdesign. Här är hur du använder den:

Steg 1: Ange Grundläggande Kurvparametrar

Ange Initial Lutning (g₁) i procentform (t.ex. 2 för en 2% uppförsbacke, -3 för en 3% nedförsbacke)
Ange Slutlig Lutning (g₂) i procentform
Ange Kurvlängd i meter
Specificera PVI Station (stationsvärdet vid den vertikala intersektionen)
Ange PVI Höjd i meter

Steg 2: Granska Resultaten

Efter att ha angett de nödvändiga parametrarna kommer kalkylatorn automatiskt att beräkna och visa:

Kurvtyp: Om kurvan är en topp, sänk eller ingen
K Värde: Graden av vertikal krökning
PVC Station och Höjd: Startpunkten för kurvan
PVT Station och Höjd: Slutpunkten för kurvan
Hög-/Lågpunkt: Om tillämpligt, stationen och höjden för den högsta eller lägsta punkten på kurvan

Steg 3: Fråga Specifika Stationer

Du kan också fråga om höjden vid en specifik station längs kurvan:

Ange Fråga Station värdet
Kalkylatorn kommer att visa den motsvarande höjden vid den stationen
Om stationen ligger utanför kurvans gränser kommer kalkylatorn att indikera detta

Steg 4: Visualisera Kurvan

Kalkylatorn tillhandahåller en visuell representation av den vertikala kurvan, som visar:

Kurvprofilen
Nyckelpunkter (PVC, PVI, PVT)
Hög eller låg punkt (om tillämpligt)
Tangentlutningar

Denna visualisering hjälper dig att förstå kurvans form och verifiera att den uppfyller dina designkrav.

Användningsfall och Tillämpningar

Beräkningar av vertikala kurvor är avgörande i många civilingenjörstillämpningar:

Motorvägs- och Vägdesign

Vertikala kurvor är grundläggande komponenter i vägdesign, vilket säkerställer säkra och bekväma körförhållanden. De används för att:

Skapa smidiga övergångar mellan olika väggrader
Säkerställa tillräckligt siktavstånd för förare
Tillhandahålla korrekt dränering för att förhindra vattenansamling
Uppfylla designstandarder och specifikationer för olika vägklassificeringar

Till exempel, när man designar en motorväg som behöver korsa kuperad terräng, måste ingenjörer noggrant beräkna vertikala kurvor för att säkerställa att förare har tillräckligt siktavstånd för att stanna säkert om ett hinder dyker upp på vägen.

Järnvägsdesign

Inom järnvägsingenjörskonst är vertikala kurvor avgörande för:

Att säkerställa smidig tågdrift
Minimera slitage på spår och tågdela
Upprätthålla passagerarkomfort
Möjliggöra korrekt drift vid designhastigheter

Järnvägsvertikala kurvor har ofta större K-värden än vägar på grund av den begränsade förmågan hos tåg att navigera branta lutningsförändringar.

Flygplatslandningsbana Design

Vertikala kurvor används i designen av flygplatslandningsbanor för att:

Säkerställa korrekt dränering av landningsbanans yta
Tillhandahålla tillräckligt siktavstånd för piloter
Uppfylla FAA- eller internationella luftfartsmyndigheters krav
Underlätta smidiga start- och landningsförhållanden

Markutveckling och Platsgradering

Vid utveckling av mark för byggprojekt hjälper vertikala kurvor att:

Skapa estetiskt tilltalande landformer
Säkerställa korrekt hantering av regnvatten
Minimera mängden jordarbete
Tillhandahålla tillgängliga vägar som uppfyller ADA-krav

Dräneringssystem för Regnvatten

Vertikala kurvor är avgörande i designen av:

Dräneringskanaler
Kulvertar
Regnvattenmagasin
Avloppssystem

Korrekt design av vertikala kurvor säkerställer att vatten flödar med lämpliga hastigheter och förhindrar sedimentation eller erosion.

Alternativ till Parabolisk Vertikal Kurvor

Även om paraboliska vertikala kurvor är standard i de flesta civilingenjörstillämpningar, finns det alternativ:

Cirkulära Vertikala Kurvor: Används i vissa äldre designer och i vissa internationella standarder. De ger en varierande förändringshastighet i lutning, vilket kan vara mindre bekvämt för förare.
Klothoid eller Spiral Kurvor: Används ibland i specialiserade tillämpningar där en gradvis ökande förändringshastighet önskas.
Kubiska Paraboler: Används ibland för speciella situationer där mer komplexa kurvegenskaper behövs.
Raka Linje Approximationer: I mycket preliminära designer eller för mycket platt terräng kan enkla raka linjeanslutningar användas istället för verkliga vertikala kurvor.

Den paraboliska vertikala kurvan förblir standard för de flesta tillämpningar på grund av sin enkelhet, konsekventa förändringshastighet och väletablerade designprocedurer.

Historia av Vertikal Kurva Design

Utvecklingen av metoder för vertikal kurvdesign har utvecklats i takt med transportingenjörskonst:

Tidig Vägdesign (Före 1900-talet)

I tidig vägkonstruktion bestämdes vertikala justeringar ofta av den naturliga terrängen med minimal gradering. När fordon blev snabbare och mer vanliga blev behovet av mer vetenskapliga metoder för vägdesign uppenbart.

Utveckling av Paraboliska Kurvor (Tidigt 1900-tal)

Den paraboliska vertikala kurvan blev standard i början av 1900-talet när ingenjörer insåg dess fördelar:

Konstant förändringshastighet i lutning
Relativt enkla matematiska egenskaper
Bra balans mellan komfort och byggbarhet

Standardisering (Mitten av 1900-talet)

Vid mitten av 1900-talet började transportmyndigheter utveckla standardiserade tillvägagångssätt för vertikal kurvdesign:

AASHTO (American Association of State Highway and Transportation Officials) etablerade riktlinjer för minimik-värden baserat på stopp-siktavstånd
Liknande standarder utvecklades internationellt
Siktavstånd blev en primär faktor vid bestämning av kurvlängder

Moderna Beräkningsmetoder (Sent 1900-tal till Nutid)

Med datorernas framväxt blev vertikal kurvdesign mer sofistikerad:

Datorstödd design (CAD) mjukvara automatiserade beräkningar
3D-modellering möjliggjorde bättre visualisering och integration med horisontell justering
Optimeringsalgoritmer hjälpte till att hitta de mest effektiva vertikala justeringarna

Idag fortsätter vertikal kurvdesign att utvecklas med ny forskning om förarbeteende, fordynamik och miljöhänsyn.

Vanliga Frågor

Vad är ett K-värde i vertikal kurvdesign?

K-värdet representerar det horisontella avståndet som krävs för att uppnå en 1% förändring i lutning. Det beräknas genom att dividera längden på den vertikala kurvan med den absoluta skillnaden mellan den initiala och slutliga lutningen. Högre K-värden indikerar plattare, mer gradvisa kurvor. K-värden specificeras ofta i designstandarder baserat på designhastighet.

Hur bestämmer jag om jag behöver en topp- eller sänkt vertikal kurva?

Typen av vertikal kurva beror på förhållandet mellan den initiala och slutliga lutningen:

Om den initiala lutningen är större än den slutliga lutningen (g₁ > g₂), behöver du en toppkurva
Om den initiala lutningen är mindre än den slutliga lutningen (g₁ < g₂), behöver du en sänkt kurva
Om den initiala och slutliga lutningen är lika (g₁ = g₂), behövs ingen vertikal kurva

Vilket minimik-värde bör jag använda för min design?

Minimik-värden beror på designhastighet, kurvtyp och tillämpliga designstandarder. Till exempel tillhandahåller AASHTO tabeller med minimik-värden baserat på stopp-siktavstånd för toppkurvor och strålkastarsiktavstånd för sänkta kurvor. Högre designhastigheter kräver större K-värden för att säkerställa säkerhet.

Hur beräknar jag hög- eller lågpunkten för en vertikal kurva?

Högpunkten (för toppkurvor) eller lågpunkten (för sänkta kurvor) inträffar där lutningen längs kurvan är noll. Detta kan beräknas med formeln:

$Station_{HL} = Station_{PVC} + \frac{-g_1 \cdot L}{g_2 - g_1}$

Hög/lågpunkt existerar endast inom kurvan om denna station ligger mellan PVC och PVT.

Vad händer om den initiala och slutliga lutningen är lika?

Om den initiala och slutliga lutningen är lika behövs ingen vertikal kurva. Resultatet är helt enkelt en rak linje med en konstant lutning. I detta fall skulle K-värdet teoretiskt vara oändligt.

Hur påverkar längden på en vertikal kurva förarens komfort?

Längre vertikala kurvor ger mer gradvisa övergångar mellan lutningar, vilket resulterar i större förarkomfort. Korta vertikala kurvor kan skapa plötsliga förändringar i vertikal acceleration, vilket kan vara obekvämt för förare och passagerare. Den lämpliga kurvlängden beror på designhastighet, lutningsskillnad och platsbegränsningar.

Kan vertikala kurvor ha noll längd?

Matematiskt kan en vertikal kurva inte ha noll längd, eftersom detta skulle skapa en omedelbar förändring i lutning, vilket inte är en kurva. I praktiken kan mycket korta vertikala kurvor användas i låghastighetsmiljöer, men de bör fortfarande ha tillräcklig längd för att ge en smidig övergång.

Hur påverkar vertikala kurvor dränering?

Vertikala kurvor påverkar riktningen och hastigheten på vattenflödet på vägar. Toppkurvor underlättar vanligtvis dränering genom att rikta bort vatten från högpunkten. Sänkta kurvor kan skapa potentiella dräneringsproblem vid lågpunkten, vilket ofta kräver ytterligare dräneringsstrukturer som inlopp eller kulvertar.

Vad är skillnaden mellan PVI, PVC och PVT?

PVI (Punkt för Vertikal Intersektion): Den teoretiska punkten där de förlängda initiala och slutliga lutningslinjerna skulle korsa varandra
PVC (Punkt för Vertikal Kurva): Startpunkten för den vertikala kurvan
PVT (Punkt för Vertikal Tangent): Slutpunkten för den vertikala kurvan

I en standard symmetrisk vertikal kurva ligger PVC vanligtvis halva kurvlängden före PVI, och PVT ligger halva kurvlängden efter PVI.

Hur noggranna är beräkningarna av vertikala kurvor?

Moderna beräkningar av vertikala kurvor kan vara extremt noggranna när de utförs korrekt. Men byggtoleranser, fältförhållanden och avrundningar i beräkningarna kan introducera små variationer. För de flesta praktiska syften är beräkningar till närmaste centimeter eller hundradel av en fot tillräckliga för höjder.

Kodexempel

Här är exempel på hur man beräknar vertikala kurvparametrar i olika programmeringsspråk:

1' Excel VBA Funktion för att beräkna höjd vid vilken punkt som helst på en vertikal kurva
2Function VerticalCurveElevation(initialGrade, finalGrade, curveLength, pvcStation, pvcElevation, queryStation)
3    ' Konvertera lutningar från procent till decimal
4    Dim g1 As Double
5    Dim g2 As Double
6    g1 = initialGrade / 100
7    g2 = finalGrade / 100
8    
9    ' Beräkna algebraisk skillnad i lutningar
10    Dim A As Double
11    A = g2 - g1
12    
13    ' Beräkna avstånd från PVC
14    Dim x As Double
15    x = queryStation - pvcStation
16    
17    ' Kontrollera om stationen är inom kurvans gränser
18    If x < 0 Or x > curveLength Then
19        VerticalCurveElevation = "Utanför kurvans gränser"
20        Exit Function
21    End If
22    
23    ' Beräkna höjd med hjälp av vertikal kurvaekvationen
24    Dim elevation As Double
25    elevation = pvcElevation + g1 * x + (A * x * x) / (2 * curveLength)
26    
27    VerticalCurveElevation = elevation
28End Function
29
30' Funktion för att beräkna K-värde
31Function KValue(curveLength, initialGrade, finalGrade)
32    KValue = curveLength / Abs(finalGrade - initialGrade)
33End Function
34

1import math
2
3def calculate_k_value(curve_length, initial_grade, final_grade):
4    """Beräkna K-värdet för en vertikal kurva."""
5    grade_change = abs(final_grade - initial_grade)
6    if grade_change < 0.0001:  # Undvik division med noll
7        return float('inf')
8    return curve_length / grade_change
9
10def calculate_curve_type(initial_grade, final_grade):
11    """Bestämma om kurvan är en topp, sänk eller ingen."""
12    if initial_grade > final_grade:
13        return "topp"
14    elif initial_grade < final_grade:
15        return "sänk"
16    else:
17        return "ingen"
18
19def calculate_elevation_at_station(station, initial_grade, final_grade, 
20                                  pvi_station, pvi_elevation, curve_length):
21    """Beräkna höjd vid vilken station som helst längs en vertikal kurva."""
22    # Beräkna PVC och PVT stationer
23    pvc_station = pvi_station - curve_length / 2
24    pvt_station = pvi_station + curve_length / 2
25    
26    # Kontrollera om stationen är inom kurvans gränser
27    if station < pvc_station or station > pvt_station:
28        return None  # Utanför kurvans gränser
29    
30    # Beräkna PVC höjd
31    g1 = initial_grade / 100  # Konvertera till decimal
32    g2 = final_grade / 100    # Konvertera till decimal
33    pvc_elevation = pvi_elevation - (g1 * curve_length / 2)
34    
35    # Beräkna avstånd från PVC
36    x = station - pvc_station
37    
38    # Beräkna algebraisk skillnad i lutningar
39    A = g2 - g1
40    
41    # Beräkna höjd med hjälp av vertikal kurvaekvationen
42    elevation = pvc_elevation + g1 * x + (A * x * x) / (2 * curve_length)
43    
44    return elevation
45
46def calculate_high_low_point(initial_grade, final_grade, pvi_station, 
47                            pvi_elevation, curve_length):
48    """Beräkna hög- eller lågpunkt för en vertikal kurva om den existerar."""
49    g1 = initial_grade / 100
50    g2 = final_grade / 100
51    
52    # Hög/lågpunkt existerar endast om lutningarna har motsatta tecken
53    if g1 * g2 >= 0 and g1 != 0:
54        return None
55    
56    # Beräkna avstånd från PVC till hög/lågpunkt
57    pvc_station = pvi_station - curve_length / 2
58    x = -g1 * curve_length / (g2 - g1)
59    
60    # Kontrollera om hög/lågpunkt är inom kurvans gränser
61    if x < 0 or x > curve_length:
62        return None
63    
64    # Beräkna stationen för hög/lågpunkt
65    hl_station = pvc_station + x
66    
67    # Beräkna PVC höjd
68    pvc_elevation = pvi_elevation - (g1 * curve_length / 2)
69    
70    # Beräkna höjd vid hög/lågpunkt
71    A = g2 - g1
72    hl_elevation = pvc_elevation + g1 * x + (A * x * x) / (2 * curve_length)
73    
74    return {"station": hl_station, "elevation": hl_elevation}
75

1/**
2 * Beräkna K-värde för en vertikal kurva
3 * @param {number} curveLength - Längd på den vertikala kurvan i meter
4 * @param {number} initialGrade - Initial lutning i procent
5 * @param {number} finalGrade - Slutlig lutning i procent
6 * @returns {number} K-värde
7 */
8function calculateKValue(curveLength, initialGrade, finalGrade) {
9  const gradeChange = Math.abs(finalGrade - initialGrade);
10  if (gradeChange < 0.0001) {
11    return Infinity; // För lika lutningar
12  }
13  return curveLength / gradeChange;
14}
15
16/**
17 * Bestämma typen av vertikal kurva
18 * @param {number} initialGrade - Initial lutning i procent
19 * @param {number} finalGrade - Slutlig lutning i procent
20 * @returns {string} Kurvtyp: "topp", "sänk" eller "ingen"
21 */
22function determineCurveType(initialGrade, finalGrade) {
23  if (initialGrade > finalGrade) {
24    return "topp";
25  } else if (initialGrade < finalGrade) {
26    return "sänk";
27  } else {
28    return "ingen";
29  }
30}
31
32/**
33 * Beräkna höjd vid vilken station som helst längs en vertikal kurva
34 * @param {number} station - Fråga station
35 * @param {number} initialGrade - Initial lutning i procent
36 * @param {number} finalGrade - Slutlig lutning i procent
37 * @param {number} pviStation - PVI station
38 * @param {number} pviElevation - PVI höjd i meter
39 * @param {number} curveLength - Längd på den vertikala kurvan i meter
40 * @returns {number|null} Höjd vid stationen eller null om utanför kurvans gränser
41 */
42function calculateElevationAtStation(
43  station,
44  initialGrade,
45  finalGrade,
46  pviStation,
47  pviElevation,
48  curveLength
49) {
50  // Beräkna PVC och PVT stationer
51  const pvcStation = pviStation - curveLength / 2;
52  const pvtStation = pviStation + curveLength / 2;
53  
54  // Kontrollera om stationen är inom kurvans gränser
55  if (station < pvcStation || station > pvtStation) {
56    return null; // Utanför kurvans gränser
57  }
58  
59  // Konvertera lutningar till decimal
60  const g1 = initialGrade / 100;
61  const g2 = finalGrade / 100;
62  
63  // Beräkna PVC höjd
64  const pvcElevation = pviElevation - (g1 * curveLength / 2);
65  
66  // Beräkna avstånd från PVC
67  const x = station - pvcStation;
68  
69  // Beräkna algebraisk skillnad i lutningar
70  const A = g2 - g1;
71  
72  // Beräkna höjd med hjälp av vertikal kurvaekvationen
73  const elevation = pvcElevation + g1 * x + (A * x * x) / (2 * curveLength);
74  
75  return elevation;
76}
77

1public class VerticalCurveCalculator {
2    /**
3     * Beräkna K-värde för en vertikal kurva
4     * @param curveLength Längd på den vertikala kurvan i meter
5     * @param initialGrade Initial lutning i procent
6     * @param finalGrade Slutlig lutning i procent
7     * @return K-värde
8     */
9    public static double calculateKValue(double curveLength, double initialGrade, double finalGrade) {
10        double gradeChange = Math.abs(finalGrade - initialGrade);
11        if (gradeChange < 0.0001) {
12            return Double.POSITIVE_INFINITY; // För lika lutningar
13        }
14        return curveLength / gradeChange;
15    }
16    
17    /**
18     * Bestämma typen av vertikal kurva
19     * @param initialGrade Initial lutning i procent
20     * @param finalGrade Slutlig lutning i procent
21     * @return Kurvtyp: "topp", "sänk" eller "ingen"
22     */
23    public static String determineCurveType(double initialGrade, double finalGrade) {
24        if (initialGrade > finalGrade) {
25            return "topp";
26        } else if (initialGrade < finalGrade) {
27            return "sänk";
28        } else {
29            return "ingen";
30        }
31    }
32    
33    /**
34     * Beräkna PVC station och höjd
35     * @param pviStation PVI station
36     * @param pviElevation PVI höjd i meter
37     * @param initialGrade Initial lutning i procent
38     * @param curveLength Längd på den vertikala kurvan i meter
39     * @return Objekt som innehåller station och höjd för PVC
40     */
41    public static Point calculatePVC(double pviStation, double pviElevation, 
42                                    double initialGrade, double curveLength) {
43        double station = pviStation - curveLength / 2;
44        double elevation = pviElevation - (initialGrade / 100) * (curveLength / 2);
45        return new Point(station, elevation);
46    }
47    
48    /**
49     * Beräkna PVT station och höjd
50     * @param pviStation PVI station
51     * @param pviElevation PVI höjd i meter
52     * @param finalGrade Slutlig lutning i procent
53     * @param curveLength Längd på den vertikala kurvan i meter
54     * @return Objekt som innehåller station och höjd för PVT
55     */
56    public static Point calculatePVT(double pviStation, double pviElevation, 
57                                    double finalGrade, double curveLength) {
58        double station = pviStation + curveLength / 2;
59        double elevation = pviElevation + (finalGrade / 100) * (curveLength / 2);
60        return new Point(station, elevation);
61    }
62    
63    /**
64     * Inre klass för att representera en punkt med station och höjd
65     */
66    public static class Point {
67        public final double station;
68        public final double elevation;
69        
70        public Point(double station, double elevation) {
71            this.station = station;
72            this.elevation = elevation;
73        }
74    }
75}
76

Praktiska Exempel

Exempel 1: Motorväg Toppkurva Design

En motorvägsdesign kräver en vertikal kurva för att övergå från en +3% lutning till en -2% lutning. PVI ligger vid station 1000+00 med en höjd av 150.00 meter. Designhastigheten är 100 km/h, vilket kräver ett minimik-värde på 80 enligt designstandarder.

Steg 1: Beräkna den minimala kurvlängden

Vertikal kurvberäknare för civilingenjörsprojekt

Vertikal Kurva Kalkylator

Inmatningsparametrar

Curve Parameters

PVI Information

Resultat

Kurvkarakteristik

Nyckelpunkter

Stationsfråga

Visualisering

Dokumentation