Python e geologia: uno script per i limiti di Atterberg

Molto spesso chi si occupa di geotecnica cerca di capire il comportamento di un terreno al variare del contenuto d’acqua. Per questo motivo vengono stimati, dei terreni a grana fine, i cosiddetti limiti di Atterberg.

Durante la mia tesi ho stimato in laboratorio i limiti di Atterberg di campioni dei terreni di copertura – presenti nel bacino del Torrente Gravegnola, in Val di Vara (SP) – interessati da innumerevoli frane superficiali innescatesi in seguito all’evento pluviometrico del 25/10/2011.

In questo articolo, dopo aver spiegato come usare Python per costruire una curva granulometrica e per rappresentare le giaciture geologiche, spiegherò come stimare i limiti di Atterberg con uno script scritto in Python.

Cosa è Python?

Python è un linguaggio di programmazione di altissimo livello. La sua sintassi, ovvero il modo in cui si scrive, è praticamente identica all’inglese scritto. Perciò, se comparato ad altri linguaggi di programmazione come ad esempio Java e C++, ricordare le varie istruzioni della programmazione Python risulta estremamente semplice e veloce.

Python è un linguaggio molto versatile, adatto a progetti sia di piccola che di grande dimensione. Inoltre è uno dei linguaggi che sta alla base di servizi online e Siti Web estremamente famosi e apprezzati come ad esempio Instagram, YouTube nonché di Dropbox, il famosissimo servizio cloud.

python

Cosa sono i limiti di Atterberg?

In geotecnica, i limiti di Atterberg indicano il valore limite del contenuto di acqua per il quale si registra una transizione dello stato fisico del terreno.

In questo post potete trovare informazioni più approfondite su questa importante prova geotecnica di laboratorio.

Lo script Python per i limiti di Atterberg

Come prima si devono importare le librerie:


import matplotlib.pyplot as plt
from numpy import *
import numpy as np
from scipy import interpolate
from scipy import stats
import statistics

In seguito creo 4 liste contenenti il numero di colpi, le tare dei barattoli che contengono i campioni durante la pesata, il peso secco e il peso umido. Ho creato un ciclo per calcolare il contenuto d’acqua W.


############################ LIMITE DI LIQUIDITA #################################

Colpi=[15,20,40]
P_tara=[34.09, 33.58, 33.56]
P_umidot=[39.39, 44.42, 45.85]
P_seccot=[37.88, 41.40, 42.60]

if len(P_umidot) == len(P_seccot):
    W=[((x-y)/(y-z))*100 for (x,y,z) in zip(P_umidot, P_seccot, P_tara)]
else:
    print("Errore: le lunghezze sono diverse")
    print("len(P_umidot) = ", len(P_umidot))
    print("len(P_seccot) = ", len(P_seccot))
    print("len(P_tara) = ", len(P_tara))
    exit(1)

print(W)

I risultati del ciclo if vengono plottati in un grafico con il seguente codice, che crea anche la linea di regressione.


#creo una figura di 8x8 pollici con risoluzione di 80 punti/pollice
plt.figure(figsize=(8,8))

# creo un unico sistema di assi cartesiani nella figura
#plt.subplot(1, 1, 1) #(1riga,1colonna,grafico1)

# Plottaggio grafico
grafico=plt.plot(Colpi,W, "bo", label='Limite Liquidità')


# Impostazioni asse y
plt.ylim(35,40.5)
plt.yticks([35,35.5,36,36.5,37,37.5,38,38.5,39,39.5,40,40.5])

#griglia
plt.grid(True)

#label assi
plt.xlabel('COLPI')
plt.ylabel('W')

#legenda
plt.legend()


#creazione linea regressione
p1=np.polyfit(Colpi,W,1)

poli=plt.plot(Colpi,polyval(p1,Colpi),"r-", label='Linea Regressione')

plt.legend()

plt.show()

E questo è il grafico risultante

grafico python limiti atterberg

Adesso non ci resta che ricavare il limite liquido dalla retta di regressione, della quale otteniamo l’equazione con questo blocco di codice:


#stima WL a 25 colpi

slope, intercept, r_value, p_value, std_err = stats.linregress(Colpi, W)

print(intercept)
print(slope)

WL=(-0.1493*25)+41.869 #calcolo l'equazione della retta, considerando slope, intercept e 25(numero di colpi)

print(WL)

Il limite liquido risulta così essere pari a 38, in coerenza con il valore che avevo ricavato – con un altro software – durante la mia tesi.

A questo punto ho scritto anche un blocco di codice per calcolare il limite plastico, usando gli stessi dati ricavati in laboratorio e impiegando formula del contenuto d’acqua usata per il limite liquido. Il limite plastico è dato dalla dei tre risultati.

#CALCOLO LIMITE PLASTICO#

P_tara=[34.73,33.38,2.35]
P_umido_tara=[38.55,37.36,5.59]
P_secco_tara=[37.72,36.49,4.94]

if len(P_umido_tara) == len(P_secco_tara):
    W=[((x-y)/(y-z))*100 for (x,y,z) in zip(P_umido_tara, P_secco_tara, P_tara)]
else:
    print("Errore: le lunghezze sono diverse")
    print("len(P_umidot) = ", len(P_umidot))
    print("len(P_seccot) = ", len(P_seccot))
    print("len(P_tara) = ", len(P_tara))
    exit(1)

print(W)

limite_plastico=statistics.mean(W) #media dei tre contenuti d'acqua

Wp=round(limite_plastico) #limite plastico arrotondato

print(Wp)

Anche in questo caso il valore del limite plastico combacia con quello fornito dal software usato durante la tesi, a dimostrazione del corretto sviluppo di questo algoritmo.

Approfondimenti

Se volete approfondire per l’argomento trattato in questo post consiglio i seguenti testi:

Ciao, mi chiamo Antonio Nirta e sono un geologo. Mi sono laureato all’Università di Pisa e dal 2017 svolgo la libera professione.

Attraverso i post presenti in questo blog cercherò di trasmettere la mia passione per le Scienze Geologiche e di fornire informazioni che riguardano il bellissimo settore della Geologia.