Łukasz Graczykowski - New pages [en]

Sieci komputerowe 2025/2026 lato

2026-02-24T10:43:04Z

Lgraczyk: Created page with " {| align="right" | __TOC__ |} == Informacje == Prowadzący przedmiot: dr hab. inż. Łukasz Graczykowski, prof. uczelni e-mail: lukasz.graczykowski [at] pw.edu.pl..."

{| align="right"
| __TOC__
|}

== Informacje ==
Prowadzący przedmiot: 
dr hab. inż. Łukasz Graczykowski, prof. uczelni 
e-mail: lukasz.graczykowski [at] pw.edu.pl 
konsultacje: umawiamy się indywidualnie (najlepiej pisząc mi wiadomość w MS Teams) 

== Wykłady ==
Pliki w zespole MS Teams.




== Regulamin ==
Pełna treść regulaminu (zajęcia stacjonarne) znajduje się [http://olimp3.if.pw.edu.pl/~majanik/data/SK/RegulaminSieciKomputerowe.pdf tutaj].

'''Warunki zaliczenia'''
Maksymalna suma punktów do uzyskania to: '''100''' 
Składa się na nią:
* '''20 pkt''' - kolokwium na wykładzie
* '''30 pkt''' - projekty (2 projekty x 15 pkt)
* '''30 pkt''' - wejściówki na laboratorium (6 wejściówek x 5 pkt)
* '''14 pkt''' - obecność (7 zajęć x 2 pkt)
* '''6 pkt''' - praca na laboratorium (subiektywna ocena zaangażowania studenta przez prowadzącego)

Zaliczenie: '''>50 pkt''' 
<code>'''Uwaga:''' Aby przedmiot zaliczyć, należy również przekroczyć 50% punktów z kolokwium wykładowego (>10 pkt), projektów (traktowanych łącznie; >15 pkt) oraz wejściówek (>15 pkt). </code>

'''Oceny:'''
* <= 50 pkt - 2.0 (niezaliczone)
* 50.5 - 60 pkt - 3.0
* 60.5 - 70 pkt - 3.5
* 70.5 - 80 pkt - 4.0
* 80.5 - 90 pkt - 4.5
* >90 pkt - 5.0

== Laboratorium - Bieżące wyniki ==
Bieżące wyniki znajdują się na tej stronie.

== Zadania ==
Zadania na laboratorium - tryb stacjonarny:

* [http://www.if.pw.edu.pl/~lgraczyk/wiki/index.php/SK_Zadanie_1_remote Zajęcia 1],
* [http://www.if.pw.edu.pl/~lgraczyk/wiki/index.php/SK_Zadanie_2 Zajęcia 2]
* [http://www.if.pw.edu.pl/~lgraczyk/wiki/index.php/SK_Zadanie_4 Zajęcia 3]
* [http://www.if.pw.edu.pl/~lgraczyk/wiki/index.php/SK_Zadanie_5 Zajęcia 4]
* [http://www.if.pw.edu.pl/~lgraczyk/wiki/index.php/SK_Zadanie_3 Zajęcia 5]
* [http://www.if.pw.edu.pl/~lgraczyk/wiki/index.php/SK_Zadanie_6 Zajęcia 6]
* [http://www.if.pw.edu.pl/~lgraczyk/wiki/index.php/SK_Zadanie_7 Zajęcia 7]



Stara strona laboratorium:
http://www.if.pw.edu.pl/~lgraczyk/sk/html/ 
<code>'''Uwaga:''' Aby powyższa strona się poprawnie wyświetlała, należy ręcznie ustawić kodowanie ''Unicode'' w przeglądarce.</code>

KADD 2025/2026

2026-02-24T10:42:21Z

Lgraczyk: Created page with " {| align="right" | __TOC__ |} == Informacje - wykład == Wykład z przedmiotu Komputerowa analiza danych doświadczalnych Prowadzący: dr hab. inż. Łukasz Graczy..."

{| align="right"
| __TOC__
|}

== Informacje - wykład ==
Wykład z przedmiotu Komputerowa analiza danych doświadczalnych 
Prowadzący: 
dr hab. inż. Łukasz Graczykowski, prof. ucz. 
e-mail: lukasz.graczykowski [at] pw.edu.pl 
konsultacje: MS Teams 
Na konsultacje proszę umawiać się przez MS Teams.

'''Zasady ustalania oceny końcowej''' 
Regulamin przedmiotu znajduje się tutaj. 
Za każde z 11 punktowanych laboratoriów można otrzymać 0-5 pkt. 
Za każde z 2 kolokwiów na laboratorium można otrzymać 30 pkt. 
Za kolokwium na wykładzie można otrzymać 35 pkt. 
Końcowa liczba punktów: 150.

Poniższa tabelka przedstawia przedziały procentowe i odpowiadające im oceny:
{| class="wikitable" border="1"
|-
! Przedział procentowy
! Przedział punktowy
! Ocena
|-
| (50%; 60%>
| 75.5 - 90.0
| 3.0
|-
| (60%; 70%>
| 90.5 - 105.0
| 3.5
|-
| (70%; 80%>
| 105.5 - 120.0
| 4.0
|-
| (80%; 90%>
| 120.5 - 135.0
| 4.5
|-
| (90%; 100%>
| 135.5 - 150.0
| 5.0
|}

== Wykłady ==

MS Teams

Sieci komputerowe 2025/2026 zima

2025-10-13T10:06:42Z

KADD 2024/2025

2025-02-25T12:53:17Z

Lgraczyk: /* Informacje - wykład */

Sieci komputerowe 2024/2025 lato

2025-02-19T15:10:29Z

Lgraczyk: /* Informacje */

Sieci komputerowe 2024/2025 zima

2024-10-04T06:27:56Z

Lgraczyk: Created page with " {| align="right" | __TOC__ |} == Informacje == Prowadzący przedmiot: dr hab. inż. Łukasz Graczykowski e-mail: lukasz.graczykowski [at] pw.edu.pl konsultacj..."

{| align="right"
| __TOC__
|}

== Informacje ==
Prowadzący przedmiot: 
dr hab. inż. Łukasz Graczykowski 
e-mail: lukasz.graczykowski [at] pw.edu.pl 
konsultacje: umawiamy się indywidualnie (najlepiej pisząc mi wiadomość w MS Teams) 

== Wykłady ==
Pliki w zespole MS Teams.




== Regulamin ==
Pełna treść regulaminu (zajęcia stacjonarne) znajduje się [http://olimp3.if.pw.edu.pl/~majanik/data/SK/RegulaminSieciKomputerowe.pdf tutaj].

'''Warunki zaliczenia'''
Maksymalna suma punktów do uzyskania to: '''100''' 
Składa się na nią:
* '''20 pkt''' - kolokwium na wykładzie
* '''30 pkt''' - projekty (2 projekty x 15 pkt)
* '''30 pkt''' - wejściówki na laboratorium (6 wejściówek x 5 pkt)
* '''14 pkt''' - obecność (7 zajęć x 2 pkt)
* '''6 pkt''' - praca na laboratorium (subiektywna ocena zaangażowania studenta przez prowadzącego)

Zaliczenie: '''>50 pkt''' 
<code>'''Uwaga:''' Aby przedmiot zaliczyć, należy również przekroczyć 50% punktów z kolokwium wykładowego (>10 pkt), projektów (traktowanych łącznie; >15 pkt) oraz wejściówek (>15 pkt). </code>

'''Oceny:'''
* <= 50 pkt - 2.0 (niezaliczone)
* 50.5 - 60 pkt - 3.0
* 60.5 - 70 pkt - 3.5
* 70.5 - 80 pkt - 4.0
* 80.5 - 90 pkt - 4.5
* >90 pkt - 5.0

== Laboratorium - Bieżące wyniki ==
Bieżące wyniki znajdują się na tej stronie.

== Zadania ==
Zadania na laboratorium - tryb stacjonarny:

* [http://www.if.pw.edu.pl/~lgraczyk/wiki/index.php/SK_Zadanie_1_remote Zajęcia 1],
* [http://www.if.pw.edu.pl/~lgraczyk/wiki/index.php/SK_Zadanie_2 Zajęcia 2]
* [http://www.if.pw.edu.pl/~lgraczyk/wiki/index.php/SK_Zadanie_4 Zajęcia 3]
* [http://www.if.pw.edu.pl/~lgraczyk/wiki/index.php/SK_Zadanie_5 Zajęcia 4]
* [http://www.if.pw.edu.pl/~lgraczyk/wiki/index.php/SK_Zadanie_3 Zajęcia 5]
* [http://www.if.pw.edu.pl/~lgraczyk/wiki/index.php/SK_Zadanie_6 Zajęcia 6]
* [http://www.if.pw.edu.pl/~lgraczyk/wiki/index.php/SK_Zadanie_7 Zajęcia 7]



Stara strona laboratorium:
http://www.if.pw.edu.pl/~lgraczyk/sk/html/ 
<code>'''Uwaga:''' Aby powyższa strona się poprawnie wyświetlała, należy ręcznie ustawić kodowanie ''Unicode'' w przeglądarce.</code>

KADD 2023/2024

2024-02-20T11:04:54Z

{| align="right"
| __TOC__
|}

== Informacje - wykład ==
Wykład z przedmiotu Komputerowa analiza danych doświadczalnych 
Prowadzący: 
dr hab. inż. Łukasz Graczykowski 
e-mail: lukasz.graczykowski [at] pw.edu.pl 
konsultacje: MS Teams 
Na konsultacje proszę umawiać się przez MS Teams.

'''Zasady ustalania oceny końcowej''' 
Regulamin przedmiotu znajduje się tutaj. 
Za każde z 11 punktowanych laboratoriów można otrzymać 0-5 pkt. 
Za każde z 2 kolokwiów na laboratorium można otrzymać 30 pkt. 
Za kolokwium na wykładzie można otrzymać 35 pkt. 
Końcowa liczba punktów: 150.

Poniższa tabelka przedstawia przedziały procentowe i odpowiadające im oceny:
{| class="wikitable" border="1"
|-
! Przedział procentowy
! Przedział punktowy
! Ocena
|-
| (50%; 60%>
| 75.5 - 90.0
| 3.0
|-
| (60%; 70%>
| 90.5 - 105.0
| 3.5
|-
| (70%; 80%>
| 105.5 - 120.0
| 4.0
|-
| (80%; 90%>
| 120.5 - 135.0
| 4.5
|-
| (90%; 100%>
| 135.5 - 150.0
| 5.0
|}

== Wykłady ==

MS Teams

Sieci komputerowe 2023/2024 lato

2024-02-20T11:04:10Z

Sieci komputerowe 2023/2024 zima

2023-10-06T06:14:31Z

Lgraczyk: /* Wykłady */

{| align="right"
| __TOC__
|}

== Informacje ==
Prowadzący przedmiot: 
dr hab. inż. Łukasz Graczykowski 
e-mail: lukasz.graczykowski [at] pw.edu.pl 
konsultacje: umawiamy się indywidualnie (najlepiej pisząc mi wiadomość w MS Teams) 

== Wykłady ==
Pliki w zespole MS Teams.

Wykład bieżący [link].




== Regulamin ==
Pełna treść regulaminu (zajęcia stacjonarne) znajduje się [http://olimp3.if.pw.edu.pl/~majanik/data/SK/RegulaminSieciKomputerowe.pdf tutaj].

'''Warunki zaliczenia'''
Maksymalna suma punktów do uzyskania to: '''100''' 
Składa się na nią:
* '''20 pkt''' - kolokwium na wykładzie
* '''30 pkt''' - projekty (2 projekty x 15 pkt)
* '''30 pkt''' - wejściówki na laboratorium (6 wejściówek x 5 pkt)
* '''14 pkt''' - obecność (7 zajęć x 2 pkt)
* '''6 pkt''' - praca na laboratorium (subiektywna ocena zaangażowania studenta przez prowadzącego)

Zaliczenie: '''>50 pkt''' 
<code>'''Uwaga:''' Aby przedmiot zaliczyć, należy również przekroczyć 50% punktów z kolokwium wykładowego (>10 pkt), projektów (traktowanych łącznie; >15 pkt) oraz wejściówek (>15 pkt). </code>

'''Oceny:'''
* <= 50 pkt - 2.0 (niezaliczone)
* 50.5 - 60 pkt - 3.0
* 60.5 - 70 pkt - 3.5
* 70.5 - 80 pkt - 4.0
* 80.5 - 90 pkt - 4.5
* >90 pkt - 5.0

== Laboratorium - Bieżące wyniki ==
Bieżące wyniki znajdują się na tej stronie.

== Zadania ==
Zadania na laboratorium - tryb stacjonarny:

* [http://www.if.pw.edu.pl/~lgraczyk/wiki/index.php/SK_Zadanie_1_remote Zajęcia 1],
* [http://www.if.pw.edu.pl/~lgraczyk/wiki/index.php/SK_Zadanie_2 Zajęcia 2]
* [http://www.if.pw.edu.pl/~lgraczyk/wiki/index.php/SK_Zadanie_4 Zajęcia 3]
* [http://www.if.pw.edu.pl/~lgraczyk/wiki/index.php/SK_Zadanie_5 Zajęcia 4]
* [http://www.if.pw.edu.pl/~lgraczyk/wiki/index.php/SK_Zadanie_3 Zajęcia 5]
* [http://www.if.pw.edu.pl/~lgraczyk/wiki/index.php/SK_Zadanie_6 Zajęcia 6]
* [http://www.if.pw.edu.pl/~lgraczyk/wiki/index.php/SK_Zadanie_7 Zajęcia 7]



Stara strona laboratorium:
http://www.if.pw.edu.pl/~lgraczyk/sk/html/ 
<code>'''Uwaga:''' Aby powyższa strona się poprawnie wyświetlała, należy ręcznie ustawić kodowanie ''Unicode'' w przeglądarce.</code>

KADD 2022/2023

2023-02-17T10:10:25Z

Lgraczyk: Created page with " {| align="right" | __TOC__ |} == Informacje - wykład == Wykład z przedmiotu Komputerowa analiza danych doświadczalnych Prowadzący: dr inż. Łukasz Graczykowsk..."

Sieci komputerowe 2022/2023 lato

2022-10-03T09:20:45Z

Lgraczyk: /* Laboratorium - Bieżące wyniki */

{| align="right"
| __TOC__
|}

== Informacje ==
Prowadzący przedmiot: 
dr inż. Łukasz Graczykowski 
e-mail: lukasz.graczykowski [at] pw.edu.pl 
konsultacje: umawiamy się indywidualnie (najlepiej pisząc mi wiadomość w MS Teams) 

== Wykłady ==
Pliki w zespole MS Teams.

Wykład bieżący [http://www.if.pw.edu.pl/~lgraczyk/SK2022/lato/Wykla65-2022l.pdf link].




== Regulamin ==
Pełna treść regulaminu (zajęcia stacjonarne) znajduje się [http://olimp3.if.pw.edu.pl/~majanik/data/SK/RegulaminSieciKomputerowe.pdf tutaj].

'''Warunki zaliczenia'''
Maksymalna suma punktów do uzyskania to: '''100''' 
Składa się na nią:
* '''20 pkt''' - kolokwium na wykładzie
* '''30 pkt''' - projekty (2 projekty x 15 pkt)
* '''30 pkt''' - wejściówki na laboratorium (6 wejściówek x 5 pkt)
* '''14 pkt''' - obecność (7 zajęć x 2 pkt)
* '''6 pkt''' - praca na laboratorium (subiektywna ocena zaangażowania studenta przez prowadzącego)

Zaliczenie: '''>50 pkt''' 
<code>'''Uwaga:''' Aby przedmiot zaliczyć, należy również przekroczyć 50% punktów z kolokwium wykładowego (>10 pkt), projektów (traktowanych łącznie; >15 pkt) oraz wejściówek (>15 pkt). </code>

'''Oceny:'''
* <= 50 pkt - 2.0 (niezaliczone)
* 50.5 - 60 pkt - 3.0
* 60.5 - 70 pkt - 3.5
* 70.5 - 80 pkt - 4.0
* 80.5 - 90 pkt - 4.5
* >90 pkt - 5.0

== Laboratorium - Bieżące wyniki ==
Bieżące wyniki znajdują się na tej stronie.

== Zadania ==
Zadania na laboratorium - tryb stacjonarny:

* [http://www.if.pw.edu.pl/~lgraczyk/wiki/index.php/SK_Zadanie_1_remote Zajęcia 1],
* [http://www.if.pw.edu.pl/~lgraczyk/wiki/index.php/SK_Zadanie_2 Zajęcia 2]
* [http://www.if.pw.edu.pl/~lgraczyk/wiki/index.php/SK_Zadanie_4 Zajęcia 3]
* [http://www.if.pw.edu.pl/~lgraczyk/wiki/index.php/SK_Zadanie_5 Zajęcia 4]
* [http://www.if.pw.edu.pl/~lgraczyk/wiki/index.php/SK_Zadanie_3 Zajęcia 5]
* [http://www.if.pw.edu.pl/~lgraczyk/wiki/index.php/SK_Zadanie_6 Zajęcia 6]
* [http://www.if.pw.edu.pl/~lgraczyk/wiki/index.php/SK_Zadanie_7 Zajęcia 7]



Stara strona laboratorium:
http://www.if.pw.edu.pl/~lgraczyk/sk/html/ 
<code>'''Uwaga:''' Aby powyższa strona się poprawnie wyświetlała, należy ręcznie ustawić kodowanie ''Unicode'' w przeglądarce.</code>

KADD 2022 Laboratorium 12 EN

2022-05-30T11:51:27Z

Lgraczyk: Created page with "== Zadanie == '''Dopasowanie funkcji za pomocą paietu <code>MINUIT</code>''' (5 pkt.) Chcemy wykonać dopasowanie do danych doświadczalnych (wczytywanych z pliku) '''nie''' u..."

== Zadanie ==
'''Dopasowanie funkcji za pomocą paietu <code>MINUIT</code>''' (5 pkt.)

Chcemy wykonać dopasowanie do danych doświadczalnych (wczytywanych z pliku) '''nie''' używając funkci <code>Fit</code>, tylko za pomocą pakietu <code>MINUIT</code> ([https://root.cern.ch/root/html534/TMinuit.html dokumentacja]), który daje nam zdecydowanie większą kontrolę nad procesem dopasowania funkcji. Przede wszystkim pakiet <code>MINUIT</code> pozwala na zdefiniowanie przez nas minimalizowanej wielkości (może to być chi-kwadrat, funkcja wiarygodności, lub cokolwiek innego co wymyślimy), i na podstawie tej minimalizacji pakiet dostarcza nam finalne parametry dopasowania.

== Kroki postępowania ==

1. Ściągamy plik z danymi: [http://www.if.pw.edu.pl/~lgraczyk/KADD2020/lab12/example_data.root example_data.root] i wczytujemy go w funkcji głównej makra. 
Wczytywanie pliku:
TFile *ifile = new TFile("file.root");
TH1D *hist = (TH1D*)ifile->Get("hist");

2. Do naszych danych dopasujemy taką oto funkcję zdefiniowaną jako funkcja globalna (nasz model opisujący dane doświadczalne):
double model(double x, double *par)
{
double mu = par[3];
double sigma = par[4];
double norm = 1./sqrt(2.*TMath::Pi())/sigma;
double G = norm*exp(-0.5 *pow((x-mu)/sigma,2)); //unormowana funkcja Gaussa
double BinWidth = hist->GetBinWidth(1);
return par[0] + par[1]*x + par[2] * BinWidth * G;
}

3. W funkcji głównej makra tworzymy obiekt TMinuit, przykładowo:
TMinuit *gMinuit = new TMinuit(liczba_parametrow_fitu); //liczba parametrów wynika z definicji funkcji teoretycznej

4. Musimy stworzyć funkcję globalną (definiujemy ją przed funkcją główną), którą <code>MINUIT</code> będzie starał się zminimalizować manipulując naszymi parametrami. Musi ona mieć postać typu:
void fcn(int &npar, double *gin, double &f, double *par, int iflag)
'''Uwaga 1!''' Nie przerażamy się parametrami (to są automatyczne parametry, które muszą być i które potrzebuje <code>MINUIT</code>, my ich w ogóle nie użyjemy). 
'''Uwaga 2!''' Jedynym parametrem, który nas interesuje to <code>double &f</code> - to jest minimalizowana wielkość. W naszym przypadku chcemy, by <code>f</code> było po prostu tożsame z chi-kwadrat. To oznacza, że '''wewnątrz''' funkcji <code>fcn</code> musimy wykonać iterację bin po binie z wczytanego pliku i dla każdego binu policzyć kwadrat różnic ( (model-wartosc_binu)^2/niepwnosc_binu^2 ). Ostateczna wartość <code>f</code>, zgodnie z definicją chi-kwadrat, to po prostu suma kwadratów różnic dla wszystkich binów.

5. W funkcji głównej, mówimy naszemu obiektowi <code>gMinuit</code>, że ma skorzystać z funkcji FCN zdefiniowanej powyżej:
gMinuit->SetFCN(fcn);

6. Następnie ustawiamy parametry funkcji, np.:
gMinuit->DefineParameter(0, "p0", 100., 1., 0., 200.);

7. Główna część, gdzie dokonuje się zadania to wykonanie dwóch komend:
gMinuit->Command("MIGRAD");
gMinuit->Command("MINOS");
<code>MIGRAD</code> to algorytm szukający minimum funkcji <code>fcn</code> (czyli szuka najniższej wartości liczby <code>f</code>, którą definiujemy w określony przez nas sposób). 
<code>MINOS</code> to algorytm używany po zminimalizowaniu <code>fcn</code>, który pozwala na dokładną estymację niepwności (w tym asymetrycznych). 
'''Uwaga!''' Nie musimy znać szczegółów obu algorytmów. Dla zainteresowanych można poczytać [https://root.cern.ch/root/htmldoc/guides/minuit2/Minuit2Letter.pdf Minuit2Letter.pdf]

8. Za pomocą:
gMinuit->GetParameter(...)
wyciągamy otrzymane parametry dopasowania, tworzymy funkcję <code>TF1</code> z tymi parametrami i rysujemy wszystko na wykresie.

== Wynik ==
Przykłądowy histogram z dopasowaniem:
[[File:Minuit1.png]]

Ostateczny output:
<code>
FCN=93.6468 FROM MINOS STATUS=SUCCESSFUL 217 CALLS 364 TOTAL
EDM=3.79962e-17 STRATEGY= 1 ERROR MATRIX UNCERTAINTY 0.0 per cent
EXT PARAMETER PARABOLIC MINOS ERRORS
NO. NAME VALUE ERROR NEGATIVE POSITIVE
1 p0 1.12163e+02 2.00576e+00 -2.00605e+00 2.00576e+00
2 p1 -3.33062e+01 1.52150e+00 -1.52151e+00 1.52153e+00
3 area 2.02070e+03 5.83151e+01 -5.82593e+01 5.83721e+01
4 mean 1.00031e+00 1.70385e-03 -1.70425e-03 1.70425e-03
5 width 5.34156e-02 1.50983e-03 -1.49782e-03 1.52309e-03
Info in <TCanvas::MakeDefCanvas>: created default TCanvas with name c1

KADD 2022 Laboratorium 11 EN

2022-05-23T11:24:05Z

Lgraczyk:

== Zadanie ==
'''Least-squares method''' (5 pkt.)

Using the least-squares method, fit to the data polynomials of varying degrees <code>n=0..5</code>.

* Please read data from the following [http://www.if.pw.edu.pl/~lgraczyk/KADD2016/lab11/dane.dat file]. They come from the experiment of elastic collisions of negatively charged K mesons (kaons) with protons, at constant K meson energy. In the first column there are values of the cosine of the scattering angle in the rest mass reference frame, in the second column is the corresponding number of collisions. As errors please assume the square root of the number of observations. The degree of fitted polynomial allows to calculate the spin quantum numbers of intermediate stages ("Analiza danych", S.Brandt, Przykład 9.2.).

* Please implement the function realizing the least-squares method. Use formulas from the lecture (ich wyprowadzenie znajduje się w [http://www.if.pw.edu.pl/~lgraczyk/KADD2022/Wyklad11-2022.pdf Lecture 12] and from the unstruction [http://www.if.pw.edu.pl/~majanik/files/wiel.ps instrukcji]) - '''please carefully read the instruction - all the steps should follow the instruction''':

[[File:wzor1_new_asd.png]]

[[File:wzor2.png]]

[[File:wzor3.png]]

[[File:wzor4.png]]

[[File:wzor567.png]]

[[File:wzor89.png]]

''Comment'': we search from a minimum of M function (equivalent of chi-squared statistics), values <code>t_{j}</code> are the cosine scattering functions (first column from the file), values <code>y_{j}</code> are the observations numbers (second column). Estimators <code>x</code> are the searched parameters (coefficients) of the polynomial.

Example function definition:
// Function returns M
// parameters:
// st - degree of the polynomial
// n - number of measurements
// tj - array of cosine of scattering angles
// yj - measurement results
// sigmaj - measurement errors
// wsp - array in which we need to save estimated coefficients ([[File:wzor10.png]])
// bswp - array in which we need to save estimated coefficient errors (square roots of the diagonal elements of the matrix [[File:wzor11.png]])
double fit (int st, int n, double *tj, double *yj, double *sigmaj, double *wsp, double *bwsp);

To implement the formulas please use the class [http://www.slac.stanford.edu/comp/unix/package/cernroot/30106/TMatrixD.html TMatrixD]. Examples:

// utworzenie macierzy o wymiarach n x m
TMatrixD *macierzA = new TMatrixD(n,m);

// dostep do elementu o indeksach i,j macierzy macierzA, np.:
(*macierzA)(i,j) = 1;

// mnozenie macierzy: macierzA = macierzB macierzC
TMatrixD *macierzA = new TMatrixD(*macierzB, TMatrix::kMult, *macierzC);

// transponowanie macierzy
TMatrixD *macierzAt = new TMatrixD(TMatrix::kTransposed,*macierzA);

// odwracanie macierzy
macierz->Invert();

* Please interpret the resulting fitting by performing a chi-squared test (using the M functions). Please state which degree of the polynomial fits data best (what is the lowest degree of the polynomial, for which we do not reject the null hypothesis)

== Result ==

[[File:mnk_2.png]]

Output:

Dopasowanie wielomianem stopnia 0
M = 833.548
x0 = 57.8452 +- 2.4051
Liczba stopni swobody=9
Kwantyl=21.666
Poziom istotnosci=0.01
Stopien 0: odrzucamy

Dopasowanie wielomianem stopnia 1
M = 585.449
x0 = 82.6551 +- 2.87498
x1 = 99.0998 +- 6.29159
Liczba stopni swobody=8
Kwantyl=20.0902
Poziom istotnosci=0.01
Stopien 1: odrzucamy

Dopasowanie wielomianem stopnia 2
M = 36.4096
x0 = 47.267 +- 3.24753
x1 = 185.955 +- 7.30235
x2 = 273.612 +- 11.6771
Liczba stopni swobody=7
Kwantyl=18.4753
Poziom istotnosci=0.01
Stopien 2: odrzucamy

Dopasowanie wielomianem stopnia 3
M = 2.84989
x0 = 37.949 +- 3.62403
x1 = 126.546 +- 12.5894
x2 = 312.018 +- 13.4278
x3 = 137.585 +- 23.7499
Liczba stopni swobody=6
Kwantyl=16.8119
Poziom istotnosci=0.01
Stopien 3: akceptujemy

Dopasowanie wielomianem stopnia 4
M = 1.68602
x0 = 39.6179 +- 3.94036
x1 = 119.102 +- 14.3563
x2 = 276.49 +- 35.5643
x3 = 151.91 +- 27.2096
x4 = 52.5999 +- 48.7566
Liczba stopni swobody=5
Kwantyl=15.0863
Poziom istotnosci=0.01
Stopien 4: akceptujemy

Dopasowanie wielomianem stopnia 5
M = 1.66265
x0 = 39.8786 +- 4.29351
x1 = 121.384 +- 20.7054
x2 = 273.188 +- 41.6103
x3 = 136.571 +- 103.954
x4 = 56.8995 +- 56.2858
x5 = 16.7294 +- 109.424
Liczba stopni swobody=4
Kwantyl=13.2767
Poziom istotnosci=0.01
Stopien 5: akceptujemy

KADD 2022 Laboratorium 10 EN

2022-05-16T11:00:27Z

Lgraczyk: /* Attention */

== Exercise ==
'''Statistical hypotheses testing''' (5 pkt.)

* The experiment of irradiating a hydrogen bubble chamber with a beam of photons was carried out in order to study the interaction of photons with protons. Photons create electron-positron pairs that can be used to monitor the photon beam. The frequency of images with 0,1,2, ... electron-positron pairs should follow the Poisson distribution. Data should be read from the [http://www.if.pw.edu.pl/~lgraczyk/KADD2016/lab10/dane10.txt file] (the first column shows the number of electron pairs in the image <code>k</code>, and the second column shows the number of photos containing <code>k</code> electron pairs). We can see that this distribution resembles the Poisson distribution - therefore we are trying to calculate the maximum likelihood estimator for the parameters of the Poisson distribution (see [http://www.if.pw.edu.pl/~lgraczyk/KADD2022/Wyklad10-2022.pdf Lecture 10]) (1 pkt.)

* Narysować na jednym wykresie punkty pomiarowe i dopasowanie (metodą estymatora największej wiarygodności i funkcją Fit z ROOT'a użytą z parametrami "LR" - dopasowanie metodą największej wiarygodności). Funkcja TF1 do rysowania (i dopasowania ROOT'em) to TMath::PoissonI (1 pkt.)

* Check the quality of the fit with the χ2 test. For this purpose, a function for calculating the χ2 test statistic should be implemented according to the formul [[File:wzor.png]]
where: nk - number of observations in the kth bin, npk - the number of cases predicted by the theory in the kth bin, i.e .:

// h - data histogram
// g - "theoretical" prediction
double chi2(TH1D *h, TF1 *f);

* Determine the number of degrees of freedom and calculate the value of the test statistic. (1 pt)

* Implement a function that returns the result of the χ2 test at a given significance level α, i.e .:
// true - there is no reason to reject the hypothesis
// false - there are grounds for rejecting the hypothesis
// Parameters:
// T - value of the chi2 test statistic
// alpha - significance level
// ndf - the number of degrees of freedom of chi2 distribution
bool testChi2(double T, double alpha, int ndf);

Using the implemented function, verify the hypothesis that the measurement data are subject to the Poisson distribution. Select the appropriate value for the significance level. Warning! Kwanyl can be read from the distribution box counted in the last class. (2 pts)

== Attention ==
* Our task is to ''manually'' carry out the actions performed automatically by the <code> Fit </code> function.
* The problem consists of two parts: determining the parameter of the Poisson distribution ''by the maximum likelihood method'', looking for the ''estimator with the lowest variance''. So we read: Lecture 10 [http://www.if.pw.edu.pl/~lgraczyk/KADD2022/Wyklad10-2022.pdf link] - about the maximum likelihood method for Poissonian distribution
* The likelihood function is, in general, a probability distribution function for the ''parameters'' of the analyzed distribution, determined on the basis of a random sample (if, for example, we study the growth distribution of Poles f (x), where X is a random variable determining the height of Poles, e.g. Gaussian distribution with two parameters (mean, deviation), then L will be the likelihood function, probability distribution of the parameters of the mean and deviation -> we are looking for the maximum of the L function, which will give us the most reliable values of the parameters mean and deviation of the function f (x))
* Searching for parameters using the maximum likelihood method consists in solving the likelihood equations, which are nothing more than the conditions necessary for the existence of the maximum of the L function (according to the mathematical analysis - we calculate the appropriate derivatives)
* For the Poisson distribution, the estimator with the lowest variance obtained by the maximum likelihood method results from the solution of the likelihood equation (one equation, because one Lambda parameter) [http://www.if.pw.edu.pl/~lgraczyk/ KADD2022 / Wyklad10-2022.pdf link]
* The second part, after finding the estimator with the highest likelihood, is to perform a chi-square test. For this purpose, we read carefully Lecture 10
* There are two lines in the graph below (histogram) - blue and red. One is an auto-fit with <code> Fit </code>, the other is a manual procedure described above.
* For the Poisson distribution in the form of such "steps" we use the function <code> TMath :: PoissonI </code> ([https://root.cern.ch/root/html534/TMath.html#TMath:PoissonI link])
* The quantile of the chi-square distribution with the appropriate number of degrees of freedom to perform the test can be read from Exercise 9 (previous classes) - that is why we drew these chi-square distributions last time.

== Result ==

[[File:Lab10_2.png]]

Output:
FCN=5.75356 FROM MIGRAD STATUS=CONVERGED 29 CALLS 30 TOTAL
EDM=5.17016e-07 STRATEGY= 1 ERROR MATRIX ACCURATE
EXT PARAMETER STEP FIRST
NO. NAME VALUE ERROR SIZE DERIVATIVE
1 p0 3.55268e+02 1.88558e+01 3.25727e-02 3.68816e-05
2 p1 2.33737e+00 8.17264e-02 1.40382e-04 -2.26405e-03
ERR DEF= 0.5

Lambda of the highest likelihood: 2.33239
Lambda (ROOT Fit): 2.33737
chi2 (value of the test statistics T): 10.5336
chi2/NDF: 1.7556
chi2 (ROOT Fit): 9.85507
chi2 (ROOT Fit)/NDF: 1.40787
Significance level alpha: 0.01
Test result: no grounds to reject the null hypothesis

KADD 2022 Laboratorium 9 EN

2022-05-09T10:58:13Z

Lgraczyk:

== Exercise ==
''Part one'': '''Chi-squared distribution''' (3 pkt.)

Write a script which will draw the chi-squared probability distribution and it's cumulative distribution for number of degrees of freedom in the range: <code>n=1..20</code>.

''Part two'': '''Fitting of the Gaussian function''' (2 pkt.)

Write a script which will perform a convolution of n uniform distributions. The value of n compute as a minimal number of convolutions, for which the value of chi2/ndf, calculated from the fit of the Gaussian function is lower than 1.0 (we use the method <code>Fit</code> from the TF1 class).

== Attention ==
* We move to the '''second part''' of our class - until now we have considered only properties of the probability distributions. Now we will move to the methods of finding the parameters (estimation) of those distributions from the random sample (experiment).
* We read '''Lecture 9''' [http://www.if.pw.edu.pl/~lgraczyk/KADD2022/Wyklad9-2022.pdf link] - especially slides about the chi-squred distribution (22-27) - the best is to read the about the estimators.
* In the first part for chi-squared distribution we used the gamma function from (<code>TMath::Gamma</code>)
* In the second part we perform n convolutions of uniform distributions and the resulting histogram should be fitted with the Gaussian function - it should be a loop (i.e. <code>while</code> or <code>do-while</code>), which we break when the value of the test statistics chi-squared (X^2) divided by the number of degrees of freedom (NDF) is lower than 1. To calculate X^2 and NDF there are appropriate methods in the TF1 class

== Result ==
'''Chi-squared distribution'''

[[File:lab9_2.png]]

'''Fit of the Gaussian function'''

[[File:lab9_splot.png]]

Result (example):
number of convoluted distributions = 9
chi2/ndf = 55.724/59 = 0.944475

KADD 2022 Laboratorium 8

2022-04-20T11:20:23Z

Lgraczyk: /* Uwagi */

Jako zadanie należy zaimplementować funkcję wykonującą splot <code>n</code> zadanych rozkładów:
// f - tablica wskaznikow do obiektow TF1, rozklady skladowe
// k - wymiar tablicy f
// h - histogram do ktorego wrzucamy wynik splotu
// n - liczba losowan
void splot(TF1 **f, int k, TH1D *h, int n);

Zadane rozkłady reprezentowane są przez obiekty <code>TF1</code>. Wynik splotu reprezentowany jest przez obiekt <code>TH1D</code>.

Następnie należy:
* wykonać i narysować splot dwóch rozkładów jednorodnych U(0.0,2.0) i U(0.0,2.0), po czym dodać do splotu jeszcze trzeci rozkład jednorodny U(0.0,2.0) i splot wszystkich 3 rozkładów narysować (losujemy liczby z rozkładów wchodzących jako elementy splotu i dodajemy je do siebie, powtarzamy to wielokrotnie i wrzucamy do histogramu - wyjściowy histogram to splot rozkładów wejściowych),
* wykonać i narysować splot dwóch rozkładów normalnych N(1.0,0.2), N(3.0,0.5) oraz policzyć średnią i odchylenie standardowe powstałego rozkładu (należy wypisać średnie i odchylenia rozkładów wejściowych oraz splotu).

''Część druga'': '''tablica Galtona''' (2 pkt.)

Jako zadanie należy napisać skrypt symulujący deskę Galtona. Parametrami skryptu powinny być:
* <code>n</code> - liczba prób (kul)
* <code>l</code> - liczba rzędów
* <code>p</code> - prawdopodobieństwo ruchu kuli w prawo (sukcesu)

Dla zadanych wartości parametrów skryptu należy narysować histogram rozkładu kul otrzymany w wyniku symulacji oraz przewidywanie teoretyczne. Symulację wykonujemy dla 3 różnych zestawów parametrów dobranych w taki sposób aby otrzymać rozkład dwumianowy.

W ramach zadania należy:
* zaimplementować funkcję symulującą deskę Galtona np:

void deskaGaltona(TH1D * h, int n, int l, double p);
* dobrać parametry <code>n</code> i <code>p</code> w taki sposób aby otrzymać '''rozkład dwumianowy'''.

== Uwagi ==
* Czytamy dokładnie '''Wykład 7''' [http://www.if.pw.edu.pl/~lgraczyk/KADD2022/Wyklad7-2022.pdf link] o splotach - slajdy 14-26, slajd 13 o centralnym twierdzeniu granicznym (CTG) też warto zapamiętać
* Zgodnie ze slajdem 17, jeżeli mamy zmienną losową U=X+Y, gdzie X i Y to zmienne losowe opisane rozkładami f(x) oraz f(y), to rozkład f(u) zmiennej losowej U jest splotem rozkładów f(x) zmiennej X oraz f(y) zmiennej Y - zrobienie splotu przy losowaniu zmiennych losowych z rozkładów wejściowych (jak w tym zadaniu) to zatem nic innego jak dodawanie do siebe tych wartości i wynikiem jest histogram - rozkład takiej sumy, który jest splotem rozkładów wejściowych

== Wynik ==
''Część pierwsza'': '''sploty funkcji'''

[[File:sploty3.png]]

Output:
EX 1: 1
EX 2: 3
EX: 4.00079

VX 1: 0.04
VX 2: 0.25
VX: 0.314075

''Część druga'': '''tablica Galtona'''

[[File:galton.png]]

KADD 2022 Laboratorium 7 EN

2022-04-11T11:16:56Z

Lgraczyk: /* Attention */

{| align="right"
| __TOC__
|}

{| align="right"
| __TOC__
|}

== Exercise ==
''Part one'': '''estimation of the Pi''' (1 pkt.)

Please write a '''function''' which estimates the number Pi with the '''von Neumann''' (it is arguably one of the most simple examples of the use-case of a '''Monte Carlo''' method). In order to calculate the Pi, we randomly generate two numbers x and y from the uniform distribution [0,1] and we check whether the pair falls within the circle of the radius equal to 1. Next, by calculating the ratio of accepted pairs to all of them, you approximate the ratio of areas of the circle to the rectangle. By performing such a random generation, calculate the Pi number. In addition, draw the graph of the resulted points inside and outside the circle:
* create two objects of type <code>TGraph</code> and fill one of them with accepted pairs (x,y), the second one with rejected pairs. Both plots draw on one canvas,
* in addition, you can create a <code>TH1D</code> object and fill it with accepted values of x. It will be a distribution of the circle.

''Part two'': '''generation of pseudo random numbers from a any probability distribution using the acceptance rejection method of von Neumann''' (3 pkt.)

The transformation method used a week ago has limited applications. You can do this when the analytical form of the cumulative function and its inverse function are known. The von Neumann method of generation of pseudo random numbers will work when you know only
the g(y) distribution, but the drawback is that you have to generate two numbers, now one. This method will also work if the g(y) function is not a proper probability distribution (it even does not need to be normalized - every function you can always normalize). This allows for a very broad application of the von Neumann method - also to calculate definite integrals, when their analytical form does not exist. This is a typical example of a Monte Carlo method.

Please prepare thee '''very similar''' functions taking as argument an object of type <code>TF1</code>. The arguments should be the function g and the range [min,max]:
* <code>double generateVonNeumann(TF1 *g, double min, double max)</code> - function returning a generated pseudo random number from distribution g(y),
* <code>double efficiencyVonNeumann(TF1 *g, double min, double max, int n)</code> - function returning the efficiency of the von Neumann method for a given g(y) function and the number of generations n,
* <code>double integra;VonNeumann(TF1 *g, double min, double max, int n)</code> - function returning the definite integral (area under the curve) from function g(y) in the range [min,max] with the number of generations n.

''Part three:'' '''acceptance rejection method of von Neumann with the helper function''' (1 pkt.)

In order to improve the efficiency of the von Neumann function, we can limit the area of random points generation with the use of a helper function. In that case we can generate one number from the pair from the s(y) helper function, instead of a uniform distribution:
* <code>double integralVonNeumannWithHelper(TF1 *g, TF1 *s, double min, double max, int n, double &wydajnosc)</code> - returns the definite integral of the function g(y) in the range [min,max] for a given number of generations n. In addition, the function should take as an argument through a reference (because in C/C++ any function can return only one quantity).

The function s(y) we choose '''always''' in a way it is above the function g(y) and so that you can easily generate a random number from the s(y) distribution (i.e. by applying the transformation of the inverse cumulative distribution, like last time).

All calculations please fo for the following function:
[[File:Lab07_funkcja2.png]]

== Attention ==
* Read carefully '''Lecture 5''' [http://www.if.pw.edu.pl/~lgraczyk/KADD2022/Wyklad5-2022.pdf link] slides 9-17
* To generate numbers from the uniform distribution, use function <code>Uniform</code> from class <code>TRandom</code> OR the '''generator written last time'''
* Remember, always accept points below the curve to all generated points.
* '''As a helper function we will use a linear function.'''
* In the case of integration using a helper function, we always choose it in such a way that it is possible to generate the number from its distribution in an easy way (by inverting the cumulative distribution function) - in other words, we convert the rectangle (two uniform distributions) to another area inside which we draw (we must be able to draw numbers from this area)
* Quadratic function and its inverse function:

[[File:Odwracanie_kwadratowej.png]]
* [http://pl.wikipedia.org/wiki/Metoda_Monte_Carlo Metoda Monte Carlo] - Wikipedia.
* [http://www.if.pw.edu.pl/~lgraczyk/KADD2016/Wyklad5-2016.pdf Wykład 5]

== Results ==
''Part one''

[[File:lab07_kolo2.png]]

Output:
The Pi number equals: 3.14392

''Parts two and three''

[[File:Lab07_dist.png]]

Output:
Integral: 0.199
Efficiency: 0.2072
Integral (method with the helper function): 0.198745
Efficiency (method with the helper function): 0.39749
Integral calculated using the ROOT method Integral: 0.198652

KADD 2022 Laboratorium 6 EN

2022-04-04T11:26:55Z

Lgraczyk: /* Exercise */

{| align="right"
| __TOC__
|}

== Exercise ==

''Part one'': '''linear congruent generator of pseudorandom numbers''' (1 pkt.)

Please write a generator of pseudorandom numbers and save generated numbers into a file.

The generator should be based on the following formula:

<code>x[j+1] = (g*x[j] + c) mod m.</code>

This generator is called LCG - linear congruent generator. Providing the first (beginning) number <code>x[0]</code> defines the whole series, which is periodic. The period depends on the parameters and under certain conditions it reaches maximum value of <code>m</code>. These conditions are:

* <code>c</code> and <code>m</code> do not have joint divisors,
* <code>b = g-1</code> is a multiply of every prime number <code>p</code>, which is a divisor of a number <code>m</code>,
* <code>b</code> is a multiply of 4 if <code>n</code> is also a multiply of 4.

For simplicity we can uuse <code>c = 0</code>, and in that case we get a multiplicative generator (MLCG).

* Value of <code>g</code> and <code>m</code> should be easy to modify in the program.

The result of the macro execution should be a file with the name name.dat containing a series of generated numbers for a given set of parameters. The macro should be executed three times, resulting in three files: <code>random1.dat, random2.dat, random3.dat</code>, for the following parameters, respectively:

* <code>m=97</code> and <code>g=23</code>,
* <code>m=32363</code> and <code>g=157</code>,
* <code>m=147483647</code> and <code>g=16807</code>.

''Second part'': '''spectral test''' (1 pkt.)

Please perform a spectral test to see what is the quality of the generator. In order to do so please draw plot on the <code>(x[n], x[n+1])</code> points from generated numbers. The obtained graph will show a spectral pattern of the generator - hence the name of the test.

If the points are distributed uniformly, the test can be judged good. If they show a certain periodic pattern - the test doesn't work properly. Of course, for the position of the points what maters are the parameters <code>g</code> and <code>m</code>.

* In order to draw spectral test, please use <code>TH2D</code>.

As a result, we should have three spectral tests.

''Third part'': '''generation of pseudorandom numbers based on transformation of a uniform distribution''' (3 pkt.)

Each function of the random variable is also a random variable. What is the probability distribution of a random variable Y, if the probability distribution of X, <code>f(x)</code>, is known. We assume, that the probability <code>g(y)dy</code> is equal to <code>f(x)dx</code>, where <code>dx</code> equals <code>dy</code>. The condition is of course fulfilled for (infinitely) small <code>dx</code>. What results from this is the following:

<code>g(y) = dx/dy f(x)</code>

Now, if we assume that the probability density <code>f(x)</code> equals 1 in the range <code>0<=x<=1</code> and <code>f(x) = 0</code> for <code>x<= 0 and x>1</code>, then the above formula we can rewrite in the following form:

<code>g(y)dy = dx = dG(y),</code>

where <code>G(y)</code> is a cumulative distribution of the random variable <code>Y</code>. After integration this gives us:

<code>x = G(y) => y = G^-1(x).</code>

If the random variable <code>X</code> has a uniform distribution between 0 and 1 and we know the inverse function <code>G^-1(x)</code> then the function <code>g(y)</code> describes the probability distribution of the random variable Y.

By using this method please generate 10000 numbers from the distribution:

[[File:Lab06_wzor.png]]

For <code>tau = 2</code>:

* Generate 10000 numbers from the distribution from 0 to 1 using a generator from the first part ('''save in the file values of xn with a macro from the first file, in order to read them by a macro from the second part.''').
* Analytically (on the piece of paper)calculate the cumulative distribution of this formula, then you need to invert it. (1 pkt.)
* Generate a distribution <code>f(x)</code> - putting generated values into a histogram - korzystając z: (1 pkt.)
** numbers generated before and read from files<code>random1.dat, random2.dat, random3.dat</code>,
** standard generator implemented in ROOT, i..e <code>gRandom->Uniform(1)</code> (the object gRandom exists in the default instance of ROOT, you can also create it by using TRandom objects via a standard way by using a constructor - [https://root.cern.ch/root/html534/TRandom.html link]).
* Draw on a single plot the histogram (normalized) and the theoretical function <code>f(x)</code> (<code>TF1</code> object). (1 pkt.)

== Attention ==
* '''Read carefully the Lecture 4 ([http://www.if.pw.edu.pl/~lgraczyk/KADD2022/Wyklad4-2022.pdf link]), especially slids 6 and 8-25
* '''At the beginning, before random number generation, we need to set the first number from the series x0 (so called "seed"). If we want that every time the random numbers are different, we can set the seed from the system clock:'''
x0 = time(NULL);
* PArameters of the histograms shown below:
TH1D *hUniform = new TH1D("hUniform","Uniform distribution",100,0,1);
TH2D *hCorr = new TH2D("hCorr","Correlation",100,xmin,xmax,100,0,1);
* Number of random number generations:
const int N = 1000000;
* Example of reading from the text file:
ifstream ifile;
ifile.open("dane.dat");
double val;
while(ifile>>val)
{
cout<<val<<endl;
}
ifile.close();

* Example of writing to the text file:
ofstream ofile;
ofile.open("dane.dat");
for(int i=0;i<N;i++)
ofile<<val<<endl;
}
ofile.close();

== Results ==
Example distribution for parameters:
* <code>m=97, g=23</code>
[[File:lab06_n97_g23_2.png]]
* <code>m=2147483647, g=16807</code>
[[File:lab06_n2147483647_g16807_2.png]]

Example transformation of a uniform distribution:

[[File:lab06_b_2.png]]

KADD 2022 Laboratorium 5 EN

2022-03-28T10:48:13Z

Lgraczyk: /* Exercise */

{| align="right"
| __TOC__
|}

== Exercise ==
Measurements of three physical observables <code>X1, X2</code> oraz <code>X3</code> have been made. Results of the measurements are in the following files:
[http://www.if.pw.edu.pl/~lgraczyk/wiki/images/e/ed/Dane1.dat Dane1.dat], [http://www.if.pw.edu.pl/~lgraczyk/wiki/images/0/0d/Dane2.dat Dane2.dat] and [http://www.if.pw.edu.pl/~lgraczyk/wiki/images/b/ba/Dane3.dat Dane3.dat].

* Please calculate the result (mean and uncertainty - standard deviation) and draw the relation between the variables <code>(X1, X2)</code>, <code>(X2, X3)</code> and <code>(X1, X3)</code>. (1 pkt)

Variables <code>Y1, Y2</code> are related to <code>X1, X2, X3</code> via the following formulas:

<code> Y1 = 2 X1 + 5 X2 + X3

Y2 = 3 + 0.5 X1 + 4 X2</code>

Please calculate:
* covariance matrix X1, X2, X3 (1 pkt)
* mean values of Y1, Y2 in direct measurement (0.5 pkt)
* covariance matrix Y1, Y2 (1pkt)
* uncertainties of quantitites Y1, Y2 (1 pkt)
* correlation coefficients Y1 and Y2 (0.5 pkt)

== Attention ==
* Look carefully '''three first slides from lecture 5''' [http://www.if.pw.edu.pl/~lgraczyk/KADD2022/Wyklad5-2022.pdf link]
* Szczegółowy opis slajdy '''12-16 from lecture 4''' [http://www.if.pw.edu.pl/~lgraczyk/KADD2022/Wyklad4-2022.pdf link]
* Read data from file (the same as in C++):
ifstream ifile;
ifile.open("dane.dat");
double val;
while(ifile>>val)
{
cout<<val<<endl;
}
ifile.close();

* For all matrix operation (creating matrices of covariance, multiplication of matrices, transposing matrices) - use the class '''<code>TMatrixD</code>''' [https://root.cern.ch/root/html534/TMatrixT_double_.html link]
* '''Remember, that matrix operations require correct order of matrices.'''
* Uncertainty and correlation coefficient of X we obtain from TH2D histograms after reading the data; uncertainties and correlation coefficient of Y we obtain after calculating the matrix of coviarance of Y
* '''Limits of the histogram ranges in T2DH histograms in my solution are as follows:

double x1min = 1.5, x1max = 5.0;
double x2min = 0.0, x2max = 3.0;
double x3min = 4.0, x3max = 16.0;
TH2D *h12 = new TH2D("h12","Hist12",100,x1min,x1max,100,x2min,x2max);
TH2D *h13 = new TH2D("h13","Hist13",100,x1min,x1max,100,x3min,x3max);
TH2D *h23 = new TH2D("h13","Hist23",100,x2min,x2max,100,x3min,x3max);

* [http://pl.wikibooks.org/wiki/Statystyka_matematyczna/Momenty_statystyczne_w_dzia%C5%82aniu Wikibooks]

== Results ==
Plots:
[[File:Lab05_KADD2012.png]]

Output:
X1=3.00691, u(X1)=0.495242
X2=2.00581, u(X1)=0.40909
X3=9.97287, u(X3)=1.98102
rho(X1,X2)=0.156132
rho(X1,X3)=-0.00698853
rho(X2,X3)=0.00875851

after rounding to 2 significant digits:
X1=3.01, u(X1)=0.50
X2=2.01, u(X1)=0.41
X3=9.97, u(X3)=1.98

This is the matrix of covariance for X
3x3 matrix is as follows

| 0 | 1 | 2 |
--------------------------------------------
0 | 0.2453 0.0316 -0.006855
1 | 0.0316 0.1674 0.0071
2 | -0.006855 0.0071 3.924

This is the matrix of covariance for Y
2x2 matrix is as follows

| 0 | 1 |
-------------------------------
0 | 9.765 3.949
1 | 3.949 2.865

Y1=26.0157, u(Y1)=3.1249
Y2=12.5267, u(Y2)=1.6927404
rho(Y1,Y2)=0.746574
rho(Y2,Y1)=0.746574

after rounding to 2 significant digits:
Y1=26.02, u(Y1)=3.13
Y2=12.53, u(Y2)=1.70

KADD 2022 Laboratorium 4 EN

2022-03-21T12:23:39Z

Lgraczyk: Created page with "{| align="right" | __TOC__ |} == Exercise == The following probability density function is given: File:Lab04b_funkcja.png Please do: * calculate constant c in the way the p..."

{| align="right"
| __TOC__
|}

== Exercise ==
The following probability density function is given:
[[File:Lab04b_funkcja.png]]

Please do:
* calculate constant c in the way the probability distribution is normalized
* randomly select from the probability distribution a pair of numbers (x,y) and then fill with the a histogram of the probability distribution f(x,y) (0.5pkt)
* normalize the histogram of the probability distribution (0.5pkt)
* calculate and draw the histogram of the cumulative distribution F(x,y) (1pkt)
* calculate and draw the histograms of the marginal distributions g(x) i h(y) (1pkt)
* calculate:
** expected values: E(X), E(Y) (0.5pkt)
** standard deviations sigma(X), sigma(Y) (0.5pkt)
** covariance cov(X,Y) (0.5pkt)
** correlation coefficient rho(X,Y) (0.5pkt)

== Attention ==
* As minimum and maximum on x and y axed in all objects we set 0 and PI/2
* For work with histograms we used objects <code>TH1D</code> and <code>TH2D</code>. Some examples can be found in: [ftp://root.cern.ch/root/doc/3Histograms.pdf Histograms]
* The histogram of the probability density we create by random selection of pseudorandom numbers from the probability density functions (we create a TF2 object like previous lab and we implement a loop until a certain number, for each iteration we use '''GetRandom2''' to select those 2 numbers and then we use a function called '''Fill'' to fill the density histogram)
* Cumulative distribution is calculated '''numerically''' (two '''for''' loops, and we integrate the density iterating over x and y, by '''SetBinContent''' we set the specific valued of the histogram)
* Marginal distributions have their own methods for histograms ('''hint:''' they are called projections)
* For parameters (means, standard deviations, covariances, correlation factors) - there are specific methods

== Result ==

Plots:
[[File:lab04_KADD2016.png]]

Rotated distribution:
[[File:lab04b_KADD2016.png]]

Output:
E(X)=0.990827
E(Y)=0.990535
sigma(X)=0.377467
sigma(Y)=0.377583
cov(X,Y)=-0.0137694
rho(X,Y)=-0.09661

KADD 2022 Laboratorium 3 EN

2022-03-14T12:04:05Z

Lgraczyk: /* Wynik */

{| align="right"
| __TOC__
|}

== Task ==
We have a probability distribution function given with the following formula:

[[File:Wzor_Lab03_Kadd2012.png]]

For parameters '''m=1''' and '''n=2''' please:
* calculate c so that the distribution is normalized (1pkt)
* draw probability distribution function f(x,y) (1pkt)
* draw cumulative distribution F(x,y) (1pkt)
* draw marginal distribution g(x) (1pkt)
* draw marginal distribution h(y) (1pkt)

== Attention ==
* All quantities (constant c, cumulative distribution, marginal distributions) we calculate numerically, i.e. by using <code>Integral</code> method.
* The script has to be written in a way Skrypt powienien być napisany w taki sposób aby wykonywał obliczenia dla dowolnego m i n.
* Please name correctly all axes.
* The probability function (TF2 object) we create by using a proper constructor which includes a pointer to the function (appropriately defined for all values x and y):
double fcn(double *x, double *params)

TF2(const char* name, void* fcn, Double_t xmin = 0, Double_t xmax = 1, Double_t ymin = 0, Double_t ymax = 1, Int_t npar = 0)

Example:
double function(double *x, double *params)
{
if(x[0]>=0 && x[1]>=0)
return params[0]*x[0]*x[1];
return 0;
}
...
double xmin = 0;
double xmax = 10;
double ymin = 0;
double xmax = 10;
int nparams = 1;
TF2 * fun1 = new TF2("fun1",function,xmin,xmax,ymin,ymax,nparams);

== Results ==
Plots:
[[File:Zad03_KADD2012.png]]

Output:
Normalization factor c=6

KADD 2022 Laboratorium 2 EN

2022-03-07T12:13:29Z

Lgraczyk: /* Results */

{| align="right"
| __TOC__
|}

==Zadanie==

Let X be a random variable that has a probability distribution function f(x):
[[File:wzor_lab2.png]]

Please do:
* Draw the probability distribution function f(x) (0.5 pkt)
* Draw the cumulative distribution F(x). Cumulative distribution has to be drawn numerically and analytically. (1 pkt)
* Calculate the probability P(5 <= X <= 10) (0.5 pkt)
* Calculate the expected value E(X) and compare with the analytic result (1 pkt)
* Calculate the variance V(X) and compare with the analytic result(1 pkt)
* Calculate mode (0.5 pkt)
* Calculate quantiles: (0.5 pkt)
** lower quartile
** median
** upper quartile

==Results==
Plots:
[[File:lab2_3.png]]

Output:
P(5<X<10) from the density: 0.245723
P(5<X<10) from the cumulative distribution: 0.245723
Mean from the function TF1: 5.98798

Mean analytically: 6
Variance from TF1: 35.3988
Variance analytically: 36
Mode: 0
x0.25: 1.74
x0.5: 4.16
x0.75: 8.32

KADD 2022 Laboratorium 1 EN

2022-02-28T12:26:56Z

Lgraczyk: /* Wynik */

{| align="right"
| __TOC__
|}

== Documentation ==
Documentation of the ROOT environment:
* main page: [https://root.cern.ch/ https://root.cern.ch/]
* documentation of the development version (master): [https://root.cern.ch/doc/master/ https://root.cern.ch/doc/master/]
* documentation of the stable version (6.22): [https://root.cern/doc/v622/ https://root.cern/doc/v622/]
* documentation of the laboratory version (5.32.00): [https://root.cern.ch/root/html532/ https://root.cern.ch/root/html532/] last version with the old C++ interpreter

== Exercise ==
1. Write a macro, which:
* creates an object <code>fun1</code> of type <code>TF1</code> representing a <code>sin(x)</code> function (see class <code>TMath</code>)
* creates an object <code>fun2</code> of type <code>TF1</code> representing a <code>cos(x)</code> function
* creates a window with 4 panels (panel distribution 2x2) - see class <code>TCanvas</code> and method <code>Divide</code>
* draws the <code>fun1</code> object on panel 1, <code>fun2</code> on panel 2, and two functions simultaneously on panel 3
* changes the color of the line of function <code>fun2</code> to blue - see method <code>SetLineColor</code> and class <code>TColor</code>
 
2. Let's imagine we throw a dice that is asymmetric. The table below summarizes the results:
{| class="wikitable" border="1"
|-
! Number of pips
| 1
| 2
| 3
| 4
| 5
| 6
|-
! Number of throws
| 2
| 1
| 5
| 4
| 10
| 12
|}
We modify further the macro:
* let's create a histogram (see class <code>TH1D</code>) by filling each bin (which corresponds to each dice facet) with values from the table (number of throws) - the histogram should be plotted on panel 4
* create a plot, called graph (see class <code>TGraph</code>) according to values from the table.
* change the style of graph points (see method <code>SetMarkerStyle</code> and class <code>TAttMarker</code>)
* draw the graph in a separate window

== Attention ==
* Attention! In order to run ROOT environment on your student account in the laboratory, you have to add the following lines (if they were not added already) to the file <code>$HOME/.bashrc</code> (they could had been added during the PTI class):
export ROOTSYS=/opt/root
export PATH=$PATH:$ROOTSYS/bin
export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:$ROOTSYS/lib
* the ROOT environment is installed separately on each computer - it is not available on the server
* in the ROOT environment we write macros, which have extensions .c, .C, .cpp, or .cxx
* a macro contains a C++ code interpreted line-by-line
* in principle, we do not need to include any libraries
* example 1:
{
double x = 5;
cout<<x<<endl;
}
* execution of a macro: start the environment (command <code>root</code>), type <code>.x macro.C</code>
* macro can also contain funkcje, example 2:
int macro()
{
double x = 5;
cout<<x<<endl;
return 1;
}
* name of the macro must be the same as the name of the main function in the macro (in order to run it with the command <code>.x macro.C</code>)
* macros can contain more functions - during the macro execution the one which will be run is that which name corresponds to the macro name (the equivalent of the <code>main</code> function in standard C++)

== Results ==
Plots:
* window 1
[[File:lab1_1.png]]
* window 2
[[File:1_2.png]]

KADD 2021/2022

2022-02-28T12:25:19Z

Lgraczyk: /* Exercises (group Mondays, 2 PM - 4 PM) */

{| align="right"
| __TOC__
|}

== Informacje - wykład ==
Wykład z przedmiotu Komputerowa analiza danych doświadczalnych 
Prowadzący: 
dr inż. Łukasz Graczykowski 
e-mail: lukasz.graczykowski [at] pw.edu.pl 
konsultacje: MS Teams 
Na konsultacje proszę umawiać się przez MS Teams.

'''Zasady ustalania oceny końcowej''' 
Regulamin przedmiotu znajduje się [http://www.if.pw.edu.pl/~lgraczyk/KADD2021/Regulamin_KADD_2021_zdalne.pdf tutaj] (wersja 2021 - zaj. zdalne). 
Za każde z 11 punktowanych laboratoriów można otrzymać 0-5 pkt. 
Za każde z 2 kolokwiów na laboratorium można otrzymać 30 pkt. 
Za kolokwium na wykładzie można otrzymać 35 pkt. 
Końcowa liczba punktów: 150.

Poniższa tabelka przedstawia przedziały procentowe i odpowiadające im oceny:
{| class="wikitable" border="1"
|-
! Przedział procentowy
! Przedział punktowy
! Ocena
|-
| (50%; 60%>
| 75.5 - 90.0
| 3.0
|-
| (60%; 70%>
| 90.5 - 105.0
| 3.5
|-
| (70%; 80%>
| 105.5 - 120.0
| 4.0
|-
| (80%; 90%>
| 120.5 - 135.0
| 4.5
|-
| (90%; 100%>
| 135.5 - 150.0
| 5.0
|}

== Wykłady ==

MS Teams 
Wykłąd bieżący [http://www.if.pw.edu.pl/~lgraczyk/KADD2022/Wyklad11-2022.pdf link]. 
'''Wykład w dniu 29.03.202 jest odwołany. Będzie odrabiany w postaci dwóch godzin wykładu w dniu 6.05.'''

== Exercises (group Mondays, 2 PM - 4 PM) ==
Current results of my group are available here: [https://docs.google.com/spreadsheets/d/1gaG91EbVPYb-IAK27f3yQ5JXGN48IswLUiiMMZlMcBI/edit?usp=sharing link].

* [http://www.if.pw.edu.pl/~lgraczyk/wiki/index.php/KADD_2022_Laboratorium_1_EN Lab 1] (28.02.2022)
* [http://www.if.pw.edu.pl/~lgraczyk/wiki/index.php/KADD_2022_Laboratorium_2_EN Lab 2] (7.03.2022)
* [http://www.if.pw.edu.pl/~lgraczyk/wiki/index.php/KADD_2022_Laboratorium_3_EN Lab 3] (14.03.2022)
* [http://www.if.pw.edu.pl/~lgraczyk/wiki/index.php/KADD_2022_Laboratorium_4_EN Lab 4] (21.03.2022)
* [http://www.if.pw.edu.pl/~lgraczyk/wiki/index.php/KADD_2022_Laboratorium_5_EN Lab 5] (28.03.2022)
* [http://www.if.pw.edu.pl/~lgraczyk/wiki/index.php/KADD_2022_Laboratorium_6_EN Lab 6] (4.04.2022)
* [http://www.if.pw.edu.pl/~lgraczyk/wiki/index.php/KADD_2022_Laboratorium_7_EN Lab 7] (11.04.2022)
* [http://www.if.pw.edu.pl/~lgraczyk/wiki/index.php/KADD_2022_Laboratorium_8 Lab 8] (20.04.2022)
* [http://www.if.pw.edu.pl/~lgraczyk/wiki/index.php/KADD_2022_Laboratorium_9_EN Lab 9] (9.05.2022)
* [http://www.if.pw.edu.pl/~lgraczyk/wiki/index.php/KADD_2022_Laboratorium_10_EN Lab 10] (16.05.2022)
* [http://www.if.pw.edu.pl/~lgraczyk/wiki/index.php/KADD_2022_Laboratorium_11_EN Lab 11] (23.05.2022)
* [http://www.if.pw.edu.pl/~lgraczyk/wiki/index.php/KADD_2022_Laboratorium_12_EN Lab 12] (30.05.2022)
* [http://if.pw.edu.pl/~lgraczyk/KADD2022/kol2/dane_sw.txt Plik] z danymi na kolokwium 2
* [http://if.pw.edu.pl/~lgraczyk/KADD2022/kol2/dane_pw.txt Plik] z danymi na kolokwium popr. 2

Sieci komputerowe 2021/2022 lato

2022-02-22T18:07:51Z

Lgraczyk: /* Wykłady */

{| align="right"
| __TOC__
|}

== Informacje ==
Prowadzący przedmiot: 
dr inż. Łukasz Graczykowski 
e-mail: lukasz.graczykowski [at] pw.edu.pl 
konsultacje: umawiamy się indywidualnie (najlepiej pisząc mi wiadomość w MS Teams) 

== Wykłady ==
Pliki w zespole MS Teams.




== Regulamin ==
Pełna treść regulaminu (zajęcia stacjonarne) znajduje się [http://www.if.pw.edu.pl/~majanik/data/SK/RegulaminSieciKomputerowe.pdf tutaj].

'''Warunki zaliczenia'''
Maksymalna suma punktów do uzyskania to: '''100''' 
Składa się na nią:
* '''20 pkt''' - kolokwium na wykładzie
* '''30 pkt''' - projekty (2 projekty x 15 pkt)
* '''30 pkt''' - wejściówki na laboratorium (6 wejściówek x 5 pkt)
* '''14 pkt''' - obecność (7 zajęć x 2 pkt)
* '''6 pkt''' - praca na laboratorium (subiektywna ocena zaangażowania studenta przez prowadzącego)

Zaliczenie: '''>50 pkt''' 
<code>'''Uwaga:''' Aby przedmiot zaliczyć, należy również przekroczyć 50% punktów z kolokwium wykładowego (>10 pkt), projektów (traktowanych łącznie; >15 pkt) oraz wejściówek (>15 pkt). </code>

'''Oceny:'''
* <= 50 pkt - 2.0 (niezaliczone)
* 50.5 - 60 pkt - 3.0
* 60.5 - 70 pkt - 3.5
* 70.5 - 80 pkt - 4.0
* 80.5 - 90 pkt - 4.5
* >90 pkt - 5.0

== Laboratorium - Bieżące wyniki ==
Bieżące wyniki znajdują się na [https://docs.google.com/spreadsheets/d/1a-YikXtgCDpEK6nF8JhnniHl4XBzztRqM5aCT02uB8s/edit?usp=sharing tej] stronie.

== Zadania ==
Zadania na laboratorium - tryb stacjonarny:

* [http://www.if.pw.edu.pl/~lgraczyk/wiki/index.php/SK_Zadanie_1_remote Zajęcia 1],
* [http://www.if.pw.edu.pl/~lgraczyk/wiki/index.php/SK_Zadanie_2 Zajęcia 2]
* [http://www.if.pw.edu.pl/~lgraczyk/wiki/index.php/SK_Zadanie_4 Zajęcia 3]
* [http://www.if.pw.edu.pl/~lgraczyk/wiki/index.php/SK_Zadanie_5 Zajęcia 4]
* [http://www.if.pw.edu.pl/~lgraczyk/wiki/index.php/SK_Zadanie_3 Zajęcia 5]
* [http://www.if.pw.edu.pl/~lgraczyk/wiki/index.php/SK_Zadanie_6 Zajęcia 6]
* [http://www.if.pw.edu.pl/~lgraczyk/wiki/index.php/SK_Zadanie_7 Zajęcia 7]



Stara strona laboratorium:
http://www.if.pw.edu.pl/~lgraczyk/sk/html/ 
<code>'''Uwaga:''' Aby powyższa strona się poprawnie wyświetlała, należy ręcznie ustawić kodowanie ''Unicode'' w przeglądarce.</code>