Giorgio Luciano

As scientists and data analysts, we often encounter complex curves in
our work. These could be spectroscopic data, chromatograms, or any other
type of signal that appears as a single peak but might be composed of
multiple underlying components. The process of breaking down such a
curve into its constituent parts is known as curve deconvolution or peak
fitting.

It's a common scenario: a researcher or student successfully decomposes
a curve into two or three components, and they're thrilled with the
result. It seems to fit well, and they're ready to draw conclusions
based on these components. But there's a crucial point that's often
overlooked: the number of components used in the deconvolution is often
arbitrary.

In this post, we'll explore why this is problematic and demonstrate how
we can fit a curve with a varying number of components using R. This
exercise will highlight why we should be cautious about interpreting the
results of curve deconvolution without careful consideration.

Let's start with some R code that generates a simple curve and then fits
it with a varying number of Gaussian components:

:::::::::::::::: {.cell}
::: {#cb1 .sourceCode .cell-code style="background: #f1f3f5;"}
``` {.sourceCode .r .code-with-copy}
# Load necessary libraries
library(minpack.lm)
```
:::

::: {.cell-output .cell-output-stderr}
 Warning: il pacchetto 'minpack.lm' è stato creato con R versione 4.3.3
:::

::: {#cb3 .sourceCode .cell-code style="background: #f1f3f5;"}
``` {.sourceCode .r .code-with-copy}
library(ggplot2)
```
:::

::: {.cell-output .cell-output-stderr}
 Warning: il pacchetto 'ggplot2' è stato creato con R versione 4.3.3
:::

::: {#cb5 .sourceCode .cell-code style="background: #f1f3f5;"}
``` {.sourceCode .r .code-with-copy}
# Function to generate a Gaussian curve
gaussian <- function(x, amp, cen, wid) {
 amp * exp(-((x - cen)^2) / (2 * wid^2))
}

# Generate sample data (a curve with a single peak)
set.seed(123)
x <- seq(0, 10, length.out = 100)
y <- gaussian(x, 1, 5, 1) + rnorm(100, sd = 0.05)
data <- data.frame(x = x, y = y)

# Function to create a model with n Gaussians
create_n_gaussian_model <- function(n) {
 components <- paste0("gaussian(x, amp", 1:n, ", cen", 1:n, ", wid", 1:n, ")", collapse = " + ")
 as.formula(paste("y ~", components))
}

# Function to fit n Gaussians
fit_n_gaussian <- function(data, n) {
 model <- create_n_gaussian_model(n)
 start_list <- as.list(rep(c(0.5, 5, 1), n))
 names(start_list) <- c(rbind(paste0("amp", 1:n), paste0("cen", 1:n), paste0("wid", 1:n)))
 
 fit <- nlsLM(model, data = data, start = start_list)
 return(fit)
}

# Fit with varying number of Gaussians
fits <- lapply(1:5, function(n) fit_n_gaussian(data, n))
```
:::

::: {.cell-output .cell-output-stderr}
 Warning in nls.lm(par = start, fn = FCT, jac = jac, control = control, lower = lower, : lmdif: info = -1. Number of iterations has reached `maxiter' == 50.
:::

::: {.cell-output .cell-output-stderr}
 Warning in nls.lm(par = start, fn = FCT, jac = jac, control = control, lower = lower, : lmdif: info = -1. Number of iterations has reached `maxiter' == 50.

 Warning in nls.lm(par = start, fn = FCT, jac = jac, control = control, lower = lower, : lmdif: info = -1. Number of iterations has reached `maxiter' == 50.
:::

::: {#cb8 .sourceCode .cell-code style="background: #f1f3f5;"}
``` {.sourceCode .r .code-with-copy}
# Calculate AIC for each fit
aics <- sapply(fits, AIC)

# Create predictions and components for each fit
for (i in 1:length(fits)) {
 data[paste0("fit", i)] <- predict(fits[[i]], newdata = data)
 params <- coef(fits[[i]])
 for (j in 1:i) {
 data[paste0("comp", j, "_", i)] <- gaussian(data$x, params[paste0("amp", j)], 
 params[paste0("cen", j)], 
 params[paste0("wid", j)])
 }
}

# Plot the results
ggplot(data, aes(x = x)) +
 geom_point(aes(y = y), alpha = 0.5) +
 geom_line(aes(y = fit1, color = "1 Gaussian")) +
 geom_line(aes(y = fit2, color = "2 Gaussians")) +
 geom_line(aes(y = fit3, color = "3 Gaussians")) +
 geom_line(aes(y = fit4, color = "4 Gaussians")) +
 geom_line(aes(y = fit5, color = "5 Gaussians")) +
 scale_color_manual(values = c("red", "blue", "green", "purple", "orange")) +
 labs(title = "Curve Deconvolution with Varying Number of Gaussians",
 subtitle = paste("AIC values:", paste(round(aics, 2), collapse = ", ")),
 x = "X", y = "Y", color = "Fit") +
 theme_minimal()
```
:::

:::: {.cell-output-display}
<div>

<figure class="figure">
<img
src="https://giorgioluciano.github.io/posts/022_pitfall_curves/index_files/figure-html/unnamed-chunk-1-1.png"
class="img-fluid figure-img" width="672" />
</figure>

</div>
::::

::: {#cb9 .sourceCode .cell-code style="background: #f1f3f5;"}
``` {.sourceCode .r .code-with-copy}
# Plot individual components for the 3-Gaussian fit
ggplot(data, aes(x = x)) +
 geom_point(aes(y = y), alpha = 0.5) +
 geom_line(aes(y = fit3, color = "Total Fit")) +
 geom_line(aes(y = comp1_3, color = "Component 1")) +
 geom_line(aes(y = comp2_3, color = "Component 2")) +
 geom_line(aes(y = comp3_3, color = "Component 3")) +
 scale_color_manual(values = c("black", "red", "blue", "green")) +
 labs(title = "Deconvolution into 3 Gaussians",
 x = "X", y = "Y", color = "Component") +
 theme_minimal()
```
:::

:::: {.cell-output-display}
<div>

<figure class="figure">
<img
src="https://giorgioluciano.github.io/posts/022_pitfall_curves/index_files/figure-html/unnamed-chunk-1-2.png"
class="img-fluid figure-img" width="672" />
</figure>

</div>
::::
::::::::::::::::

This code generates a single peak and then fits it with 1 to 5 Gaussian
components. It then plots the results and calculates the Akaike
Information Criterion (AIC) for each fit.

What we see from this exercise is striking:

1. All fits, from 1 to 5 components, appear to fit the data reasonably
 well visually.

2. The AIC values generally decrease as we add more components,
 suggesting that more complex models fit the data better.

However, here's the crucial point: our original data was generated from
a single Gaussian curve with added noise. Despite this, we can
"successfully" decompose it into 2, 3, 4, or even 5 components, each of
which might seem meaningful if we didn't know the true origin of the
data.

This demonstrates a fundamental issue in curve deconvolution: without
additional information or constraints, we can often fit a curve with an
arbitrary number of components, and purely statistical measures might
even suggest that more components provide a better fit.

So, what should we do? Here are some guidelines:

1. Always consider the physical or chemical meaning behind the
 components. Does it make sense in your specific context to have 2,
 3, or more components?

2. Use multiple criteria for model selection, not just visual fit or a
 single statistical measure. AIC, BIC, cross-validation, and other
 techniques can provide different perspectives.

3. Be cautious about over-interpretation. Just because you can fit a
 curve with multiple components doesn't necessarily mean those
 components represent real, distinct physical or chemical entities.

4. When possible, use additional experimental techniques to validate
 your deconvolution. For example, in spectroscopy, you might use
 different types of spectroscopy or chemical separation techniques to
 confirm the presence of multiple components.

5. Always report the uncertainty in your fits and be transparent about
 the assumptions made in your analysis.

In conclusion, while curve deconvolution can be a powerful tool, it's
crucial to approach it with caution and skepticism. The ability to fit a
curve with multiple components doesn't always reflect the underlying
reality of the system you're studying. As scientists and data analysts,
it's our responsibility to critically evaluate our methods and results,
always keeping in mind the limitations and potential pitfalls of our
analytical techniques.

As scientists and data analysts, we often encounter complex curves in our work. These could be spectroscopic data, chromatograms, or any other type of signal that appears as a single peak but might be composed of multiple underlying components. The process of breaking down such a curve into its constituent parts is known as curve deconvolution or peak fitting.

The Pitfall of Arbitrary Curve Deconvolution: A Cautionary Tale for Scientists and Students

::::::::::::::: {#excel-non-è-un-database-linee-guida-essenziali-per-una-corretta-gestione-dei-dati .section .level1}
# **Excel non è un Database: Linee Guida Essenziali per una Corretta Gestione dei Dati**

È fondamentale comprendere la differenza tra un foglio di calcolo e un
database, nonché l'importanza di una corretta gestione dei dati. Di
seguito sono riportati motivi per cui Excel non dovrebbe essere
utilizzato come database, insieme a criteri essenziali per gestire e
analizzare i dati in modo efficace.

::: {#perché-excel-non-è-un-database .section .level3}
### **Perché Excel non è un Database** {.anchored anchor-id="perché-excel-non-è-un-database"}

**1. Limitata integrità e validazione dei dati** 
Excel permette di inserire qualsiasi tipo di dato in qualsiasi cella,
senza un controllo rigido sulla coerenza. I database, al contrario,
richiedono la definizione di tipi di dati e limitano gli inserimenti in
base a queste regole, garantendo maggiore integrità.

**2. Mancanza di robuste funzionalità di sicurezza** 
I database offrono un controllo più sofisticato sugli accessi, con
ruoli, permessi e log di attività. In Excel, chiunque con accesso al
file può modificarlo senza lasciare traccia, mettendo a rischio la
sicurezza dei dati.

**3. Difficoltà nella gestione di grandi set di dati** 
Quando i dati superano certe dimensioni (milioni di righe o centinaia di
colonne), Excel diventa inefficiente e può bloccarsi. I database sono
progettati per gestire grandi volumi di dati in modo efficiente.

**4. Limitate capacità di collaborazione multiutente** 
Excel ha funzionalità di condivisione, ma i conflitti tra versioni
possono facilmente emergere. I database, invece, sono progettati per la
collaborazione simultanea senza perdita di dati.

**5. Assenza di strumenti complessi di interrogazione e reporting** 
Le query SQL nei database permettono analisi molto più complesse
rispetto a quanto sia possibile in Excel. I database offrono anche
reportistica avanzata con strumenti di Business Intelligence (BI).

[Clicca qui per ulteriori
info](https://giorgioluciano.github.io/posts/021_confronto_xls_database/confronto_xls_database.html)
:::

::::::::::: {#criteri-essenziali-per-la-gestione-dei-dati .section .level3}
### **Criteri Essenziali per la Gestione dei Dati** {.anchored anchor-id="criteri-essenziali-per-la-gestione-dei-dati"}

Quando si gestiscono dati per l'analisi, è importante rispettare
determinati criteri per garantire accuratezza ed efficienza.

::: {#convenzioni-di-denominazione-dei-file .section .level4}
#### **1. Convenzioni di Denominazione dei File** {.anchored anchor-id="convenzioni-di-denominazione-dei-file"}

Il nome di un file deve essere chiaro, descrittivo e privo di caratteri
speciali. Utilizzare nomi significativi è essenziale per garantire che
chiunque possa capire il contenuto del file senza doverlo aprire.
Evitare nomi vaghi come **"database_ultima_versione"** o
**"file_finale"**, che non offrono informazioni utili.

**Esempi corretti:**

- "2024924_nome_trial_autore_versione.csv"

- "2023_report_emoglobina_livelli.xls"

- "esame_glucosio_pazienti_clinica_X_v3.xlsx"

**Esempi da evitare:**

- "file_versione_definitiva_finale.xlsx"

- "dati123.xls"

**Evitare caratteri speciali:** 
Evita l'uso di caratteri come: 
/ \\ \* & \# % @ ( ) \[ \] { }

**Esempi corretti:**

- "dati_pazienti_2023.xlsx"

- "analisi_vitaminaD_v2.csv"

**Esempi da evitare:**

- "dati/pazienti(2023).xlsx"

- "report&finale#versione.xls"
:::

::: {#convenzioni-di-denominazione-delle-colonne-e-delle-righe .section .level4}
#### **2. Convenzioni di Denominazione delle Colonne e delle Righe** {.anchored anchor-id="convenzioni-di-denominazione-delle-colonne-e-delle-righe"}

I nomi di colonne e righe devono essere chiari e coerenti. Un nome
significativo aiuta a capire immediatamente cosa rappresentano i dati
senza necessità di ulteriori spiegazioni.

**Nomi significativi:** 
Utilizzare nomi che descrivano esattamente i dati contenuti. Ad esempio,
invece di usare nomi come **"var1"** o **"colonna1"**, usare nomi più
specifici come **"eta_paziente"** o **"Vitamina_D"**.

**Esempi corretti:**

- "nome_paziente"

- "eta"

- "altezza"

- "peso"

- "BMI"

- "Vitamina_D"

**Esempi da evitare:**

- "colonna1"

- "dato_A"

- "x1"

**Evitare caratteri speciali:** 
Come per i nomi dei file, evitare caratteri come spazi, trattini e
simboli speciali ("/", "&", "#", etc.) e lettere accentate. Usare
l'underscore (\_) o il camelCase (es. "nomeCliente") per separare le
parole.
:::

::: {#coerenza-nei-nomi .section .level4}
#### **3. Coerenza nei Nomi** {.anchored anchor-id="coerenza-nei-nomi"}

Evitare l'uso misto di maiuscole e minuscole, inglese e italiano, spazi
e underscore. I nomi devono seguire un formato coerente per evitare
confusione.

**Esempi da evitare:**

- "NomePaziente" (uso misto di maiuscole e minuscole)

- "pressione_Sanguigna" (uso misto di lingue)

- "data nascita" (uso di spazi)

**Esempi corretti:**

- "nome_paziente"

- "pressione_sistolica"

- "data_nascita"
:::

::: {#sensibilità-alle-maiuscole .section .level4}
#### **4. Sensibilità alle Maiuscole** {.anchored anchor-id="sensibilità-alle-maiuscole"}

Utilizzare lettere maiuscole e minuscole in modo coerente e
intenzionale. La distinzione tra maiuscole e minuscole può essere
significativa, soprattutto nei database case-sensitive.
:::

::: {#celle-vuote .section .level4}
#### **5. Celle Vuote** {.anchored anchor-id="celle-vuote"}

Una cella vuota può avere diversi significati. Assicurarsi di chiarire
sempre cosa indica una cella vuota (dati non misurati, fuori scala,
mancanti, etc.) per evitare ambiguità.
:::

::: {#zero-vs.-dati-mancanti .section .level4}
#### **6. Zero vs. Dati Mancanti** {.anchored anchor-id="zero-vs.-dati-mancanti"}

Assicurarsi di distinguere tra uno zero e un dato mancante. Utilizzare
valori specifici come **"NA"** o **"null"** per indicare dati mancanti e
non confonderli con zeri.
:::

::: {#notazione-numerica-coerente .section .level4}
#### **7. Notazione Numerica Coerente** {.anchored anchor-id="notazione-numerica-coerente"}

Le virgole e i punti hanno significati diversi nella notazione numerica
a seconda del paese. Assicurarsi di utilizzare una notazione numerica
coerente per evitare ambiguità nei valori.
:::

::: {#evitare-duplicati .section .level4}
#### **8. Evitare Duplicati** {.anchored anchor-id="evitare-duplicati"}

Non ci dovrebbero essere righe o colonne duplicate, a meno che non ci
sia una ragione specifica e giustificata. I duplicati possono falsare i
risultati dell'analisi.

Seguendo queste linee guida, i vostri dati saranno puliti, coerenti e
pronti per un'analisi accurata
:::
:::::::::::

::: {#ulteriori-linee-guida-per-dati-clinici .section .level3}
### Ulteriori Linee Guida per Dati Clinici {.anchored anchor-id="ulteriori-linee-guida-per-dati-clinici"}

Quando si gestiscono dati clinici o sensibili, sono necessarie ulteriori
precauzioni:

1. **Identificazione del Paziente** 
 Assicurarsi che i nomi dei pazienti (o gli ID se i nomi non possono
 essere riportati) siano coerenti e corretti. Errori nei dati
 identificativi possono portare a gravi conseguenze cliniche.

2. **Controllo di Errori Macroscopici** 
 Controllare errori macroscopici come altezze di 170 metri, pazienti
 che pesano 8 kg o con BMI irrealistici (\>30 o \<1). Questi errori
 evidenti possono influire negativamente sull'analisi.

3. **Formattazione Condizionale** 
 Applicare una formattazione condizionale ai dati quando possibile
 (es. evidenziare automaticamente le celle con valori fuori dal range
 atteso). Questo può aiutare a individuare rapidamente e visivamente
 gli errori nei dati. [Clicca qui per una guida alla formattazione
 condizionale](https://giorgioluciano.github.io/posts/020_Formattazione_condizionale/formattazione_condizionale.html)
:::

::: {#faq-domande-frequenti-su-excel-e-la-gestione-dei-dati .section .level3}
### **FAQ: Domande Frequenti su Excel e la Gestione dei Dati** {.anchored anchor-id="faq-domande-frequenti-su-excel-e-la-gestione-dei-dati"}

**1. Posso utilizzare Excel come database per piccoli set di dati?** 
Sì, Excel può essere utilizzato per piccoli set di dati, soprattutto se
si tratta di progetti temporanei o analisi rapide. Tuttavia, anche per
set di dati piccoli, un database garantisce maggiore integrità,
sicurezza e scalabilità, evitando potenziali problemi quando il volume
dei dati cresce.

**2. Perché Excel non è consigliato per dati sensibili come quelli
clinici?** 
Excel non offre controlli di accesso avanzati o log di modifica,
esponendo i dati a errori accidentali o manipolazioni non tracciate.
Inoltre, non è possibile crittografare o proteggere adeguatamente i dati
sensibili in un foglio di calcolo, aumentando il rischio di violazioni
della privacy.

**3. Quali sono i principali rischi di sicurezza nell'utilizzare Excel
per la gestione dei dati clinici?** 
I principali rischi includono:

- Modifiche accidentali o intenzionali non tracciate.

- Accesso non autorizzato ai dati.

- Mancanza di crittografia e protezione dei dati.

- Difficoltà nel mantenere la coerenza e l'integrità dei dati,
 specialmente in ambienti multiutente.

**4. È possibile limitare chi può accedere e modificare i dati in un
file Excel?** 
Excel offre alcune funzionalità di protezione, come la protezione delle
celle e l'impostazione di password per l'accesso ai fogli. Tuttavia,
queste misure sono deboli rispetto ai sistemi di sicurezza avanzati
disponibili in un database relazionale, che permettono controlli
granulari su chi può visualizzare o modificare i dati.

**5. Come posso gestire i duplicati in Excel?** 
Excel fornisce strumenti per individuare e rimuovere duplicati, ma il
controllo deve essere eseguito manualmente o tramite formule. Nei
database, le chiavi primarie possono essere utilizzate per garantire che
non ci siano duplicati nei record, offrendo una maggiore automazione e
affidabilità.

**6. Cosa devo fare se il mio file Excel diventa troppo grande e lento
da usare?** 
Se un file Excel diventa troppo grande, è probabile che tu abbia
superato i limiti operativi del foglio di calcolo. In questi casi, è
consigliabile migrare i dati in un database che può gestire volumi molto
più grandi di righe e colonne in modo efficiente, senza rallentamenti.

**7. Come posso evitare di commettere errori di formattazione numerica
(es. virgola e punto decimale)?** 
Assicurati di impostare correttamente le preferenze regionali nel
software che utilizzi per gestire i dati. Nei database, puoi specificare
in modo preciso il formato numerico accettato per evitare ambiguità,
cosa che Excel non può garantire automaticamente senza un'attenta
configurazione.
:::
:::::::::::::::

Excel non è un Database: Linee Guida Essenziali per una Corretta Gestione dei Dati
 

È fondamentale comprendere la differenza tra un foglio di calcolo e un database, nonché l’importanza di una corretta gestione dei dati. Di seguito sono riportati motivi per cui Excel non dovrebbe essere utilizzato come database, insieme a criteri essenziali per gestire e analizzare i dati in modo efficace.

Criteri Essenziali per La Gestione Dati

:::::::::::: {#formattazione-condizionale .section .level1}
# Formattazione Condizionale

La **formattazione condizionale** in Excel consente di applicare
automaticamente stili di formattazione (come colori delle celle, stili
di carattere o bordi) alle celle in base a determinate condizioni o
criteri specifici. Ecco i passaggi per eseguire una formattazione
condizionale in Excel:

::: {#passaggi-per-eseguire-la-formattazione-condizionale-in-excel .section .level3}
### Passaggi per eseguire la formattazione condizionale in Excel {.anchored anchor-id="passaggi-per-eseguire-la-formattazione-condizionale-in-excel"}

1. **Seleziona le celle da formattare:**

 - Evidenzia l'intervallo di celle su cui vuoi applicare la
 formattazione condizionale. Ad esempio, se vuoi applicarla a un
 elenco di valori numerici, seleziona l'intervallo come **A1**

2. **Apri il menu di formattazione condizionale:**

 - Vai alla scheda **Home** della barra multifunzione.

 - Nel gruppo **Stili**, clicca su **Formattazione condizionale**.

 **Scegli il tipo di regola:** Dal menu a discesa della formattazione
 condizionale, puoi scegliere diversi tipi di regole in base alle tue
 esigenze:

 - **Regole predefinite**:

 - **Evidenzia regole celle**: Usa questa opzione per applicare la
 formattazione a celle che soddisfano una condizione come
 "maggiore di", "minore di", "tra", "testo che contiene", ecc.

 - **Barre dati**: Applica barre colorate all'interno delle celle
 per rappresentare i valori numerici.

 - **Scale di colori**: Applica diverse sfumature di colori in base
 ai valori delle celle.

 - **Set di icone**: Applica icone (frecce, segni di spunta,
 semafori) per rappresentare i valori delle celle rispetto a una
 scala di valori.

 - **Nuova regola**: Clicca su **Nuova regola** per creare condizioni
 personalizzate. Ad esempio, puoi applicare una formattazione
 basata su formule specifiche.

 ![](https://giorgioluciano.github.io/posts/020_Formattazione_condizionale/images/Excel_fig2.png){.img-fluid}

3. **Definisci il criterio di formattazione:** Selezionando una delle
 opzioni predefinite, potrai impostare le condizioni. Ad esempio, se
 scegli "Maggiore di", inserisci il valore di riferimento nella
 casella, ad esempio **50**, per formattare tutte le celle che
 contengono un valore superiore a 50.

 Esempio: Se scegli **Evidenzia regole celle \> Maggiore di...**,
 puoi inserire il numero 50 e poi scegliere uno stile di
 formattazione come il riempimento rosso chiaro con testo rosso
 scuro.

 ![](https://giorgioluciano.github.io/posts/020_Formattazione_condizionale/images/Excel_fig4.png){.img-fluid}

4. **Scegli uno stile di formattazione:**

 - Seleziona lo stile che desideri applicare alle celle che
 soddisfano la condizione. Puoi scegliere tra colori di
 riempimento, colori del testo o bordi, oppure personalizzare lo
 stile cliccando su **Formato personalizzato**.

 ![](https://giorgioluciano.github.io/posts/020_Formattazione_condizionale/images/Excel_fig5.png){.img-fluid}

5. **Applica la regola:**

 - Dopo aver configurato la regola, clicca su **OK** per applicare la
 formattazione condizionale alle celle selezionate.

Ecco un esempio di come usare la **formattazione condizionale in Excel**
per un'**analisi del sangue**. Supponiamo che tu abbia un foglio con i
risultati di vari esami del sangue per diversi pazienti, e vuoi
evidenziare i risultati che sono al di fuori dei range normali per
facilitare l'identificazione di valori critici.
:::

::: {#esempio-di-analisi-del-sangue .section .level3}
### Esempio di analisi del sangue {.anchored anchor-id="esempio-di-analisi-del-sangue"}

| **Paziente** | **Emoglobina (g/dL)** | **Colesterolo (mg/dL)** | **Glucosio (mg/dL)** |
|---------------|-----------------------|-------------------------|----------------------|
| Mario Rossi | 12.5 | 180 | 95 |
| Anna Verdi | 14.8 | 240 | 110 |
| Luca Blu | 11.2 | 170 | 160 |
| Giulia Gialli | 13.6 | 220 | 85 |
:::

::: {#obiettivo .section .level3}
### Obiettivo: {.anchored anchor-id="obiettivo"}

Evidenziare i valori:

- **Emoglobina** al di fuori del range normale (tra 12 e 16 g/dL).

- **Colesterolo** superiore a 200 mg/dL (indica colesterolo alto).

- **Glucosio** superiore a 100 mg/dL (indica glicemia alta).
:::

:::::: {#passaggi-per-applicare-la-formattazione-condizionale .section .level3}
### Passaggi per applicare la formattazione condizionale: {.anchored anchor-id="passaggi-per-applicare-la-formattazione-condizionale"}

::: {#formattazione-per-lemoglobina-fuori-dal-range-normale .section .level4}
#### 1. Formattazione per l'emoglobina fuori dal range normale {.anchored anchor-id="formattazione-per-lemoglobina-fuori-dal-range-normale"}

Vogliamo evidenziare in **rosso** i valori di **Emoglobina** che sono al
di sotto di **12 g/dL** o al di sopra di **16 g/dL**.

- **Seleziona l'intervallo** delle celle che contiene i valori
 dell'emoglobina (es. **B2**

 ).

- Vai su **Home \> Formattazione condizionale \> Nuova regola**.

- Clicca su **Utilizza una formula per determinare le celle da
 formattare**.

- Inserisci la seguente formula per evidenziare i valori inferiori a 12
 o superiori a 16:

`=O(B2<12, B2>16)`

- Clicca su **Formato...** e scegli un riempimento rosso o un colore di
 testo rosso per evidenziare i valori fuori range.

- Clicca su **OK** per applicare la regola.
:::

::: {#formattazione-per-il-colesterolo-alto .section .level4}
#### 2. Formattazione per il colesterolo alto {.anchored anchor-id="formattazione-per-il-colesterolo-alto"}

Vogliamo evidenziare in **giallo** i valori di **Colesterolo** superiori
a **200 mg/dL**.

- **Seleziona l'intervallo** delle celle con i valori del colesterolo
 (es. **C2**).

- Vai su **Home \> Formattazione condizionale \> Evidenzia regole celle
 \> Maggiore di...**.

- Nella finestra che si apre, inserisci **200** come valore.

- Seleziona uno stile di formattazione predefinito o clicca su **Formato
 personalizzato** e scegli un riempimento giallo.

- Clicca su **OK**.
:::

::: {#formattazione-per-il-glucosio-alto .section .level4}
#### 3. Formattazione per il glucosio alto {.anchored anchor-id="formattazione-per-il-glucosio-alto"}

Vogliamo evidenziare in **arancione** i valori di **Glucosio** superiori
a **100 mg/dL**.

- **Seleziona l'intervallo** delle celle con i valori del glucosio (es.
 **D2**).

- Vai su **Home \> Formattazione condizionale \> Evidenzia regole celle
 \> Maggiore di...**.

- Inserisci **100** come valore.

- Seleziona uno stile di formattazione con riempimento arancione per i
 valori che superano il limite.

- Clicca su **OK**.
:::
::::::

::: {#risultato-finale .section .level3}
### Risultato finale: {.anchored anchor-id="risultato-finale"}

Dopo aver applicato queste regole, la tabella potrebbe apparire così:

![](https://giorgioluciano.github.io/posts/020_Formattazione_condizionale/images/Excel_fig7.png){.img-fluid}
:::

::: {#interpretazione .section .level3}
### Interpretazione: {.anchored anchor-id="interpretazione"}

- I valori di **Anna Verdi** e **Luca Blu** sono evidenziati per il
 colesterolo e il glucosio elevati, rispettivamente in ciano e
 arancione.

- Il valore dell'emoglobina di **Luca Blu** è evidenziato in rosso
 poiché è inferiore al valore normale di 12 g/dL.

- In questo modo, è facile individuare rapidamente i pazienti con valori
 critici, consentendo un'analisi più efficiente e una migliore gestione
 clinica.
:::
::::::::::::

Formattazione Condizionale

La

 formattazione condizionale

in Excel consente di applicare automaticamente stili di formattazione (come colori delle celle, stili di carattere o bordi) alle celle in base a determinate condizioni o criteri specifici.

Formattazione condizionale in Excel

:::::::::::::: {#confronto-tra-excel-e-database-nella-gestione-clinica-dei-dati-errori-e-sicurezza .section .level3}
### **Confronto tra Excel e Database nella Gestione Clinica dei Dati: Errori e Sicurezza** {.anchored anchor-id="confronto-tra-excel-e-database-nella-gestione-clinica-dei-dati-errori-e-sicurezza"}

::: {#caso-excel-errore-nel-valore-di-una-glicemia .section .level4}
#### **Caso Excel: Errore nel Valore di una Glicemia** {.anchored anchor-id="caso-excel-errore-nel-valore-di-una-glicemia"}

Un errore comune in Excel è l'inserimento di valori non corretti a causa
di formati non standardizzati. Supponiamo di avere una tabella in cui si
registrano i valori di glicemia dei pazienti. Il formato corretto
richiede l'uso del punto come separatore decimale (ad esempio, **5.8**
mmol/L), ma un utente inserisce erroneamente un valore con la virgola
(**5,8**).

Esempio di tabella:

| Paziente   | Valore di glicemia (mmol/L) |
|------------|-----------------------------|
| Paziente A | 5.6                         |
| Paziente B | 6.2                         |
| Paziente C | 5,8                         |
| Paziente D | 7.1                         |

In questo caso, Excel potrebbe trattare **5,8** come testo, non come
numero, perché la virgola è interpretata come un separatore non
numerico. Di conseguenza, il valore **5,8** verrebbe ignorato durante i
calcoli. Per esempio, se si tenta di calcolare la media dei valori con
la formula `=MEDIA(B2:B5)`, Excel considererà solo i valori numerici
(5.6, 6.2 e 7.1), restituendo una media non corretta.

- **Media calcolata da Excel (ignorando 5,8)**:  
  (5.6+6.2+7.1)/3=6.3(5.6 + 6.2 + 7.1) / 3 = 6.3(5.6+6.2+7.1)/3=6.3

- **Media corretta (includendo 5.8)**:  
  (5.6+6.2+5.8+7.1)/4=6.175(5.6 + 6.2 + 5.8 + 7.1) / 4 =
  6.175(5.6+6.2+5.8+7.1)/4=6.175

Questo errore può facilmente passare inosservato, portando a conclusioni
cliniche sbagliate.
:::

:::: {#caso-database-prevenzione-dellerrore .section .level4}
#### **Caso Database: Prevenzione dell'Errore** {.anchored anchor-id="caso-database-prevenzione-dellerrore"}

In un database, l'inserimento di dati con formato errato viene
automaticamente bloccato. Supponiamo che la colonna dei valori glicemici
sia definita come **DECIMAL** o **FLOAT**, dove è richiesto l'uso del
punto decimale. Se si tenta di inserire un valore con la virgola, il
database restituirà un errore, impedendo l'inserimento errato.

::: {#cb1 .sourceCode style="background: #f1f3f5;"}
``` {.sourceCode .sql .code-with-copy}
CREATE TABLE glicemia (
      paziente VARCHAR(50), 
      valore_glicemia DECIMAL(4,1) );

INSERT INTO glicemia (paziente, valore_glicemia) VALUES ('Paziente C', '5,8');
```
:::

Questo comando genererebbe un errore simile a:

**`ERROR: invalid input syntax for type numeric: "5,8"`**

Il database obbliga l'utente a correggere l'errore prima di continuare,
prevenendo errori nei calcoli successivi.
::::

::: {#caso-excel-mancanza-di-controllo-sugli-accessi .section .level4}
#### **Caso Excel: Mancanza di Controllo sugli Accessi** {.anchored anchor-id="caso-excel-mancanza-di-controllo-sugli-accessi"}

Excel non offre un sistema avanzato di controllo sugli accessi e
tracciamento delle modifiche. Supponiamo che un file Excel venga
utilizzato per gestire i dati clinici di pazienti, con il rischio che
qualsiasi utente con accesso possa modificare i dati (intenzionalmente o
accidentalmente) senza lasciare traccia.

Esempio:

| ID Paziente | Nome        | Diagnosi               | Terapia       | Medico        |
|-------------|-------------|------------------------|---------------|---------------|
| 001         | Mario Rossi | Ipertensione           | ACE Inibitori | Dott. Bianchi |
| 002         | Anna Verdi  | Diabete Tipo 2         | Insulina      | Dott. Neri    |
| 003         | Luca Blu    | Insufficienza cardiaca | Betabloccanti | Dott. Verdi   |

Un operatore sanitario potrebbe per errore modificare la terapia di un
paziente, sostituendo "Insulina" con "Metformina" per Anna Verdi. In
questo scenario, non ci sarebbe alcun modo di risalire a chi ha
apportato la modifica, poiché Excel non tiene traccia delle modifiche,
esponendo i dati clinici a gravi rischi.
:::

:::: {#caso-database-robustezza-nella-gestione-della-sicurezza .section .level4}
#### **Caso Database: Robustezza nella Gestione della Sicurezza** {.anchored anchor-id="caso-database-robustezza-nella-gestione-della-sicurezza"}

Un database offre robusti meccanismi di controllo degli accessi, con
permessi specifici per ogni ruolo. Ad esempio, solo determinati utenti
possono modificare i dati sensibili, mentre altri hanno accesso in sola
lettura. Inoltre, ogni modifica viene tracciata automaticamente,
registrando chi ha fatto la modifica e quando.

Esempio di gestione degli accessi:

::: {#cb2 .sourceCode style="background: #f1f3f5;"}
``` {.sourceCode .sql .code-with-copy}
GRANT SELECT ON cartella_clinica TO infermiera;
GRANT UPDATE ON terapia TO medico;
```
:::

Ogni modifica viene registrata, e se qualcuno cambia la terapia, è
possibile risalire all'operatore e correggere l'errore.  
Esempio di log delle modifiche:

| ID Paziente | Operatore   | Campo Modificato | Valore Precedente | Valore Nuovo | Data Modifica    |
|-------------|-------------|------------------|-------------------|--------------|------------------|
| 002         | infermiera1 | Terapia          | Insulina          | Metformina   | 2024-09-24 10:30 |
::::

::: {#caso-excel-duplicazione-dei-dati .section .level4}
#### **Caso Excel: Duplicazione dei Dati** {.anchored anchor-id="caso-excel-duplicazione-dei-dati"}

Un altro rischio comune in Excel è la duplicazione accidentale dei dati.
Supponiamo che durante l'inserimento di nuovi pazienti, un utente copi e
incolli una riga esistente invece di crearne una nuova, modificando solo
alcune informazioni e lasciando altri campi inalterati.

Esempio di tabella:

| ID Paziente | Nome        | Diagnosi               | Terapia       | Medico        |
|-------------|-------------|------------------------|---------------|---------------|
| 001         | Mario Rossi | Ipertensione           | ACE Inibitori | Dott. Bianchi |
| 002         | Anna Verdi  | Diabete Tipo 2         | Insulina      | Dott. Neri    |
| 003         | Mario Rossi | Insufficienza Cardiaca | Betabloccanti | Dott. Bianchi |

In questo caso, abbiamo due pazienti con lo stesso nome, ma terapie e
diagnosi diverse. Questa duplicazione potrebbe non essere immediatamente
evidente e potrebbe causare confusione clinica o errori nella gestione
del paziente. Excel non dispone di controlli per rilevare
automaticamente questi errori.
:::

:::::: {#caso-database-eliminazione-delle-duplicazioni .section .level4}
#### **Caso Database: Eliminazione delle Duplicazioni** {.anchored anchor-id="caso-database-eliminazione-delle-duplicazioni"}

Un database può evitare questo tipo di errore utilizzando vincoli di
unicità. Se la colonna "ID Paziente" è definita come chiave primaria,
nessun duplicato sarà consentito.  
Sebbene Excel sia uno strumento potente e molto utilizzato per la
gestione dei dati, può presentare alcune limitazioni, specialmente
quando si tratta di gestire dati sensibili come quelli clinici. Un
database strutturato offre un livello superiore di controllo e
sicurezza, prevenendo errori comuni come quelli dovuti a formati non
standardizzati o duplicazioni. La scelta dello strumento giusto dipende
dalle esigenze specifiche e dalla complessità dei dati da gestire, con
l'obiettivo di garantire sempre accuratezza e sicurezza.

Esempio:

::: {#cb3 .sourceCode style="background: #f1f3f5;"}
``` {.sourceCode .sql .code-with-copy}
CREATE TABLE cartella_clinica (
    id_paziente INT PRIMARY KEY,
    nome VARCHAR(100),
    diagnosi VARCHAR(100),
    terapia VARCHAR(100),
    medico VARCHAR(100)
);
```
:::

Se si tenta di inserire un nuovo paziente con un ID già esistente:

::: {#cb4 .sourceCode style="background: #f1f3f5;"}
``` {.sourceCode .sql .code-with-copy}
INSERT INTO cartella_clinica (id_paziente, nome, diagnosi, terapia, medico)
VALUES (003, 'Mario Rossi', 'Ipertensione', 'ACE Inibitori', 'Dott. Bianchi');
```
:::

Il database restituirebbe un errore simile a:

::: {#cb5 .sourceCode style="background: #f1f3f5;"}
``` {.sourceCode .sql .code-with-copy}
ERROR: duplicate key value violates unique constraint "cartella_clinica_pkey"
```
:::

Questo impedisce l'inserimento accidentale di dati duplicati,
preservando l'integrità dei dati clinici.

------------------------------------------------------------------------

L'utilizzo di Excel per la gestione di dati clinici comporta rischi
significativi di errori dovuti a formati incoerenti, duplicazioni e
mancanza di tracciabilità. Al contrario, un database offre strumenti
avanzati per prevenire questi problemi, garantendo una maggiore
sicurezza, precisione e affidabilità nella gestione dei dati clinici.
::::::
::::::::::::::


Confronto tra Excel e Database nella Gestione Clinica dei Dati: Errori e Sicurezza


 Caso Excel: Errore nel Valore di una Glicemia

Un errore comune in Excel è l’inserimento di valori non corretti a causa di formati non standardizzati. Supponiamo di avere una tabella in cui si registrano i valori di glicemia dei pazienti.

Confronto tra Excel e Database nella Gestione Clinica dei Dati: Errori E Sicurezza

::::::: {#non-negotiables-for-your-data .section .level1}
# **Non-Negotiables for Your Data**

In today's data-driven world, it is essential to understand the
difference between a spreadsheet and a database, as well as the
importance of proper data management. This post will explain why Excel
should not be used as a database and provide key guidelines for
effectively managing and analyzing data.

::: {#why-excel-is-not-a-database .section .level3}
### Why Excel Is Not a Database {.anchored anchor-id="why-excel-is-not-a-database"}

While Excel is a powerful tool for many tasks, it's important to
recognize its limitations when it comes to data management. Here are
some key reasons why:

1.  **Limited Data Integrity and Validation**  
    Excel allows users to input any type of data in any cell without
    strict consistency checks. Databases, on the other hand, enforce
    data types and restrict entries based on predefined rules.

2.  **Lack of Robust Security Features**  
    Databases provide more advanced access control, including roles,
    permissions, and activity logs. In Excel, anyone with file access
    can modify the data without any trace.

3.  **Difficulty Handling Large Datasets**  
    As data grows (millions of rows or hundreds of columns), Excel
    becomes inefficient and prone to crashing. Databases are designed to
    handle large datasets efficiently.

4.  **Limited Multi-user Collaboration**  
    Although Excel offers sharing features, version conflicts can easily
    arise. Databases are built for simultaneous collaboration without
    data loss.

5.  **Lack of Advanced Querying and Reporting Tools**  
    SQL queries in databases allow for far more complex analyses than
    Excel can handle. Additionally, databases offer advanced reporting
    features with Business Intelligence (BI) tools.

For serious data management needs, it's advisable to use a dedicated
database system like MySQL, PostgreSQL, or MongoDB.
:::

::::: {#key-guidelines-for-data-management .section .level3}
### Key Guidelines for Data Management {.anchored anchor-id="key-guidelines-for-data-management"}

When someone provides data for analysis, it's important to adhere to
certain standards to ensure accurate and efficient analysis.

::: {#file-naming-conventions .section .level4}
#### 1. **File Naming Conventions** {.anchored anchor-id="file-naming-conventions"}

File names should be clear, descriptive, and free of special characters.
Using meaningful names is essential to ensure that anyone can understand
the content of the file without having to open it. Avoid vague or
generic names like *"database_latest_version"* or *"final_file"*, which
provide little context.

Here are some best practices for naming files:

- **Good examples**:

  - *"yyyymmdd_trial_name_author_revision"*

  - *"hospitalXYZ_patient_data.csv"*

- **Examples to avoid**:

  - *"final_final_version_file.xlsx"*

  - *"data123*.xls"\*

Avoid special characters like spaces or symbols that can cause issues in
different systems and software. Characters to avoid include:

- `/`, `\`, `*`, `&`, `#`, `%`, `@`

Instead, use underscores (`_`) to separate words (e.g.,
*"correct_file_name.xlsx"*).
:::

::: {#column-and-row-naming-conventions .section .level4}
#### 2. **Column and Row Naming Conventions** {.anchored anchor-id="column-and-row-naming-conventions"}

Just like file names, column and row names should follow the same rules
of clarity and consistency. Meaningful column names help everyone
immediately understand the data without needing extra explanations.

**Here are some guidelines for naming columns and rows:**

- **Use meaningful names**:  
  Columns should clearly describe the data they contain. Instead of
  using generic names like *"var1"* or *"column1"*, use more specific
  names like *"patient_age"* or *"quantity_sold"*.

- **Good examples**:

  - *"patient_name"*, *"Vitamin D" , "Cholesterol"*

- **Examples to avoid**:

  - *"column1"*, *"data_A"*, *"x1"*

- **Avoid special characters**:  
  Like file names, avoid characters like spaces, dashes, or special
  symbols (*"/"*, *"&"*, *"#"*, etc.). Use underscores (`_`) or
  camelCase (e.g., *"customerName"*) to separate words in column names.

3.  **Case Sensitivity**  
    Be intentional with the use of uppercase and lowercase letters to
    differentiate categories, data types, or names. Case sensitivity can
    be important, especially when working with case-sensitive databases
    or programming languages.

4.  **Empty Cells**  
    An empty cell has meaning. Is it an unmeasured value? An
    out-of-scale value? A missing value? Or data that cannot be
    retrieved? Always clarify the meaning of empty cells to avoid
    ambiguity.

5.  **Zero vs. Missing Data**  
    Zero is different from missing data. Ensure that this distinction is
    clear in the dataset, perhaps by using a specific value (e.g., "NA"
    or "null") to indicate missing data.

6.  **Consistent Numeric Notation**  
    Commas and periods have different meanings in numerical notation
    depending on the region (e.g., 1,000 in the US means "one thousand,"
    whereas in Europe it may mean "one"). Use consistent and clear
    numeric notation throughout the document.

7.  **Avoid Duplicates**  
    There should be no duplicate rows or columns unless there is a
    specific and justified reason for their presence. Duplicates can
    skew analysis results.

Following these guidelines will ensure your data is clean, consistent,
and ready for accurate analysis. Remember, good data management
practices are the foundation for reliable research and decision-making.
:::
:::::
:::::::


Non-Negotiables for Your Data
 

In today’s data-driven world, it is essential to understand the difference between a spreadsheet and a database, as well as the importance of proper data management. This post will explain why Excel should not be used as a database and provide key guidelines for effectively managing and analyzing data.

Messaggi di Rogue Scholar

The Pitfall of Arbitrary Curve Deconvolution: A Cautionary Tale for Scientists and Students

Criteri Essenziali per La Gestione Dati

Formattazione condizionale in Excel

Confronto tra Excel e Database nella Gestione Clinica dei Dati: Errori E Sicurezza

Non-Negotiables for Your Data