"Verweilzeit" <-> Die potentielle Zeit die eine User auf einer Seite verbracht hat. Um diese messen zu können miüssen zwei Einträge in der DB vorhanden sein die eine gleiche User-ID und gleicher Session-ID haben

"messbar" <-> Ein UT-Eintrag ist nur dann komplett "messbar" bzw. auswertbar wenn ein zweiter (vorheriger) Eintrag in der DB vorhanden ist.

"gültigen Tracking-Einträge" <-> Die zugrundeliegende Seite des Tracking-Eintrags ist noch vorhanden


//STATS-EINSTELLUNGSOPTIONEN

        $UTanz: Anzahl der max auslesenden Tracking Daten
        $SessionMaxVerweildauer: Maximale Zeitdifferenz die zwischen zwei Seitenbesuchen innerhalb einer Session sein darf. Ansonsten 									wird die Session in zwei Sessions aufgesplittet.
        $IntervallMax: Obere Intervallgrenzen für die Klassen der Verweildauern;
        $IntervallSeitenMax: Obere Intervallgrenzen für die Klassen der Seitenzugriffe;       
        $RankBenoetigteZugriffe: benötigte Seitenzugriffe damit eine Seite ins Ranking kommt
        $RankAnzahl: Größe der Rankings, Anzahl der Klassen
        $LehrModulID: Ausgewählts Lernmodul
        $umlauteAendern: 1=ja, Umlaute werden bei der Ausgabe umschrieben
        $KapitelAbdeckungsKennzahlFaktor: Sinnvolle Faktoren für die Intervallgrenzen für Kapitelabdecklungsgrade. 
        				Sie werden mit $KapitelDurchZugriffe (je Ebene!) multipliziert um die Klassengrenzen zu bestimmen.


//ALLGEMEINE VARIABLEN

	//aus DB:lm_tree

    $vatizumkind[$row[0]]: Liefert die DB-ID des Elternelements zu einer Seite/einem Kapitel-DB-ID aus lm_tree
    $seitenTiefe[$row[0]]: Liefert die Baumebene der Seite/Kapitel aus lm_tree
   
	//aus DB:lm_data
	
    $Lehrmodulanz: Anzahl der Ilias-Lernmodule in DB:object_data
    $LehrmodulID[lm-id]= Liefert die DB-ID zur jeweiligen Lernmodul-Seite
    $rLehrmodulID[db-lm-id]= Liefert zur DB-ID eines Lernmoduls die Stats-ID (r=revers)
    $LehrmodulName[lm-id]= Name des Lernmoduls in DB:object_data;

    $Kapitelanz: Anzahl der Ilias-Kapitel in DB:lm_data
    $KapitelID[kapitel-id]= Liefert die DB-ID zum jeweiligen Stats-Kapitel
    $KapitelName[kapitel-id]= Name des Kapitel in DB:lm_data
    $KapitelLernModul[kapitel-id]= Liefert die Lernmodul-ID zum jeweiligen Kapitel
    $rKapitelID[db-kapitel-id]= Liefert zur DB-ID eines Kapitel die Stats-ID (r=revers)
    $Seitenanz: Anzahl der Ilias-Seiten in DB:lm_data
    $SeitenID[seiten-id]= Liefert die DB-ID zur jeweiligen Stats-Seite
    $SeitenName[seiten-id]= Name der Seite in DB:lm_data
    $SeitenLernModul[seiten-id]= Liefert die Lernmodul-ID zur jeweiligen Seite
	$rSeitenID[db-seiten-id]= Liefert zur DB-ID einer Seite die Stats-ID (r=revers)

//DATEN AUSLESEN AUS DB:ut_access

    $UserZugriffe[db-id]: Anzahl der gültigen Tracking-Einträge eines Users 
    $SeitenZugriffe[seiten-id]: Anzahl der gültigen Tracking-Einträge einer Seite
    $GesamtSeitenZugriffe: Gesamtanzahl der gültigen Einträge 
    $KapitelSeitenZugriffe[kapitel-id]: Anzahl der gültigen Einträge eines Kapitels

	//falls erster Seitenzugriff einer Session

    $Sessionanz: Anzahl aller Sessions
    $SessionCheck[user-id][user-session][0]: Anzahl der Zugriffe während einer jeder Session eines Users
    $SessionCheck[user-id][user-session][1]: Sessions-IDs eines Users
    $SessionZugriffe[session-id]: Anzahl aller messbaren Zugriffe während einer Session
    $SessionID[session-id]=Liefert die DB-ID zur jeweiligen Session
    $SessionUserID[session-id]=Liefert die User-ID zur jeweiligen Session;
    $SessionStartTime[session-id]=Startzeit der Session;
    $SessionQuellSeite[session-id]=Stats-Seiten-ID von der aus der Sessioneintrag gestartet wurde;

	//falls erneuter Seitenzugriff

    $SessionGesamtZugriffe: Alle Zugriffe, auch wenn nicht messbar
    $MessbareSessionZugriffe: Summe aller messbaren Einträgen in allen Sessions
    $SessionsVerweildauer[m-session-id]: Für jede messbare Session wird hier die Zeit zwischen den DB-Einträgen kumuliert
    $MessbareSessions: Anzahl aller messbaren Sessions
    $SessionZugriffe[session-id]:  Anzahl der messbaren Zugriffen für eine Session
    $UserSessionAnz[user-id]:  Anzahl Sessions für einen User
    $SeitenMessbareZugriffe[seiten-id]: Anzahl aller messbaren Zugriffe für eine Seite 
    $SessionGesamtDauerAll: Summe aller Verweilzeiten
    $SessionGesamtDauer[session-id]: Summe aller Verweilzeiten für eine Session
    $UserGesamtSessionsDauer[user-id]: Summe aller Verweilzeiten für einen User
    $UserSessionZugriffe[user-id]: Anzahl aller messbaren Zugriffe für einen User
    $SeiteGesamtVerweilZeit[seiten-id]: Summe aller Verweilzeiten für eine Seite
    $SessionVonNach[seiten-id][seiten-id]: Die Verweise aller Benutzer zwischen zwei Seiten werden hier abgespeichert


//STATISTIKEN

	//Verweildauer-Stats
	
    $SessionDurchschnittsDauer= $SessionGesamtDauerAll/$MessbareSessions;
    $SeitenVerweildauerDurchschnitt= $SessionGesamtDauerAll/$MessbareSessionZugriffe;
    $SeitenVerweildauerSpannweite= $SessionsVerweildauer[$MessbareSessionZugriffe-1]-$SessionsVerweildauer[0];
    $VerweildauerMedian= Mittlerer Wert der $SessionsVerweildauer
    $SeitenVerweildauerVarianz= Varianz von $SessionsVerweildauer;
    $SeitenVerweildauerStandartAbw= Wurzel von $SeitenVerweildauerVarianz;
    $SeitenVerweildauerVarKoef= $SeitenVerweildauerDurchschnitt/$SeitenVerweildauerStandartAbw;
    $SeitenGesamtVerweilMax/Min: Ranking SeiteGesamtVerweilZeit für Seiten=$SeiteGesamtVerweilZeit ->absteigend/fallend geordnet;
    $SeitenDurchschnittVerweilMax/Min: Ranking durchsch. Verweildauer für Seiten=$SeiteGesamtVerweilZeit[$i]/$SeitenMessbareZugriffe[$i] ->absteigend/fallend geordnet;

	//User-Stats

    $UserGesamtSessionsDauerMax/Min: Ranking Gesamte Sessiondauer der Einzelnen User = $UserGesamtSessionsDauer[$i]->absteigend/fallend geordnet;
    $UserSessionAnzMax/Min: Ranking Sessioanzahl der Einzelnen User = $UserSessionAnz[$i] ->absteigend/fallend geordnet;
    $UserAnz: Anzahl von Usern mit mind. einem Seitenbesuch
    $UserMessbarAnz: Anzahl von Usern mit mind. einer Verweilzeit

    //SEITENZUGRIFFSTATS
    
    $IntervallSeitenAnz: Anzahl an Seiten innerhalb eines Intervalls hinsichtlich der Seitenzugriffe;  
    $SeitenZugriffMax/Min: Ranking $SeitenZugriffe ->absteigend/fallend geordnet;
	$SeitenZugriffeMedian: Mittlerer Wert der $SeitenZugriffMax;
	$SeitenZugriffeSpannweite: $SeitenZugriffMax[0]-$SeitenZugriffMax[count($SeitenZugriffMax)-1];
	$ZugriffsWertMax: SeitenZugriffe Modus, also die jeweilige größte Anhäufung von Seitenzugriffe;
	$SeitenZugriffeVarianz: Varianz von $SeitenZugriffMax
    $SeitenZugriffeStandartAbw: Wurzel von $SeitenZugriffeVarianz;
    $SeitenZugriffeVarKoef: $SeitenZugriffeStandartAbw/($GesamtSeitenZugriffe/$Seitenanz);	
	
    //SESSIONSTATS
    
    $SessionGesamtDauerMax/Min: Ranking SessionGesamtDauer für Sessions=$SessionGesamtDauer ->absteigend/fallend geordnet;
    $SessionDurschnittsZeit: $GesamtSeitenZugriffe/$Sessionanz;     

    //EINZELSEITEN STATS
    
    $EinzelSeitenVarianz[$i]: Varianz von $SeitenVerweildauerListe[$i];
    $EinzelSeitenVarKoef[$i]=($SeiteGesamtVerweilZeit[$i]/$SeitenMessbareZugriffe[$i])/sqrt($EinzelSeitenVarianz[$i]);
    $EinzelSeitenVarMax/Min: Ranking $EinzelSeitenVarianz ->absteigend/fallend geordnet;
    $EinzelSeitenVarKoefMax/Min: Ranking $EinzelSeitenVarKoef ->absteigend/fallend geordnet;    

    //KAPITEL STATS:
    
    $KapitelZugriffe[]: Summe der $SeitenZugriffe aller Seiten des Kapitels;
    $KapitelGesamtVerweilZeit[]]:  Summe der $SeiteGesamtVerweilZeit aller Seiten des Kapitels;
    $KapitelMessbareZugriffe[]:  Summe der $SeitenMessbareZugriffe aller Seiten des Kapitels;
    $KapitelSeitenSumme[]: Anzahl von Seiten im Kapitel
    $KapitelGesamtSeitenAnzEbene: Anzahl von Seiten in der jeweiligen Kapitelebene
    $KapitelTiefe2Anzahl:  Anzahl von Kapiteln in der jeweiligen Kapitelebene
    $KapitelZugriffMax/Min: Ranking $KapitelZugriffe der jeweiligen Ebene ->absteigend/fallend geordnet;
    $KapitelGesamtVerweilMax/Min: Ranking $KapitelGesamtVerweilZeit der jeweiligen Ebene ->absteigend/fallend geordnet;
    $KapitelSeitenSummeMax: Ranking $KapitelSeitenSumme der jeweiligen Ebene ->absteigend/fallend geordnet;
    $KapitelDurchZugriffe: Summe von $KapitelZugriffMax geteilt durch $KapitelGesamtSeitenAnzEbene der jeweiligen Ebene;
    $KapitelAbgedeckteSeiten[]= Anzahl an Seiten eines Kapitels die größer als die benötigte $KapitelAbdeckungsKennzahl sind;
    
