Contact
CoCalc Logo Icon
StoreFeaturesDocsShareSupport News Sign UpSign In
| Download

Labb 4 7584632

Project: DVGA18
Views: 137
Kernel: Python 3 (Anaconda)

Lab 4 - Python-del

I denna lab skall ni skriva ett program som läser in data från en serie drag-experiment och plottar och behandlar dom. Nedanför finns ett skelett för programmet, där ni måste fylla i några av funktionerna och få dom att funka.

Den första sektionen definierar några variabler som ni sedan kan använda, och dessutom innehåller en funktion read_data() som tar ett filnamn som parameter och returnerar innehållet i filen som en matris med 5 kolumner. Dessutom finns funktion-prototyp för de övriga funktioner ni kommer behöva, men utan innehåll.

Se dessutom nedanför för lite tips till funktioner ni kanske kommer behöva samt en kort introduktion till NumPy-biblioteket som användas till att behandla matriser och Matplotlib som användas för att plotta data.

Uppgiften:

  1. Fylla i funktionen calc_strain_load() så att den plockar ut töjning och spänning från ett dataset och returnerar dom.

  2. Fylla i funktionen find_peak() så att den returnerar töjning och spänning för toppen av "spännings-spetsen" (enligt dragprovs-beskrivningen). Det räcker om ni antar att spetsen finns där spänningen är högst för töjnings-värde under 0.005%.

  3. Fylla i funktionen find_gradient() så att den returnerar värden för E-modul, dvs lutningen på linjen mellan utgångspunkten och spännings-spetsen.

  4. Fylla i funktionen find_strain_limit() så att den returnerar värden av RelR_{el}. Ni kan utgå ifrån att detta värde som den lägsta spänningsvärde motsvarende töjnings-värde mellan punkten där spännings-spetsen finns, och 0.05.

  5. Fylla i funktionen process_file() så att den tar in ett filnamn och använder dem ovan definierade funktioner till att:

  • Läsa in data från filen.

  • Plotta töjning och spänning som en graf.

  • Markera spännings-spetsen och RelR_{el}-värdet på grafen.

  • Skriva ut E-modul (lutningen på kurvan). Kom ihåg att få rätt enhet på värdet.

  1. Anropa funktionen process_file() på dom tillgängliga datafilerna. Filerna finns på Python-datorn och har filnamn som "Specimen_RawData_XX.csv" där XX är ett nummer mellan 1 och 28. Emellertid saknas någon av filerna (det finns totalt 19 filer), så ni behöver kolla vilka filer som finns och bara läsa in dom.

Om ni föredrar något annat sätt att strukturera funktionerna får ni modifiera dom (och även göra nya funktioner om så behövs), men funktionaliteten måste kvarstå enligt beskrivningen ovan.

Extra utmaning till dom som är sugna

Ingen av funktionerna i punkt 1-4 ovanför behöver vara längre än 5 linjer/rader kod. Flera av dem behöver faktisk bara vara 2-3 linjer. Om ni försöker optimera detta, så se till att det inte skadar läsbarheten!

Redovisning

Labben ska redovisas för labhandledaren vid ett labtillfälle där alla som labbat tillsammans ska delta och kunna svara på frågor från labhandledaren. Sista ordinarie datum för redovisningen är 2015-01-09. Sen redovisning kan ske efter överenskommelse med labhandledare.

Snabb-intro till NumPy och Matplotlib

NumPy (Numeric Python) är ett bibliotek för att göra beräkningar på numeriska dataset/datamängder som har en serie funktioner vanliga Python-listor saknar. Dessutom funkar NumPy bra för stora dataset. Relevant för er här är att NumPy har en datatyp (array) som representerar en matris, lik den som MatLab använder.

Funktionen read_data nedanför returnerar en sådant array; ni kan använda det ungefär som en vanlig lista, förutom att det också går att få ut data från en två-dimensionell matris. Sålunda är array[1,2] andra rad, tredje kolumn (till skillnad från Matlab börjar arrays räkna från 0). Om man vill ha ut en hel rad eller kolumn är tex array[1,:] andra rad och array[:,3] fjärde kolumn. Det går att göra for-loopar över ett array på samma sätt som med en vanlig lista. Slutligen går det att räkna med hela matriser eller rader/kolumner. array/2 delar tex alla element i array med två.

Matplotlib är ett bibliotek för att plotta data. Det har många möjligheter (ni skall få se någon av dom på föreläsningen den 8. december), men för att plotta töjning och spänning behöver ni bara känna till funktionen plot( ) som finns i modulen plt. Den anropas som plt.plot(X,Y), där X och Y är antigen siffror eller listor med siffror, och plottar dom angivna X- och Y-värdena. Det går till och med att ange utseende på tredje platsen, så tex plt.plot(X,Y,'o') plottar X och Y med cirklar (istället för linjer som vanligt). Andra sättet är bra om ni tex skall markera ett enda värde på en graf.

Användbara funktioner

Det kan gå att lösa labben utan att använda dom här funktionerna, men ni kanske tycker dom är bra...

  • Funktionen os.path.exists() tar in ett filnamn och returnerar True om filen existerar, och False annars.

  • Om a är en array ger a.min() minsta värden i det array'en, och a.max() ger största. På samma sätt ger a.argmin() platsen i array'en där minsta värdet finns, och a.argmax() ger platsen där största värdet finns. Dvs a.min() == a[a.argmin()] och a.max() == a[a.argmax()].

  • Om man anropar plt.plot() flera gånga på rad blir alla anrop plottade ovanpå varandra. Detta kan vara bra om man tex skall markera något på en graf, eller vill jämnföra flera dataset. Men det kan också vara förvirrande, särskilt om man har för många grejar att plotta på en gång. I så fall kan det vara bra att splittra upp plottarna i flera figurer.

    Man tar fram en ny figur genom att anropa plt.figure(). Om man sedan anropar plt.plot(), plottar den på sist skapade figuren.

Funktion till inläsning osv

Evaluera den här koden för att kunna använda funktionen och värdene nedanför. Eller, om ni inte jobbar i iPython, kopiera då koden till er kodfil.

# Imports and settings %matplotlib inline import csv, math, os import numpy as np from matplotlib import pyplot as plt plt.rcParams['figure.figsize'] = (16.0, 10.0) # Function to read in the data def read_data(filename): # Read in data a = np.loadtxt(filename, delimiter=";", skiprows=2) # Sort on the 5th column, return the result return a[a[:,4].argsort()] # Some constants that can be used in the remainder of the code area = 3.5**2*math.pi # cross section area of the sample cutoff_peak = 0.005 # we assume the load peak is at a strain (x-value) lower than this value cutoff_min = 0.05 # we assume the minimum after the peak is at a strain lower than this value

Funktioner ni behöver fylla i

Fyll i dom här funktionerna enligt beskrivningen ovan, och anrop sedan process_file med rätt filnamnar.

# Function to calculate the strain and load from the loaded data import math #def calc_strain_load(data): diameter = 7 # givet i mm print(diameter) tArea = (((diameter/2)**2)*math.pi*10**-6) # givet i m^2 print(tArea) load = 103.27324 # givet i N print(load) strain = load/tArea print(strain) # return strain,load
7 3.848451000647496e-05 103.27324 2683501.4914474534
# Function to compute the peak strain and return the result def find_peak(strain, load): diameter = 7 radie = diameter/2 area = radie**2*math.pi # cross section area of the sample stress = load/area return peak_x, peak_y # Some constants that can be used in the remainder of the code area = 3.5**2*math.pi # cross section area of the sample cutoff_peak = 0.005 # we assume the load peak is at a strain (x-value) lower than this value cutoff_min = 0.05 # we assume the minimum after the peak is at a strain lower than this value
# Function to compute E-modul and return the result def find_gradient(strain, load): # ..... return e_modul
# Function to compute R_el and return the result def find_strain_limit(strain, load): # ..... return limit_x, limit_y
# Function to process a file using the other functions defined above def process_file(filename): data = read_data(filename) print(data) #strain,load = calc_strain_load(data) #peak_x,peak_y = find_peak(strain,load) #gradient = find_gradient(strain,load) #limit_x,limit_y = find_limit(strain,load) # print gradient # ... # plot strain and load # ... # mark peak and limit on the graph # ...
# Call function process_file for each of the filenames... # Imports and settings %matplotlib inline import csv, math, os import numpy as np from matplotlib import pyplot as plt plt.rcParams['figure.figsize'] = (16.0, 10.0) # Some constants that can be used in the remainder of the code area = 3.5**2*math.pi # cross section area of the sample cutoff_peak = 0.005 # we assume the load peak is at a strain (x-value) lower than this value cutoff_min = 0.05 # we assume the minimum after the peak is at a strain lower than this value # Function to read in the data def read_data(filename): # Read in data a = np.loadtxt(filename, delimiter=";", skiprows=2) # Sort on the 5th column, return the result return a[a[:,4].argsort()] # Function to compute the peak strain and return the result def find_peak(strain, stress): import numpy as np x = np.array(strain) y = np.array(stress) idx = 0 cutoff = 0.005 while x[idx] < cutoff: idx = idx + 1 # idx == 4 max_idx = y[:idx].argmax() # positionen för max-värdet max_x = x[max_idx] max_y = y[max_idx] # max_idx == 2, max_x == 0.03, max_y == 110 print(idx) print(max_x) print(max_y) print(max_y/area) return max_x, max_y # Function to process a file using the other functions defined above def process_file(filename): data = read_data(filename) # print(data) # calc_strain_stress(data) # Testanrop strain,stress = calc_strain_stress(data) # print(strain) # print(stress) peak_x,peak_y = find_peak(strain,stress) #gradient = find_gradient(strain,stress) #limit_x,limit_y = find_limit(strain,stress) # print gradient # ... # plot strain and stress # ... # mark peak and limit on the graph # ... # Function to calculate the strain and stress from the loaded data import math def calc_strain_stress(data): load = data[:,2] # givet i N stress = load/area # print(load) # print(stress) strain = data[:,4] # print(strain) return(strain,stress) #for i in range(1,29): filename = 'Specimen_RawData_' + str(1) + '.csv' print(filename) try: with open(filename) as file: process_file(filename) pass except IOError as e: print ("No file with the name:" , filename)
Specimen_RawData_1.csv 690 0.00269 544.288637077 14.1430574791
# Labb 4 # process files an it's data to make calculations on tensile tests # Imports and settings %matplotlib inline import csv, math, os import numpy as np from matplotlib import pyplot as plt plt.rcParams['figure.figsize'] = (16.0, 10.0) # Some constants for the area and load limits area = (3.5*10**(-3))**2*math.pi # cross section area of the sample in sqr m cutoff_peak = 0.005 # we assume the load peak is at a strain (x-value) lower than this value cutoff_min = 0.05 # we assume the minimum after the peak is at a strain lower than this value # Function to read in the data def read_data(filename): # Read in data a = np.loadtxt(filename, delimiter=";", skiprows=2) # Sort on the 5th column, return the result return a[a[:,4].argsort()] # Function to calculate the e-module def find_gradient(strain, stress): strain1 = float(strain[100:101]) # print(strain1) strain2 = float(strain[500:501]) # print(strain2) stress1 = float(stress[100:101]) # print(stress1) stress2 = float(stress[500:501]) # print(stress2) gradient = (stress2 - stress1)/(strain2 - strain1) # print(gradient) return gradient # Returns the x and y values for the point with maximum or minimum y value in the x interval between x_min and x_max def minmax_in_interval(xvals, yvals, x_min, x_max, min_or_max = 'max'): idx_min = 0 while xvals[idx_min] < x_min and idx_min < len(xvals)-1: idx_min = idx_min + 1 idx_max = idx_min while xvals[idx_max] < x_max and idx_max < len(xvals)-1: idx_max = idx_max + 1 x_interval = xvals[idx_min:idx_max+1] y_interval = yvals[idx_min:idx_max+1] if min_or_max == 'max': idx_val = np.argmax(y_interval) elif min_or_max == 'min': idx_val = np.argmin(y_interval) else: raise RuntimeError("Must choose 'min' or 'max' as fifth argument.") extreme_x = x_interval[idx_val] extreme_y = y_interval[idx_val] return extreme_x, extreme_y # Function to process a file using the other functions defined above def process_file(filename): data = read_data(filename) # print(data) # calc_strain_stress(data) # Testanrop strain, stress = calc_strain_stress(data) # print(strain) # print(stress) peak_strain, peak_stress = minmax_in_interval(strain, stress, 0, cutoff_peak, 'max') # print(peak_strain) # print(peak_stress) gradient = find_gradient(strain, stress) limit_strain, limit_stress = minmax_in_interval(strain, stress, cutoff_peak, cutoff_min, 'min') # print(limit_strain) # print(limit_stress) print('E-modulen:', round((gradient*10**(-9)), 3), 'GPa') plt.plot(strain, stress, label='') plt.title(filename) plt.xlabel('Strain') plt.ylabel('Stress') plt.scatter(peak_strain, peak_stress, s=800, facecolors='none', edgecolors='r', label='Upper load limit') plt.scatter(limit_strain, limit_stress, s=800, facecolors='none', edgecolors='g', label='Lower load limit') plt.show() # Function to retrieve the strain and load from the loaded data and calculate the stress with the load def calc_strain_stress(data): load = data[:,2] # givet i N stress = load/area # print(load) # print(stress) strain = data[:,4] # print(strain) return(strain,stress) # Loop to check if file exists and if so send it into the process_file-function for i in range(1,29): file_name = 'Specimen_RawData_' + str(i) + '.csv' #print(file_name) try: with open(file_name) as file: print(file_name) process_file(file_name) pass except IOError as e: print ("No file with the name:" , file_name)
Specimen_RawData_1.csv E-modulen: 202.453 GPa
Image in a Jupyter notebook
No file with the name: Specimen_RawData_2.csv Specimen_RawData_3.csv E-modulen: 114.416 GPa
WARNING: Some output was deleted.