Geologia e Python: la carta di Casagrande

Per classificare i terreni, da un punto di vista geotecnico, sono importati i limiti di Atterberg con i quali si determinano il limite di liquidità (WL) e l’indice di plasticità IP (IP=WL-WP), che si usano anche per la costruzione della carta di plasticità di Casagrande.

Con questa carta si classificano i campione di “fine”, ossia quella porzione di terreno passante al setaccio n°40 (0.420 mm).

In questo post vedremo come, usando Python, costruire la carta di plasticità di Casagrande ecome plottare su di essa dei campioni di terreno.

geologia-python

La carta di Casagrande

La carta di di Casagrande presenta nell’asse delle ascisse il limite di liquidità (WL) mentre in quello delle ordinate l’indice di plasticità (IP). Molto importanti sono la “A-line” e il limite WL=50%, in quanto determinano delle aree con diverse caratteristiche fisiche.

Molto importante è la “U-line” che svolge il compito di limite massimo: se i campioni si trovano al di sopra di essa vanno ripetuti i limiti di Atterberg.

Se il WL del campione esaminato è uguale o maggiore a WL=50% abbiamo MH o OH (limi inorganici di alta plasticità oppure argille organiche da media a alta plasticità) se ricade sotto la “A-line”, mentre se ricade sopra la “A-line” avremo CH o OH (argille inorganiche di alta plasticità o argille organiche da media a alta plasticità).

Se il WL del campione esaminato è minore a WL=50% abbiamo ML o OL (limi inorganici da bassa a media plasticità o limi e argille organiche di bassa plasticità) se ricade sotto la “A-line”, mentre se ricade sopra la “A-line” avremo CL o OL (argille inorganiche da bassa a media plasticità o limi e argille organiche di bassa plasticità).

Se il nostro campione si trova a sinistra di WL=50% e ha un IP compreso tra 4 e 7 ricade nel campo delle argille e dei limi di bassa plasticità (CL-ML).

carta-Casagrande
La carta di plasticità di Casagrande

Il codice Python

In questo paragrafo vediamo il codice Python per costruire la carta di Casagrande e classificare i nostri campioni di fine.

Innanzitutto importiamo la libreria matplotlib (documentazione ufficiale) e creiamo due liste che contengono rispettivamente i dati di WL e di IP dei nostri campioni.

Che cosa è una lista? In parole povere una lista può essere paragonata ad un contenitore di biscotti. Prendiamo ad esempio la lista a=[1,2,3,4,5]: a=[] è il contenitore (a è il suo nome) mentre 1,2,3,4,5 sono i biscotti (i dati che dobbiamo analizzare).

import matplotlib.pyplot as plt
import numpy as np

IP=[6,11,5,8,6,6,6,6,11,12,8,10,8]
WL=[33,35,21,36,22,26,30,27,32,33,31,32,32]

Il passo successivo è disegnare le linee che suddividono la carta nelle diverse porzioni. Dopo aver inserito le coordinate (ad esempio per la U-line sono contenute nelle liste x e y) le inseriamo con il comando plt.plot(). Dentro le parentesi inseriamo le coordinate da plottare, il tipo tratteggio della linea, il colore (attraverso il comando color=’’) che vogliamo assegnare alla linea e lo spessore della linea (linewidth=).

#################################
a=0
a1=0
b=60
b1=60
plt.plot([a,b],[a1,b1], '-', color='black', linewidth=0.8)
#################################

#######################U-line######################
x=[16,16,16]
y=[0,2,4]
plt.plot(x, y, '--', color='gray', linewidth=0.8)

wl=[17.29,20.42,30.83,50,51.67,62.08,72.50]
ip=[7,10,20,38.40,40,50,60]
plt.plot(wl,ip, '--', color='gray', linewidth=0.8)
###################################################

#######################A-line######################
wl=[25.48,33.70,47.40,61.10,74.79,88.49,102.19]
ip=[4,10,20,30,40,50,60]
plt.plot(wl,ip, '-', color='black', linewidth=0.8)
###################################################

#######################CL-ML#######################
x=[4,10,20,25.48]
y=[4,4,4,4]
plt.plot(x,y, '-', color='black', linewidth=0.8)

x2=[7,10,20,29.59]
y2=[7,7,7,7]
plt.plot(x2,y2, '-', color='black', linewidth=0.8)
###################################################

#######################WL=50%####################################
plt.axvline(x=50, ymin=0,ymax=0.64, color='black', linewidth=0.8)

Una volta create le aree della carta inseriamo, usando il comando plt.text(), le etichette che le identificano. Dentro le parentesi del comando vanno inserite le coordinate con le quali posizionare le etichette nella carta ed il testo dell’etichetta.

#IMPOSTO LE ETICHETTE DA METTERE NELLE PORZIONI DELLA CARTA#
ch= 'CH or OH'
mh= 'MH or OH'
cl= 'CL or OL'
ml='ML or OL'
cl_ml='CL-ML'

plt.text(70,50, ch) #PLOTTO ETICHETTA NELLA CARTA
plt.text(75,22, mh) #PLOTTO ETICHETTA NELLA CARTA
plt.text(42,25, cl) #PLOTTO ETICHETTA NELLA CARTA
plt.text(39,7, ml) #PLOTTO ETICHETTA NELLA CARTA
plt.text(15,5, cl_ml) #PLOTTO ETICHETTA NELLA CARTA

Per rendere inclinate le etichette della “A-line” e della “U-line” ho definito una funzione addtext()

def addtext(props):
    plt.text(45, 35, 'U-line', props, rotation=45)
    plt.text(62, 32, 'A-line', props, rotation=35)

addtext({'ha': 'left', 'va': 'bottom'})

Per definire una funzione si usa la parola chiave def, che informa istantaneamente Python di ció che stiamo facendo, seguita dal nome che volete dare a questa funzione.

I nomi assegnati devono essere rappresentativi dello scopo della funzione. Il nome viene seguito da una coppia di parentesi, e all’interno delle parentesi metteremo i parametri, ovvero delle variabili necessarie al funzionamento della funzione. Ma non tutte le funzioni necessitano di parametri.

Seguendo la logica di Python, il codice che viene inserito all’interno della funzione deve essere indentato.

Per eseguire la funzione dobbiamo richiamarla, usando semplicemente il suo nome.

All’interno della nostra funzione abbiamo inserito, attraverso plt.text(), i punti dove posizionare le etichette, le etichette con le loro proprietà e l’angolo di rotazione. Una volta richiamata la funzione dentro le parentesi inseriamo le variabili relative all’ allineamento del testo.

Non rimane che assemblare il grafico inserendo gli assi delle ascisse e delle ordinate, con le relative etichette, ed inserire dentro il grafico i dati dei nostri campioni (presenti nelle liste create all’inizio!).

Gli assi vengono generati con il comando plt.axis(): dentro le parentesi vengono inseriti il limite inferiore e superiore di entrambi. Per etichettarli diamo rispettivamente plt.xlabel() e plt.ylabel().

Per inserire i nostri dati usiamo plt.plot(): dentro le parentesi inseriamo le liste e ‘or’ dove o indica il simbolo da usare e r, che sta per red, indica impostare il colore della simbologia.

Con il comando plt.show() compare a schermo il risultato finale.

########Creazione grafico ed inserimento campioni###########
plt.axis([0, 100, 0, 60])

plt.xlabel('WL(%)')
plt.ylabel('IP(%)')

plt.plot(WL,IP, 'or')

plt.show()

Il risultato è il seguente:

Approfondimenti

Per approfondire l’argomento trattato in questo post sono consigliati i seguenti libri:

Questi testi possono essere acquistati con Amazon Prime, che prevede una prova gratuita di 30 giorni. Potete iscriversi a questo servizio cliccando sul banner sottostante.

Spread the love

Lascia un commento

Il tuo indirizzo email non sarà pubblicato. I campi obbligatori sono contrassegnati *