La carta di Casagrande: come costruirla con python

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à (W_L) e l’indice di plasticità IP (IP=W_L-W_P), che si usano anche per la costruzione della carta di plasticità di Casagrande.

Con la carta di Casagrande 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 e come plottare su di essa dei campioni di terreno.

La carta di Casagrande

La carta di di Casagrande presenta nell’asse delle ascisse il limite di liquidità (W_L) mentre in quello delle ordinate l’indice di plasticità (IP). Molto importanti sono la “A-line” e il limite W_L=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 W_L del campione esaminato è uguale o maggiore a W_L=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 W_L del campione esaminato è minore a W_L=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 W_L=50% e ha un IP compreso tra 4 e 7 ricade nel campo delle argille e dei limi di bassa plasticità (CL-ML).

Il codice Python per costruire la carta di plasticità di Casagrande

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 W_L 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:

Ulteriori letture

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

Corso Python

Sei digiuno di Python e vuoi acquisire nozioni su questo potente linguaggio di programmazione? Ti consiglio il corso “Python 3.8 Guida Completa: da Principiante a Esperto” (LINK) presente su Udemy. Saper usare questo linguaggio di programmazione è molto utile, anche perchè possiamo creare da solo degli scripts per le tue analisi anzichè spendere soldi per software proprietari.