Mätning av acceleration, hastighet, läge och lufttryck under en hisstur

In [1]:
from IPython.display import HTML
HTML('''<script>
code_show=true; 
function code_toggle() {
 if (code_show){
 $('div.input').hide();
 } else {
 $('div.input').show();
 }
 code_show = !code_show
} 
$( document ).ready(code_toggle);
</script>
<form action="javascript:code_toggle()"><input type="submit" value="Visa / dölj källkoden."></form>''')
Out[1]:

Inledning

Introduktion

I en modern "smartphone" finns det sensorer som gör att den kan användas som mätinstrument både för rörelse och lufttryck. Jag tog med min iPhone, med appen SensorLog, på en hisstur fyra våningar upp och ned i en hiss. Med hjälp av programmeringsspråket Python, med bl a tillägget SciPy för numerisk analys, så kunde i efterhand de närmare 1 700 mätvärdena av respektive slag hanteras och användas för skapa såväl rörelse- och tryckförändringsgrafer samt för att göra beräkningar på dessa. Allt detta hanterades i den integrerade miljön Jupyter. Det är en öppen plattform som bl a kan köra kod, skapa diagram utifrån kod, visa texter och bilder samt slutligen skapa en fil som kan presentera resultatet av detta på webben.

Syfte och frågeställning

Syftet med mätningen var att undersöka hur telefonens mätdata för rörelse och lufttryck var användbar för att göra grafer och beräkningar utifrån, och i så fall avgöra hur väl resultatet stämde överens med verkliga förhållanden och teoretiska modeller. Ett annat syfte var att undersöka hur väl Pythonmiljön lämpade sig för hantering av resultaten.

Frågeställningarna blev då

  • Hur väl stämmer mätdatan från en iPhone överens med verkliga förhållanden och teoretiska modeller beträffande märningar av rörelser och lufttrycksförändringar?
  • Är det möjligt och rimligt att hantera och redovisa dessa data med beräkningar i en Python-miljö?

Omgivning och begränsningar

Mätningarna skedde den 24 april 2017 på Åva gymnasium i Täby. Det var regnigt ute, så det var inte förvånande att de uppmätta lufttrycken var lägre än normaltrycket på 101,325 kPa. Alla värden mättes upp i frekvensen 50 Hz. Rörelsen mättes enbart i en dimension.

Metod

Experimentutförande

Själva försöket lades upp så att telefonen, med appen SensorLog, låg på hissens golv. Innan hissen trycktes igång startades mätningen, varpå mätningen avslutades efter att hissen hade stannat. Mätningar gjordes då hissen åkte upp fyra våningar respektive ned lika långt. SensorLog samlade in accelerations- och tryckdata (och även annan data som är irrelevant i detta experiment) i en och samma mätning.

Databearbetning

Databearbetningen gjordes med hjälp av programmeringsspråket Python på plattformen Jupyter. SensorLog ger data i form av ett tidsvärde samt accelerations- och tryckdata. Det behövs en funktionsanpassning och en numerisk integrationsmetod som kan tilämpas på accelerationsdatan för att få ut hastighet och läge på hissen vid de olika tidpunkterna; dessa verktyg finns tillgänglig i Pythontillägget SciPy. Vidare behövs möjlighet att plotta datan. Det ger biblioteket Matplotlib möjlighet till.

Datan representeras i tabellkolumner: för respektive tidpunkt så kommer det att finnas ett accelerationsvärde, hastighetsvärde, lägesvärde och tryckvärde.

In [2]:
import numpy as np # För grundläggande matrisfunktioner
import matplotlib.pyplot as plt # För att kunna rita grafer
import matplotlib.pylab as pylab # För att kunna sätta storleken på graferna
from numpy import genfromtxt # För att kunna läsa från CSV-filer och lägga i matriser
from scipy.interpolate import UnivariateSpline # För att kunna integrera
from scipy import stats # För att kunna utföra linjär regression
from IPython.core.display import display, HTML, Markdown # För att kunna skapa hyperlänkar som utdata

g = 9.81 # Värdet på tyngdaccelerationen i loggern

# Några inställningar för graferna
# Grafernas storlek
# (Man kan även sätta graferns storlek (t ex W = 15, H = 10) för varje plot med "plt.figure(figsize=(15,10))")
pylab.rcParams['figure.figsize'] = (15.0, 10.0)

# Fonter i graferna
fontHeader = {'family': 'serif',
        'color':  'darkred',
        'weight': 'normal',
        'size': 24,
        }

fontAxis = {'family': 'serif',
        'color':  'black',
        'weight': 'normal',
        'size': 20,
        }

# Tabeller skapas
# De tabeller som kommer att användas för att skapa graferna är
#   * tValsDown (tiden i sekunder från start)
#   * aValsDown (accelerationen vid respektive tidpunkt, korresponederar till tidpunkterna i tValsDown).
#   * vValsDown (hastigheten vid respektive tidpunkt, korresponederar till tidpunkterna i tValsDown).
#   * positionDown (läget vid respektive tidpunkt, korresponederar till tidpunkterna i tValsDown).
#   * pValsDown (trycket vid respektive tidpunkt, korresponederar till tidpunkterna i tValsDown).
#   * tValsDownRed (en tabell som innehåller vart 100:e tidsvärde, ger bättre resultat för tryckmätningarna)
#   * pValsDownRed (tryckvärden, korresponderar till tidpunkterna i tValsDownRed)

# Läs in datan från fil och skapa tabeller av den
descent = genfromtxt('hiss_ned.csv', delimiter = ',')
ascent = genfromtxt('hiss_upp.csv', delimiter=',')
timestampsDown = descent[30:len(descent) - 50, 3] # Tidsmarkeringar, ligger fr o m rad 1 i kolumn 3. Startar dock på rad 30 och avslutar 50 rader innan mätslut för att få bort omkringliggande brus.
timestampsUp = ascent[1:len(ascent) - 50 ,3] # Tidsmarkeringar, ligger fr o m rad 1 i kolumn 3.
accstampsDown = descent[31:len(descent) - 50, 6] # Acc-värden. Då tidsstämplarna kommer att göras om till intervall så blir antalet sådana ett mindre än stämplarna. Därav så startar tabellern på rad 26 istället för 25 för att värdena ska bli lika många.
accstampsUp = ascent[2:len(ascent) - 50 ,6] # Acc-värden. Då tidsstämplarna kommer att göras om till intervall så blir antalet
                                           # sådana ett mindre än stämplarna. Därav så startar tabellern på rad 2 istället för 1
                                           # för att värdena ska bli lika många.

pValsDown = descent[31:len(descent) - 50, 10] # Tryckvärden
pValsUp = ascent[2:,10] # Tryckvärden


# I tabellen får vi enbart tidsstämplar, dessa måste göras om till en tidslängd från start.
# Dessa tidslängder läggs i en ny tabell. Antalet rader i denna tabell kommer att bli en mindre än timestampsDown-tabellen.
tValsDown = []
tValsUp = []
timeZeroDown = timestampsDown[0]
timeZeroUp = timestampsUp[0]
    
for time in timestampsDown[1:]:
    tValsDown.append(time - timeZeroDown)
    
for time in timestampsUp[1:]:
    tValsUp.append(time - timeZeroUp)

    
# Nedanstående tabeller tar ett urval av tids- och tryckvärdena. Detta för att samplingsfrekvensen
# egentligen är för hög för att mäta tryckskillnader.
tValsDownRed = [] # En "reducerad" tidstabell
tValsUpRed = [] # En "reducerad" tidstabell

for i in range(0, len(tValsDown), 100): # Tar vart 100:e värde
    tValsDownRed.append(tValsDown[i])
    
for i in range(0, len(tValsUp), 100): # Tar vart 100:e värde
    tValsUpRed.append(tValsUp[i])
    
pValsDownRed = [] # En "reducerad" trycktabell
for i in range(0, len(pValsDown), 100):
    pValsDownRed.append(pValsDown[i])
    
pValsUpRed = [] # En "reducerad" tidstabell
for i in range(0, len(pValsUp), 100):
    pValsUpRed.append(pValsUp[i])
    
# Accelerationen från tabellen är uttryckt i g-enheter med postiv riktning nedåt.
# Jag vill ha accelerationen i m/s2 med positiv riktning uppåt.
# Dessutom kompenseras för det absoluta felet i accelerometervärdet, det visar sig att "viloläget"
# ligger på -0.995 g istället för -1.00 g genom att utgå från summan av accelerationen = 0 under hela hissturen.

aValsDown = (accstampsDown - sum(accstampsDown) / len(accstampsDown)) * (-g)
aValsUp = (accstampsUp - sum(accstampsUp) / len(accstampsUp)) * (-g)

# Funktioner till mätvärdena måste approximeras för att kunna integreras,
# vilket måste göras för att få hastighet respektive läge.

# Accelerationsfunktionen approximeras
accelerationDown = UnivariateSpline(tValsDown, aValsDown)
accelerationUp = UnivariateSpline(tValsUp, aValsUp)
accelerationDown.set_smoothing_factor(1)
accelerationUp.set_smoothing_factor(1)

# Hastigheten beräknas med hjälp av accelerationsfunktionen ovan, och vilkoret v(0) = 0.

vValsDown = []
vValsUp = []
counter = 0
displacement = 0

for i in tValsDown:
    if counter == 0:
        vValsDown.append(accelerationDown.integral(tValsDown[counter], i))
    else:
        vValsDown.append(accelerationDown.integral(tValsDown[counter - 1], i) + vValsDown[counter - 1] )
    counter = counter + 1
    
counter = 0

for i in tValsUp:
    if counter == 0:
        vValsUp.append(accelerationUp.integral(tValsUp[counter], i))
    else:
        vValsUp.append(accelerationUp.integral(tValsUp[counter - 1], i) + vValsUp[counter - 1] )
    counter = counter + 1

    
# Hastighetsfunktionen approximeras
velocityDown = UnivariateSpline(tValsDown, vValsDown)
velocityUp = UnivariateSpline(tValsUp, vValsUp)
velocityDown.set_smoothing_factor(0.001)
velocityUp.set_smoothing_factor(0.001)

averageVelocityDown = sum(vValsDown) / len(vValsDown)
displacementDown = velocityDown.integral(0, tValsDown[len(tValsDown) - 1]) # Förflyttningen beräknas som integralen över tiden för hastighetsfunktionen

averageVelocityUp = sum(vValsUp) / len(vValsUp)
displacementUp = velocityUp.integral(0, tValsUp[len(tValsUp) - 1]) # Förflyttningen beräknas som integralen över tiden för hastighetsfunktionen

# Läget beräknas ur hastighetsfunktionen ovan med villkoret h(0) = högsta höjden.

positionDown = []
positionUp = []
counter = 0

for i in tValsDown:
    if counter == 0:
        positionDown.append(velocityDown.integral(tValsDown[counter], i) - velocityDown.integral(0, tValsDown[len(tValsDown) - 1]))
    else:
        positionDown.append(velocityDown.integral(tValsDown[counter - 1], i) + positionDown[counter - 1])
    counter = counter + 1
    
counter = 0

for i in tValsUp:
    if counter == 0:
        positionUp.append(velocityUp.integral(tValsUp[counter], i))
    else:
        positionUp.append(velocityUp.integral(tValsUp[counter - 1], i) + positionUp[counter - 1] )
    counter = counter + 1
    
# Någon lägesfunktion behöver inte approximeras, vi ska enbart rita grafen.

# Framförallt för trycket vill jag ha en tabell med färre mätvärden (jag väljer vart 100:e),
# därför att jag vill visa diskreta punkter istället för punkter som ligger så tätt att de ser ut som
# en sammanbunden linje. Däremot kommer jag att anpassa en rät linje till de punkter som skapats då
# hissen gick i konstant hastighet.

positionDownRed = []
positionUpRed = []

for i in range(0, len(positionDown), 100):
    positionDownRed.append(positionDown[i])
    
for i in range(0, len(positionUp), 100):
    positionUpRed.append(positionUp[i])
    
# En hjälpfunktion för att kunna göra urval baserat på tid istället för indexnummer
# Den används för att kunna använda tidsintervall istället för indexnummer när trycket under turen analyseras.

def timeSel(lowerTime, upperTime, useReducedTable = 0, down = 0):
    indexMin = 0
    indexMax = 0
    numberOfValues = 1
    timeSpan = []
    
    if useReducedTable == 0:
        if down == 0:
            for theTime in tValsUp:
                if theTime < lowerTime:
                    indexMin = indexMin + 1
                if ((theTime <= upperTime) and (theTime > lowerTime)):
                    indexMax = indexMax + 1
                    numberOfValues = numberOfValues + 1
                    
        else:
            for theTime in tValsDown:
                if theTime < lowerTime:
                    indexMin = indexMin + 1
                if ((theTime <= upperTime) and (theTime > lowerTime)):
                    indexMax = indexMax + 1
                    numberOfValues = numberOfValues + 1 
                
    if useReducedTable == 1:
        if down == 0:
            for theTime in tValsUpRed:
                if theTime < lowerTime:
                    indexMin = indexMin + 1
                if ((theTime <= upperTime) and (theTime > lowerTime)):
                    indexMax = indexMax + 1
                    numberOfValues = numberOfValues + 1
        else:
            if down == 1:
                for theTime in tValsDownRed:
                    if theTime < lowerTime:
                        indexMin = indexMin + 1
                    if ((theTime <= upperTime) and (theTime > lowerTime)):
                        indexMax = indexMax + 1
                        numberOfValues = numberOfValues + 1
            
    
    timeSpan.append(indexMin)
    timeSpan.append(indexMax + indexMin)
    timeSpan.append(numberOfValues)
    
    # Returnerar t ex vektorn [10, 110, 101], vilket innebär att den nedre intervallgränsen ligger på
    # index 10, den övre på 110 och att antal värden är 101 stycken.
    
    return timeSpan
    
    

Mätvärden och beräkningar

Rådata från accelerometern

Den enda data som appen SensorLog gav beträffande rörelsen var accelerationen. Den datan erhålls i multipler av tyngdaccelerationen, som är förinställd i appen enligt amerikansk standard till 9,81 m/s2. Rådatan för uppfärden finns som csv-fil här och för nedfärden finns csv-filen här.

In [3]:
plt.tick_params(labelsize=16)
plt.plot(tValsUp, accstampsUp, 'r.')
plt.title('Accelerationsmätning under hisstur uppåt - plottade rådata\n', fontdict = fontHeader)
plt.xlabel('Tid [s]', fontdict = fontAxis)
plt.ylabel('Acceleration [$\cdot 9.81\;$m/s$^2$]', fontdict = fontAxis)

# Tweak spacing to prevent clipping of ylabel
plt.subplots_adjust(left=0.15)

plt.savefig("fig1a.png", transparent=True)
plt.show()
display(Markdown('**Figur 1a:** *Plottade rådata från accelerometer under hisstur uppåt.*'))

Figur 1a: Plottade rådata från accelerometer under hisstur uppåt.

In [4]:
plt.tick_params(labelsize=16)
plt.plot(tValsDown, accstampsDown, 'r.')
plt.title('Accelerationsmätning under hisstur nedåt - plottade rådata\n', fontdict = fontHeader)
plt.xlabel('Tid [s]', fontdict = fontAxis)
plt.ylabel('Acceleration [$\cdot 9.81\;$m/s$^2$]', fontdict = fontAxis)

# Tweak spacing to prevent clipping of ylabel
plt.subplots_adjust(left=0.15)

plt.savefig("fig1b.png", transparent=True)
plt.show()
display(Markdown('**Figur 1b:** *Plottade rådata från accelerometer under hisstur nedåt.*'))

Figur 1b: Plottade rådata från accelerometer under hisstur nedåt.

Accelerationens variation över tiden

Jag väljer att representera accelerationen med positiv rikting uppåt och i absoluta tal istället för i multipler av g. Dessutom kompenseras för det absoluta felet i accelerometervärdet; det visar sig att "viloläget" ligger på -0.995g (syns i ovanstående graf) istället för -1.00g. Funktionen anpassas med hjälp av NumPy:s funktion UnivariateSpline.

In [5]:
plt.tick_params(labelsize=16)
plt.plot(tValsUp, aValsUp, 'r.')

plt.plot(tValsUp, accelerationUp(tValsUp), 'b-', lw=3)

plt.grid(b=True, which='major', color='black', linestyle='--')

plt.gcf().subplots_adjust(left=0.15)
plt.title('Rörelsemätning under hisstur uppåt - Acceleration\n', fontdict = fontHeader)
plt.xlabel('Tid [s]', fontdict = fontAxis)
plt.ylabel('Acceleration [m/s$^2$]', fontdict = fontAxis)

# Tweak spacing to prevent clipping of ylabel
plt.subplots_adjust(left=0.15)

plt.savefig("fig2a.png", transparent=True)
plt.show()

display(Markdown('**Figur 2a:** *Anpassad accelerationsfunktion.*'))

Figur 2a: Anpassad accelerationsfunktion.

In [6]:
plt.tick_params(labelsize=16)
plt.plot(tValsDown, aValsDown, 'r.')

plt.plot(tValsDown, accelerationDown(tValsDown), 'b-', lw=3)

plt.grid(b=True, which='major', color='black', linestyle='--')

plt.gcf().subplots_adjust(left=0.15)
plt.title('Rörelsemätning under hisstur nedåt - Acceleration\n', fontdict = fontHeader)
plt.xlabel('Tid [s]', fontdict = fontAxis)
plt.ylabel('Acceleration [m/s$^2$]', fontdict = fontAxis)

# Tweak spacing to prevent clipping of ylabel
plt.subplots_adjust(left=0.15)

plt.savefig("fig2b.png", transparent=True)
plt.show()
display(Markdown('**Figur 2b:** *Anpassad accelerationsfunktion.*'))

Figur 2b: Anpassad accelerationsfunktion.

Hastighetens variation över tiden, positiv riktning uppåt

Genom att integrera respektive accelerationsfunktion över små tidsintervall erhålls hastighetsförändringen över respektive intervall. Givet att hissen startar från stillastående så kan hastigheten vid olika tidpunkter beräknas.

In [7]:
plt.tick_params(labelsize=16)
plt.plot(tValsUp, vValsUp, 'b', lw = 3)
plt.grid(b=True, which='major', color='black', linestyle='--')

plt.gcf().subplots_adjust(left=0.15)
plt.title('Rörelsemätning under hisstur uppåt - Hastighet\n', fontdict = fontHeader)
plt.xlabel('Tid [s]', fontdict = fontAxis)
plt.ylabel('Hastighet [m/s]', fontdict = fontAxis)

# Tweak spacing to prevent clipping of ylabel
plt.subplots_adjust(left=0.15)

plt.savefig("fig3a.png", transparent=True)
plt.show()

display(Markdown('**Figur 3a:** *Hastighet vid olika tidpunkter då hissen är på väg uppåt.*'))
print('Beräknad medelhastighet: {:.2f}'.format(averageVelocityUp), 'm/s.')

Figur 3a: Hastighet vid olika tidpunkter då hissen är på väg uppåt.

Beräknad medelhastighet: 0.45 m/s.
In [8]:
plt.tick_params(labelsize=16)
plt.plot(tValsDown, vValsDown, 'b', lw = 3)
plt.grid(b=True, which='major', color='black', linestyle='--')

plt.gcf().subplots_adjust(left=0.15)
plt.title('Rörelsemätning under hisstur nedåt - Hastighet\n', fontdict = fontHeader)
plt.xlabel('Tid [s]', fontdict = fontAxis)
plt.ylabel('Hastighet [m/s]', fontdict = fontAxis)

# Tweak spacing to prevent clipping of ylabel
plt.subplots_adjust(left=0.15)

plt.savefig("fig3b.png", transparent=True)
plt.show()

display(Markdown('**Figur 3b:** *Hastighet vid olika tidpunkter då hissen är på väg nedåt.*'))
print('Beräknad medelhastighet: {:.2f}'.format(averageVelocityDown), 'm/s.')

Figur 3b: Hastighet vid olika tidpunkter då hissen är på väg nedåt.

Beräknad medelhastighet: -0.45 m/s.

Lägets variation över tiden, höjd över bottenplan

Genom att integrera hastighetsfunktionen över små tidsintervall från start och framåt så erhålls förflyttningen över det aktuella intervallet. Den kumulerade värdet utgör förflyttningen till det aktuella tidsintervallets slut. Värdet av integralen över hela intervallet utgör den totala förflyttningen i förhållande till bottenplanet. Abslolutbeloppet av den totala förflyttningen motsvarar höjden över bottenplanet.

In [9]:
plt.tick_params(labelsize=16)
plt.plot(tValsUp, positionUp, 'b', lw = 5)
plt.grid(b=True, which='major', color='black', linestyle='-')

plt.gcf().subplots_adjust(left=0.15)
plt.title('Rörelsemätning under hisstur uppåt - Höjd\n', fontdict = fontHeader)
plt.xlabel('Tid [s]', fontdict = fontAxis)
plt.ylabel('Höjd över bottenplan [m]', fontdict = fontAxis)

# Tweak spacing to prevent clipping of ylabel
plt.subplots_adjust(left=0.15)

plt.savefig("fig4a.png", transparent=True)
plt.show()

display(Markdown('**Figur 4a:** *Höjden vid olika tidpunkter.*'))

print('Beräknad förflyttning: {:.1f}'.format(displacementUp), 'm.')

Figur 4a: Höjden vid olika tidpunkter.

Beräknad förflyttning: 14.5 m.
In [10]:
plt.tick_params(labelsize=16)
plt.plot(tValsDown, positionDown, 'b', lw = 5)
plt.grid(b=True, which='major', color='black', linestyle='-')

plt.gcf().subplots_adjust(left=0.15)
plt.title('Rörelsemätning under hisstur nedåt - Höjd\n', fontdict = fontHeader)
plt.xlabel('Tid [s]', fontdict = fontAxis)
plt.ylabel('Höjd över bottenplan [m]', fontdict = fontAxis)

# Tweak spacing to prevent clipping of ylabel
plt.subplots_adjust(left=0.15)

plt.savefig("fig4b.png", transparent=True)
plt.show()

display(Markdown('**Figur 4b:** *Höjden vid olika tidpunkter.*'))
print('Beräknad förflyttning: {:.1f}'.format(displacementDown), 'm.')

Figur 4b: Höjden vid olika tidpunkter.

Beräknad förflyttning: -14.4 m.

Kontrollmätning höjd i trapphuset

Med

  • Antal trappsteg: 88

  • Höjd på trappsteg: 16,0 - 16,5 cm

så erhålls den totala höjden h: 14,1 m < h < 14,5 m (detta ska jämföras med respektive beräkna förflyttning ovan)

Lufttryckets variation över höjden

Tryckets variation med tiden räknas om till dess variation över den faktiska förflyttningen (enligt de beräknade data som ligger till grund för höjd-diagrammet ovan). För diagrammets del visade det sig vara fruktlöst att markera samtliga värden då mätning gjordes 50 gånger per sekund; trycket förändrades helt enkelt inte mätbart över ett så kort tidsintervall. Här reduceras antalet värden till 1 av 100, dvs ett mätvärde varannan sekund.

In [11]:
plt.tick_params(labelsize=16)
plt.plot(positionUpRed, pValsUpRed, 'rx', ms = 16)
#pylab.xlim(0, 15)
plt.grid(b=True, which='major', color='black', linestyle='--')
plt.gcf().subplots_adjust(left=0.15)
plt.title('Lufttrycksmätning under hisstur uppåt\n', fontdict = fontHeader)
plt.xlabel('Höjd över bottenplan [m]', fontdict = fontAxis)
plt.ylabel('Tryck [kPa]', fontdict = fontAxis)

# Tweak spacing to prevent clipping of ylabel
plt.subplots_adjust(left=0.15)

plt.savefig("fig5a.png", transparent=True)
plt.show()
display(Markdown('**Figur 5a:** *Lufttryckets variation med höjden under uppfärd.*'))

Figur 5a: Lufttryckets variation med höjden under uppfärd.

In [12]:
plt.gca().invert_xaxis()
plt.tick_params(labelsize=16)
plt.plot(positionDownRed, pValsDownRed, 'rx', ms = 16)

plt.grid(b=True, which='major', color='black', linestyle='--')
plt.gcf().subplots_adjust(left=0.15)
plt.title('Lufttrycksmätning under hisstur nedåt\n', fontdict = fontHeader)
plt.xlabel('Höjd över bottenplan [m]', fontdict = fontAxis)
plt.ylabel('Tryck [kPa]', fontdict = fontAxis)

# Tweak spacing to prevent clipping of ylabel
plt.subplots_adjust(left=0.15)

plt.savefig("fig5b.png", transparent=True)
plt.show()
display(Markdown('**Figur 5b:** *Lufttryckets variation med höjden under nedfärd.*'))

Figur 5b: Lufttryckets variation med höjden under nedfärd.

Beräknade förändringshastigheter av lufttrycket i olika faser av hissfärden

Nedan syns hur tryckförändringen per höjdenhet varierar med accelerationen. Det bör vara en konsekvens av luftens tröghet; den "hinner inte med" hissens acceleration. I denna datahantering är samtliga mätvärden medtagna i de redovisade intervallen.

In [13]:
timeIntStart = timeSel(0, 2.0, 0, 0)
timeIntMid = timeSel (5, 28, 0, 0)
timeIntStop = timeSel(30, 32, 0, 0)

posSelStart = positionUp[timeIntStart[0]:timeIntStart[1]]
pressureSelStart = pValsUp[timeIntStart[0]:timeIntStart[1]]

posSelMid = positionUp[timeIntMid[0]:timeIntMid[1]]
pressureSelMid = pValsUp[timeIntMid[0]:timeIntMid[1]]

posSelEnd = positionUp[timeIntStop[0]:timeIntStop[1]]
pressureSelEnd = pValsUp[timeIntStop[0]:timeIntStop[1]] 

m1, b1, r1, p1, e1 = stats.linregress(posSelStart, pressureSelStart)
m2, b2, r2, p2, e2 = stats.linregress(posSelMid, pressureSelMid)
m3, b3, r3, p3, e3 = stats.linregress(posSelEnd, pressureSelEnd)

display(Markdown('#### Beräknade tryckförändringar per höjdenhet under uppfärd'))

print('*Startfas (0.0 - 2.0 sekunder)*')
print('h1: {:.2f}'.format(posSelStart[0]), 'm.')
print('h2: {:.2f}'.format(posSelStart[len(posSelStart) - 1]), 'm.')
print('Tryckförändring per höjdenhet: {:.2f}'.format(m1*1000), 'Pa/m')
print('R^2-värde: {:.2f}'.format(r1**2))
print('Antal mätvärden: {}'.format(timeIntStart[2]))

print('------------------------------------')
print('*Mellanfas (5.0 - 28.0 sekunder)*')
print('h1: {:.2f}'.format(posSelMid[0]), 'm.')
print('h2: {:.2f}'.format(posSelMid[len(posSelMid) - 1]), 'm.')
print('Tryckförändring per höjdenhet: {:.2f}'.format(m2*1000), 'Pa/m')
print('R^2-värde: {:.2f}'.format(r2**2))
print('Antal mätvärden: {}'.format(timeIntMid[2]))

print('------------------------------------')
print('*Slutfasfas (30.0 - 32.0 sekunder)*')
print('h1: {:.2f}'.format(posSelEnd[0]), 'm.')
print('h2: {:.2f}'.format(posSelEnd[len(posSelEnd) - 1]), 'm.')
print('Tryckförändring per höjdenhet: {:.2f}'.format(m3*1000), 'Pa/m')
print('R^2-värde: {:.2f}'.format(r3**2))
print('Antal mätvärden: {}'.format(timeIntStop[2]))

Beräknade tryckförändringar per höjdenhet under uppfärd

*Startfas (0.0 - 2.0 sekunder)*
h1: 0.00 m.
h2: 0.40 m.
Tryckförändring per höjdenhet: -0.57 Pa/m
R^2-värde: 0.41
Antal mätvärden: 100
------------------------------------
*Mellanfas (5.0 - 28.0 sekunder)*
h1: 1.87 m.
h2: 13.31 m.
Tryckförändring per höjdenhet: -11.51 Pa/m
R^2-värde: 1.00
Antal mätvärden: 1150
------------------------------------
*Slutfasfas (30.0 - 32.0 sekunder)*
h1: 14.28 m.
h2: 14.53 m.
Tryckförändring per höjdenhet: -43.35 Pa/m
R^2-värde: 0.72
Antal mätvärden: 101
In [14]:
timeIntStart = timeSel(0, 2.0, 0, 1)
timeIntMid = timeSel (5, 28, 0, 1)
timeIntStop = timeSel(30, 32, 0, 1)

posSelStart = positionDown[timeIntStart[0]:timeIntStart[1]]
pressureSelStart = pValsDown[timeIntStart[0]:timeIntStart[1]]

posSelMid = positionDown[timeIntMid[0]:timeIntMid[1]]
pressureSelMid = pValsDown[timeIntMid[0]:timeIntMid[1]]

posSelEnd = positionDown[timeIntStop[0]:timeIntStop[1]]
pressureSelEnd = pValsDown[timeIntStop[0]:timeIntStop[1]] 

m1, b1, r1, p1, e1 = stats.linregress(posSelStart, pressureSelStart)
m2, b2, r2, p2, e2 = stats.linregress(posSelMid, pressureSelMid)
m3, b3, r3, p3, e3 = stats.linregress(posSelEnd, pressureSelEnd)

display(Markdown('#### Beräknade tryckförändringar per höjdenhet under nedfärd'))

print('*Startfas (0.0 - 2.0 sekunder)*')
print('h1: {:.2f}'.format(posSelStart[0]), 'm.')
print('h2: {:.2f}'.format(posSelStart[len(posSelStart) - 1]), 'm.')
print('Tryckförändring per höjdenhet: {:.2f}'.format(m1*1000*(-1)), 'Pa/m')
print('R^2-värde: {:.2f}'.format(r1**2))
print('Antal mätvärden: {}'.format(timeIntStart[2]))

print('------------------------------------')
print('*Mellanfas (5.0 - 28.0 sekunder)*')
print('h1: {:.2f}'.format(posSelMid[0]), 'm.')
print('h2: {:.2f}'.format(posSelMid[len(posSelMid) - 1]), 'm.')
print('Tryckförändring per höjdenhet: {:.2f}'.format(m2*1000*(-1)), 'Pa/m')
print('R^2-värde: {:.2f}'.format(r2**2))
print('Antal mätvärden: {}'.format(timeIntMid[2]))

print('------------------------------------')
print('*Slutfasfas (30.0 - 32.0 sekunder)*')
print('h1: {:.2f}'.format(posSelEnd[0]), 'm.')
print('h2: {:.2f}'.format(posSelEnd[len(posSelEnd) - 1]), 'm.')
print('Tryckförändring per höjdenhet: {:.2f}'.format(m3*1000*(-1)), 'Pa/m')
print('R^2-värde: {:.2f}'.format(r3**2))
print('Antal mätvärden: {}'.format(timeIntStop[2]))

Beräknade tryckförändringar per höjdenhet under nedfärd

*Startfas (0.0 - 2.0 sekunder)*
h1: 14.43 m.
h2: 14.22 m.
Tryckförändring per höjdenhet: -1.57 Pa/m
R^2-värde: 0.43
Antal mätvärden: 100
------------------------------------
*Mellanfas (5.0 - 28.0 sekunder)*
h1: 12.79 m.
h2: 1.48 m.
Tryckförändring per höjdenhet: 12.01 Pa/m
R^2-värde: 1.00
Antal mätvärden: 1150
------------------------------------
*Slutfasfas (30.0 - 32.0 sekunder)*
h1: 0.49 m.
h2: 0.00 m.
Tryckförändring per höjdenhet: 26.21 Pa/m
R^2-värde: 0.83
Antal mätvärden: 101

Den linjära delen av tryckförändring

I diagrammet nedan visas den del av tryckförändringen som är linjär. Den visar sig hänga ihop med att hissen går i konstant hastighet.

In [15]:
plt.tick_params(labelsize=16)
timeInt = timeSel(2.5, 30, 1, 1)
timeTics = tValsUpRed[timeInt[0]:timeInt[1]]
positionTics = positionUpRed[timeInt[0]:timeInt[1]]
pressureMarks = pValsUpRed[timeInt[0]:timeInt[1]]
xi = np.arange(0, 15)

m, b, r, p, e = stats.linregress(positionTics, pressureMarks)
line = m * xi + b

plt.plot(positionTics, pressureMarks, 'rx', ms = 16)
plt.plot(line, linestyle = '-', color = 'b', linewidth = 3.0)

#pylab.xlim(0, 15)
plt.grid(b=True, which='major', color='k', linestyle='--')
plt.gcf().subplots_adjust(left=0.15)
plt.title('Lufttrycksmätning under hisstur uppåt\n', fontdict = fontHeader)
plt.xlabel('Höjd över bottenplan [m]', fontdict = fontAxis)
plt.ylabel('Tryck [kPa]', fontdict = fontAxis)

# Tweak spacing to prevent clipping of ylabel
plt.subplots_adjust(left=0.15)

plt.savefig("fig6a.png", transparent=True)
plt.show()

display(Markdown('**Figur 6a:** *Trycket minskar linjärt med ökad höjd nära marknivå. Mätresultat under den delen av hissturen som var i konstant hastighet.*'))
print('Beräknad tryckförändring per höjdenhet: {:.1f}'.format(m * 1000), 'Pa/m')
print('r^2-värde: {:.2f}'.format(r**2))

display(HTML("""<a target = blank href="https://www.smhi.se/kunskapsbanken/meteorologi/lufttryck-1.657">SMHI:s värde: ca -12.5 Pa/m, nära marknivå.</a>"""))

Figur 6a: Trycket minskar linjärt med ökad höjd nära marknivå. Mätresultat under den delen av hissturen som var i konstant hastighet.

Beräknad tryckförändring per höjdenhet: -11.4 Pa/m
r^2-värde: 1.00
In [16]:
plt.gca().invert_xaxis()
plt.tick_params(labelsize=16)
timeInt = timeSel(5, 30, 1, 0)
timeTics = tValsDownRed[timeInt[0]:timeInt[1]]
positionTics = positionDownRed[timeInt[0]:timeInt[1]]
pressureMarks = pValsDownRed[timeInt[0]:timeInt[1]]
xi = np.arange(0, 15)

k, m, r, p, e = stats.linregress(positionTics, pressureMarks)
line = k * xi + m

plt.plot(positionTics, pressureMarks, 'rx', ms = 16)
plt.plot(line, linestyle = '-', color = 'b', linewidth = 3.0)

plt.grid(b=True, which='major', color='black', linestyle='--')
plt.gcf().subplots_adjust(left=0.15)
plt.title('Lufttrycksmätning under hisstur nedåt\n', fontdict = fontHeader)
plt.xlabel('Höjd över bottenplan [m]', fontdict = fontAxis)
plt.ylabel('Tryck [kPa]', fontdict = fontAxis)

# Tweak spacing to prevent clipping of ylabel
plt.subplots_adjust(left=0.15)

plt.savefig("fig6b.png", transparent=True)
plt.show()

display(Markdown('**Figur 6b:** *Trycket ökar linjärt med minskad höjd nära marknivå. Mätresultat under den delen av hissturen som var i konstant hastighet.*'))

print('Beräknad tryckförändring per höjdenhet: {:.1f}'.format(k * 1000*(-1)), 'Pa/m')
print('r^2-värde: {:.2f}'.format(r**2))

display(HTML("""<a target = blank href="https://www.smhi.se/kunskapsbanken/meteorologi/lufttryck-1.657">SMHI:s värde: ca 12.5 Pa/m, nära marknivå</a>."""))