---
# System prepended metadata

title: Relazione sull'utilizzo di `root` per la generazione algoritmica di decadimenti

---

# Relazione sull'utilizzo di `root` per la generazione algoritmica di decadimenti

L'obiettivo dell'esercitazione era di simulare il decadimento di particelle appartenenti al modello standard tramite il software `root` distribuito dal CERN di Ginevra. Abbiamo implementato in C++ il programma facendo riferimento allo standard ed a corrette pratiche di sviluppo. Per esempio abbiamo usato `std::vector` per contenere le particelle in modo che la memoria sia automaticamente allocata e liberata secondo RAII.

# TODO

Motivare le scelte fatte tra cui:
1. Le condizioni nella selezione dell'istogramma di massa invariante tra `invmass0`-`invmass05`

## Compilazione

Il codice è stato compilato tramite `g++` con aggiuntivi parametri per il linker che simulano l'esecuzione all'interno del REPL di `root` come pseudo-macro che eseguono il `main`.

Dunque di seguito ecco i comandi di compilazione:
```bash
g++ `root-config --cflags --glibs` Simulation.cpp ResonanceType.cpp ParticleType.cpp Particle.cpp -o Simulation
```
```bash
g++ `root-config --cflags --glibs` DataAnalysis.cpp ResonanceType.cpp ParticleType.cpp Particle.cpp -o DataAnalysis
```

## Impostazione

È presente un vettore `std::vector` di particelle del tipo `ResonanceType`, ricondotte a `ParticleType` nel caso non siano dotate di larghezza `fWidth`. 
Sono generati e 7 tipi di particelle nell’array `ntot`, a cui vengono assegnate masse `mass` e cariche `charge`.
È chiamato il metodo `Particle::AddParticleType` su ognuno di essi.

Sono poi generati gli istogrammi necessari ed è chiamato il metodo `Sumw2` su ognuno di essi per rendere possibile il calcolo degli errori degli istogrammi ottenuti grazie alla loro corretta elaborazione nella propagazione. 
Gli istogrammi generati sono i seguenti:
* `types` per i tipi di particelle generati 
* `angles` per gli angoli azimutali e polari
* `pav` per l’impulso medio
* `impulse` per l’impulso trasverso
* `energy` per la distribuzione di energia 
* `invmass0` fino a `invmass5` per le masse invarianti tra particelle a prescindere dal segno per particelle con carica di segno opposto, per particelle con carica dello stesso segno, pioni e kaoni di segno opposto, pioni e kaoni dello stesso segno per i decadimenti (è stato segnato in commento di toglierlo) 
* `htot`, un vettore di istogrammi, per contenerli tutti e facilitare il salvataggio e la stampa dei risultati a seguito della generazione


## Generazione

In primo luogo il vettore di `ResonanceType` è riempito in base alle istanze generate randomicamente ogniqualvolta viene rilevato un tipo di particella non presente in esso. 

La generazione randomica del tipo di particella e del suo impulso è gestita tramite `gRandom` in un sistema di coordinate sferiche, poi ricondotte ai loro corrispettivi cartesiani.

Gli angoli sono stati generati in coordinate polari per permettere una migliore corrispondenza con la trattazione matematica delle collisioni tra particelle. Questo si riespecchia sull'impulso, anche esso scomposto in coordinate polari.

La media dell'impulso `p` è stata impostata ad 1 e segue una distribuzione esponenziale decrescente.
```c++
double average_p = gRandom->Exp(1.);
```

La probabilità di generazione del tipo di particella è gestita tramite due variabili: `x` è indicativa del tipo, mentre `y` determina come la particella decade, e nel caso di un decadimento con l'1% di probabilità, se decade in una coppia `ppion`-`nkaon` oppure `npion`-`pkaon`, questo viene aggiunto all'istogramma della massa invariante tra i due.

La particella è aggiunta al vettore delle particelle generate, l'istogramma dei tipi `types` viene riempito con l'indice corrispondente al suo tipo, come quello degli angoli `angles` e della media degli impulsi `pav`, nonché quello dei moduli degli impulsi `impulse` e delle energie `energy`.

Di seguito la spiegazione algoritmica basata sull'introduzione dei cicli `for` etichettati da lettere `[I]`,`[J]`, etc... 

```c++
for (int i = 0; i < 1E5; i++) {                            // [I]
    // I.1. Itero 100 volte per ognuna delle 1E5 particelle, entrando in [J]
    for (int j = 0; j < 100; j++) {                        // [J]
        // J.1 Generiamo le variabili casuali
        // J.2 Determiniamo il tipo di particella
        // J.3 Riempiamo gli istogrammi di tipo, angolo,
        //      distribuzione dell'impulso medio, 
        //      impulso trasverso ed energia
    }
    // I.2 Aggiungiamo gli eventi di risonanza all'array
    //     degli eventi con un for loop
    // I.3 Itero lungo EventParticle, entrando in [K]
    int size = EventParticle.size();
    for (int k = 0; k < size - 1; k++) {                    // [K]
        // K.1 Se è una risonanza passo all'iterazione
        //     successiva
        // K.2 Itero per ogni altra particella
        for (int l = k + 1; l < size; l++) {                // [L]
            // L.1 Come per K.1
            // L.2 Aggiungo la massa invariante tra la
            //     particella k e la l nel rispettivo
            //     istogramma (invmass0-5)
        }
    }
    // I.4 Libero i vettori prima di passare alla 
    //     iterazione successiva
    EventParticles.clear();
    ResonanceEvents.clear();
}
```

## Scrittura e Chiusura

### Creazione del file

Crea un nuovo file `Particles.root` col metodo `TFile` di Root, con specifica `RECREATE`, così da eliminare eventuali file omonimi generati in precedenza.
```c++
TFile *f = new TFile("Particles.root", "RECREATE");
```

Il parametro `RECREATE` è stato specificato per rigenerare il file ogniqualvolta il programma venga eseguito, sovrascrivendo il precedente.
### Riempimento del file

Scrive sul file così creato tutti gli elementi dell’array di istogrammi `htot`, così da avere un file di root completo di tutti i dati ottenuti dalla simulazione.
```c++
// For each element in htot write it in file f
for (int i = 0; i < 11; ++i) {
    htot[i]->Write();
}
```
### Pulizia della memoria

Chiude il file e pulisce la memoria puntata dai puntatori di `char` associati ai vari tipi di particella.
```c++
// Operation repeated for each ParticleType
delete ppion; 
```

## Analisi dei dati

1. Sistemo le impostazioni grafiche
2. Inizializzo il file `Particles.root` da cui carico tutti gli istogrammi di cui istemo le impostazioni
4. Genero 6 funzioni `f1`-`f6` e le fitto ai relativi istogrammi
5. Scrivo il file `HistoData.txt` con `std::ofstream`
6. Controlla attentamente come scrive i file pdf da root
    7. ATTENZIONE ALLE [ ] !!!
8. Da completare...