venerdì, gennaio 08, 2010

Installare ROOT su Ubuntu

Chi ha un Ubuntu 9.10 (Karmic Koala) come sistema operativo può installare ROOT (versione 5.18b) direttamente tramite il sistema di pacchetti di Ubuntu e via interfaccia grafica.
1) Aprire il menu Applicazioni/Ubuntu Software Center.
2) Nella casella di ricerca digitrare ROOT
3) Installare il pacchetto ROOT con un semplice clic!

Per chi volesse installarlo da linea di comando (apt-get / aptitude)
1) Aprire un terminale
2) digitare
sudo apt-get install root-system-bin libroot-minuit5.18 libroot-minuit-dev root-fitter
e inserire la propria password utente
3) Fine :)

Aggiungendo gli opportuni repository al file /etc/apt/sources.list questa procedura dovrebbe funzionare anche su Debian (ma non ho provato personalmente, feedback in merito sono graditi).

Naturalmente se volete l'ultimissima versione potete scaricare il sorgente dal sito ufficiale di ROOT e compilarlo.

lunedì, novembre 02, 2009

Istruzioni per la connesione internet:
- una volta loggati, aprire un browser (firefox)
- in Modifica/preferenze/avanzate/rete/impostazioni
- attivare la modalità "configurazione manuale del proxy"
ed inserire "proxyu9.lib.unimib.it" - porta 8080
- attivare "utilizza questo proxy per ogni protocollo"
- confermare tutto e tornare alla pagina del browser
- se viene richiesto di inserire utente e password, mettete le vostre
(utente è : lib\bi01matricola)

sabato, settembre 27, 2008

ROOT Troubleshooting

Dato che "a volte ritornano" e di solito si tratta di problemi penso che sia utile riportare qui una mini guida per risolvere uno dei problemi più comuni che seguono l'installazione di ROOT sul proprio pc. Il problema riguarda gli utenti Linux, ma, ovviamente, è un problema da poco e la soluzione è immediata (c'è gia anche sulle slide, in particolare qui) ma capita che uno non la colga e rischi di impazzire perchè, nonostante l'installazione abbia funzionato, non si riesce a fare ripartire ROOT.
Per ulteriori informazioni (cos'è bash?, cos'è export? che vuol dire il carattere "$" prima dei nomi?) si rimanda ai testi specializzati sull'argomento.

************************************************************************
Troubleshooting (trad. "sparalo allo problema!")
Hai installato ROOT (hai digitato "make" da qualche parte e hai visto
una lista di scritte che scorrevano?) e magari l'avevi anche fatto
partire appena installato ma adesso hai aperto un terminale e digitando:
----------------------------------------------------------------------
root
----------------------------------------------------------------------
non parte?
Prima di tutto, controlliamo se la tua shell è una bash o una
tcsh apri un terminale e digita
----------------------------------------------------------------------
echo $SHELL
----------------------------------------------------------------------
se ottieni una risposta del tipo:
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
/bin/bash
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
allora la tua shell è una bash.
Di seguito le istruzioni sono quelle per una shell bash, qui ci sono i
comandi adatti per le shell tcsh.
ROOT non parte perchè il sistema semplicemente... non sa dove andarlo a
pescar!! Bisogna impostare le variabili di ambiente che indichino
dove sta il nostro ROOT.
Per farlo ecco i tre seguenti comandi EXPORT che devi digitare nella shell.
----------------------------------------------------------------------
export ROOTSYS=percorso_di_base_di_root
export PATH=$ROOTSYS/bin:$PATH
export LD_LIBRARY_PATH=$ROOTSYS/lib:$LD_LIBRARY_PATH
----------------------------------------------------------------------
percorso_di_base_di_root è la cartella dove hai fatto "make"
quando l'hai installato. Ecco un esempio: ho scaricato il file .tar e
salvato nella cartella "~/root++" e poi estratto.
Quindi devo digitare (per la tilde si deve fare AltGr + ì [i con l'accento])
----------------------------------------------------------------------
export ROOTSYS=~/root++/root/
----------------------------------------------------------------------
e gli altri due comandi export.
A questo punto digitando
----------------------------------------------------------------------
root
----------------------------------------------------------------------
dovrebbe partire.
Se tutto funziona ora noterai che se chiudi la shell (che oltre a essere
un termine frequente in fisica atomica e nucleare è il nome tecnico del
terminale) e la riapri per far partire ROOT dovresti digitare di nuovo
quei comandi.
Per automatizzare la cosa, vai nella tua cartella "~" che è la tua
cartella "home" personale e digita il comando:
----------------------------------------------------------------------
ls -a
----------------------------------------------------------------------
che ti mostra tutti ( all ) i file (anche quelli nascosti) presenti
nella cartella. Cerca il file chiamato:
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
.bashrc
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
(il punto all'inizio vuol dire che il file è nascosto.)
Se lo trovi, digita:
----------------------------------------------------------------------
nano .bashrc
----------------------------------------------------------------------
Dovresti vedere una cosa tipo:
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
# ~/.bashrc: executed by bash(1) for non-login shells.
# see /usr/share/doc/bash/examples/startup-files (in the package bash-doc)
# for examples
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
e aggiungi le seguenti righe in fondo (le righe che cominciano con il #
sono commentate)
----------------------------------------------------------------------
# comandi per ROOT
export ROOTSYS=percorso_di_base_di_ROOT
export PATH=$ROOTSYS/bin:$PATH
export LD_LIBRARY_PATH=$ROOTSYS/lib:$LD_LIBRARY_PATH
----------------------------------------------------------------------
ossia i comandi che hai digitato prima.
Quando hai finito premi
----------------------------------------------------------------------
Ctrl+O
Invio
Ctrl+X
----------------------------------------------------------------------
In questo modo salvi il file, confermi il nome e esci.
(La guida dei comandi di "nano" la vedi nella parte inderiore della
finestra ;) ).
A questo punto aprendo una shell e andando in una cartella qualsiasi,
digitando
----------------------------------------------------------------------
root
----------------------------------------------------------------------
Dovresti vedere il logo.
Buon lavoro.

Permission is granted to copy, distribute and/or modify this
document under the terms of the GNU Free Documentation License,
Version 1.2 or any later version published by the Free Software
Foundation; with no Invariant Sections, no Front-Cover Texts and
no Back-Cover Texts. A copy of the license is included in the
section entitled "GNU Free Documentation License".
***********************************************************************
Disclaimer: se qualcuno ha da discutere sul fatto che il migliore editor non sia "nano", ma per esempio "vim" o "emacs" evidentemente ne sa abbastanza da solo da non avere bisogno di questo post.

martedì, marzo 18, 2008

esame del 19 marzo

Ciao, sul sifa c'è scritto che l'esame si svolgerà alle 14 mentre avevo sentito voci che dicevano che sarebbe stato di mattina.
L'aula è sempre la stessa?

giovedì, dicembre 13, 2007

root su vista

domanda di carattere tecnico: ho delle difficoltà nel far partire ROOT su Vista.
s i installa correttamene ma poi non riesco ad utilizzrlo.
consigli?
ciao

lunedì, dicembre 03, 2007

mercoledì, novembre 28, 2007

introduzione all'ereditarieta'

Ecco alcune slide di introduzione all'ereditarieta', da sfogliare come lettura serale prima della lezione del 3/4 dicembre.

lunedì, novembre 26, 2007

mercoledì, novembre 21, 2007

varie

Precisazioni dell'esercizio per la prossima volta.

  1. Partendo dalle indicazioni e dai suggerimenti sulle slide, scrivere una classe vettore per la gestione di array dinamici, templata sul tipo di dati da allocare nel vettore.
  2. Compilare ed eseguire questo semplice programma. Riconoscete l'origine di ogni riga stampata come output?
  3. Scrivere una funzione doppio_di, esterna alla classe (ovvero non un metodo della classe), che prenda come unico argomento, passato per valore, un oggetto V della vostra classe vettore e restituisca un vettore W i cui elementi W[i] sono ciascuno il doppio di V[i].
  4. Scrivere una funzione void raddoppiami che prenda come unico argomento il riferimento di un vettore e raddoppi il valore di ciascun suo elemento.
  5. Implementare gli opportuni metodi (e aggiungere eventualmente gli opportuni attributi) perchè la classe vettore consenta il cambiamento della dimensione dell'array dinamico. In particolare, consenta sia di ridurre il numero di elementi (preservando il valore dei primi elementi sopravvissuti) e sia di aumentarne (preservando il valore dei primi elementi già esistenti). Inutile dirlo: attenzione ai new e delete!
Nel risolvere gli esercizi 3 e 4, far tesoro dell'esercizio 2...

Nota tecnica: con linux, per connettersi ad internet con un modem telefonico (non-ADSL), è possibile usare i seguenti programmi: gnome-ppp (se usate gnome come) o kppp (se usate KDE). Se la versione di linux non e' troppo vecchia, tutto dovrebbe essere molto semplice e intuitivo: basta trovare una di queste due applicazioni nel menu e utilizzarle nel modo più naturale possibile. Per ulteriori dettagli (ma non dovrebbe essercene bisogno...) potete leggere qui.

lunedì, novembre 19, 2007

martedì, novembre 13, 2007

complessi & istogramma

Esercizio facile-facile: dato il seguente header-file complesso.hpp per una possibile classe dei numeri complessi, scriverne l'implementazione in un corrispondente file complesso.cpp (e ovviamente, com'è sempre sottinteso, scrivere una test-unit per tale classe, ovvero un semplice programma capace di testare tutte le funzionalità implementate per la classe).
Esercizio facile: scrivere una classe istogramma da usare per l'analisi della soluzione all'esercizio 10. La classe istogramma non dovrà contenere al suo interno il generatore di numeri casuali, ma dovrà contenere solo quei metodi e quegli attributi che gli sono necessari per poter gestire una situazione del tutto generica in cui si vuole

  • popolare l'istogramma inserendo un valore alla volta
  • disegnare l'istogramma allo stato corrente (ovvero corrispondente alla popolazione di valori inseriti fino a quel momento)
  • restituire il valore della media e della varianza della popolazione allo stato corrente
Ulteriori specifiche (come la possibilità di indicare il numero di bin dell'istogramma, la possibilità di poter cambiare al volo il numero di bin, ovvero di poter cambiare il numero di bin quando l'istogramma è già stato creato e (parzialmente) riempito, la possibilità di cambiare al volo il numero bin soltanto accorpando i bin correntemente usati, e così via...) sono lasciati alla libertà dello studente.

NOTA BENE
Se avete domande (ed è bene per voi che ne abbiate!) sfruttate almeno la mailinglist del gruppo, ovvero scrivete una mail a labinfodocet@googlegroups.com

giovedì, novembre 08, 2007

allora...?

...chi è che racconta qui sul blog qual è la sottigliezza cui bisogna prestare attenzione nel risolvere l'esercizio 6, rispetto alla soluzione dell'esercizio 5?
...e chi è che mette un bello screenshot dell'ASCII-istogramma che ha ottenuto? Va bene con qualsiasi generatore random...!

mercoledì, novembre 07, 2007

strutture

Per chi le ha già viste durante la seconda lezione, per chi le vedrà nella prossima lezione, ecco le slide sulle strutture.
Vi ricordo che le slide delle lezioni precedenti si trovano qui.

mercoledì, ottobre 31, 2007

materiale per cominciare

A parte un po' di filosofia sui numeri casuali, ecco le slides della prima lezione (cliccate sulle singole diapositive per vederle ingrandite).
Per avere una bozza di codice in C/C++ da cui partire, ecco il piccolo programma visto in classe.
Per gli affezionati di Windoz™, un modo per giocare col C/C++ è quello di usare DevCpp: leggete qui per sapere come scaricarlo e come usarlo.
Vi ricordo gli esercizi step-by-step richiesti per la prossima volta. Va da sè che la "soluzione" ad ogni esercizio (tipicamente la funzione che si richiede di scrivere) va testata in un main che la usa e mostra in qualche modo che il suo funzionamento e' quello richiesto. Per tutti questi esercizi si darà per scontato la conoscenza e l'utilizzo della funzione rand() del C/C++ che abbiamo visto in classe.
  1. scrivere un(a funzione che costituisca da) generatore di numeri casuali interi distribuiti uniformemente nell'intervallo [0,RAND_MAX];
  2. scrivere un generatore di numeri casuali floating-point (float o double) distribuiti uniformemente nell'intervallo [0,1];
  3. scrivere un generatore di numeri casuali floating-point distribuiti uniformemente nell'intervallo [0,1), ovvero 1 escluso;
  4. scrivere un generatore di numeri casuali floating-point distribuiti uniformemente nell'intervallo [0,6);
  5. scrivere un generatore di numeri casuali floating-point distribuiti uniformemente nell'intervallo [1,6);
  6. scrivere un generatore di numeri casuali interi distribuiti uniformemente nell'intervallo [1,6];
  7. scrivere un generatore di numeri casuali floating-point distribuiti uniformemente nell'intervallo [-2,2);
  8. scrivere un generatore di numeri casuali floating-point distribuiti uniformemente nell'intervallo [-M_PI,M_PI);
  9. scrivere una funzione che accetta due argomenti di tipo floating-point (a e b) e che costituisca un generatore di numeri casuali floating-point distribuiti uniformemente nell'intervallo [a,b);
  10. scrivere un generatore di numeri casuali floating-point distribuiti nell'intervallo [-M_PI/2,M_PI/2) con una probabilità proporzionale alla funzione coseno;

IMPORTANTE: siete caldamente invitati a scrivere post e commenti su questo blog per condividere problemi, idee, dubbi e — sì — anche soluzioni. Non è escluso che qualche problema, idea, dubbio e — sì — soluzione possa venire anche da parte nostra...
Buon lavoro!

sabato, ottobre 27, 2007

Benvenuti!

Inizia il corso per l'anno accademico 2007-2008.

Questo blog, al quale sono registrati anche diversi studenti che hanno seguito il corso del 2006-2007, e' pensato come luogo di discussione fra gli studenti, di scambio di problemi e soluzioni, di condivisione di trucchi, link e scoperte (riguardo agli argomenti del corso ;) ).

Chiunque si iscriva, mandando uno dei seguenti email
valentina.tancini [at] mib.infn.it
vincenzo.miccio [at] mib.infn.it
verra' inserito fra gli amministratori, con tutte le prerogrative (ad esempio, potra' lui stesso inserire nuovi autori).

mercoledì, luglio 04, 2007

lista di algoritmi

dalla wikipedia, una lista di algoritmi.

giovedì, giugno 21, 2007

TPad

Ciao a tutti,
Volevo mettere in evidenza un nuovo oggetto di ROOT che ho scoperto da poco, si tratta del TPad. (documentazione e tutorial con un istrogramma riempito con numeri casuali). Utilizzando questo oggetto si possono rappresentare in un TCanvas più grafici contemporaneamente. Le opzioni sono molto simili a quelle del TCanvas.
Da segnalare anche (sempre nel TCanvas) l'azione "Inspect" che si può attivare facendo clic con il tasto destro del mouse è utile perchè da l'elenco dello stato di tutte le variabili che compongono l'oggetto, insieme ad una breve descrizione.
Posto un file di esempio con un TCanvas nel quale sono rappresentati due grafici (una carica di un circuito RC e la stessa relazione linearizzata) e qui l'output.

lunedì, giugno 11, 2007

forum in web

Ecco un forum di sviluppatori, interessante da consultare per vedere se qualcuno ha gia' posto il problema che non riusciamo a risolvere

thescripts developers network

venerdì, giugno 01, 2007

giovedì, maggio 10, 2007

un altro sito interessante sulle STL

http://www.ishiboo.com/~nirva/c++/stl-ref/