strongcalc.cpp

#include "strongcalc.h"

STRONGcalc::STRONGcalc(OSM* o, KOO* s, KOO* e,char max, char min,
                       STRONGsetting* hs,Track*** trck, int* N, bool Hmonly){
    this->o = o;
    this->s = s;
    this->e = e;
    this->max = max;
    this->min = min;
    this->hs = hs;
    this->trck = trck;
    int hmmax;
    // determine the maximum vertical meters to calculate
    if(s != NULL && e != NULL){
        radius = distance(s->lat,s->lon,e->lat,e->lon)*hs->rfac+hs->rabs;
        hmmax = qMax(int(radius*hs->hmperkm),hs->hmmax);
    }
    else{
        if(s == NULL && e == NULL){
            radius = 1e10;
            hmmax = hs->hmmax;
        }
        else{
            radius = hs->rabs;
            hmmax = qMax(int(radius*hs->hmperkm),hs->hmmax);
        }
    }
    *N = this->N = hmmax / hs->hmstep + 1;
    if(Hmonly){
        if(hs->noSTRONGPlus)
            runmode = RMcalc;
        else
            runmode = RMcalcRestricted;
    }
    else
        if(hs->noSTRONGPlus)
            runmode = RMcalcClimb;
        else
            runmode = RMcalcClimbRestricted;
}
void STRONGcalc::exit(){}
void STRONGcalc::run(){
    switch(runmode){
    case RMcalc:
        init_Strong();
        calc<STRONGfib>(f);
        delete f;
        delete mind;
        delete mindSTRONG;
        break;
    case RMcalcClimb:
        o->points_Hm(o->get_first_KOO());
        init_Strong();
        calc<STRONGfib>(f);
        o->reset_Hm(o->get_first_KOO());
        delete f;
        delete mind;
        delete mindSTRONG;
        break;
    case RMcalcRestricted:
        init_StrongPlus();
        calc<STRONGPlusfib>(fplus);
        delete fplus;
        delete mind;
        delete mindSTRONG;
        break;
    case RMcalcClimbRestricted:
        init_StrongClimb();
        calc<STRONGClimbfib>(fclimb);
        delete fclimb;
        delete mind;
        delete mindSTRONG;
        break;
    case RMload:
        load_STRONG();
        break;
    case RMsave:
        save_STRONG();
        break;
    }
    emit finished(foundSTRONG);
}
template <class T> void STRONGcalc::calc(FibunacciHeap<T>**f){
    Neighbour* n;
    for(int i = 0; i < N; i++){/*Der Algorithmus arbeitet und wird Schritt i für Schritt i vom
        Interface aufgerufen */
        T* t; float d; STRONG* cS; int si = -1;

        do{ t = f[i]->extmin();
        }while(t != NULL && t->d < 0);

        while(t != NULL){
            /*der Fibunacci-Heap der Hoehe (i*stepsize) ist noch nicht
            abgearbeitet*/

            /*bevor KOO abgehandelt wird, Daten speichern, damit traceback()
            sinnvoll arbeiten kann,
            ausserdem den naechsten Neighbour festlegen*/
            cS = &(t->k->cd->s[i]);
            cS->via = t->via;
            cS->from = t->from;
            n = t->k->cd->neighbours;

            while(n != NULL){
                if( n->nb->cd->s != NULL
                    && n->way->type >= min && n->way->type <= max
                    && traceback(cS,n)){
                    /*Der Weg erfüllt die Anforderung an den Typ und hat die
                    Prioritaetswarteschlange noch nie durchlaufen, der Endpunkt
                    liegt außerdem im zu betrachtenden Routingbereich*/
                    si = index_STRONG(t,n);
                    if(si < N){
                        /*nur, wenn der Grenzwert noch nicht überschritten ist*/
                        if(    n->nb->cd->s[si].from == NULL
                            && n->nb->cd->s[si].via == NULL){
                            /*KOO wurde noch nie erreicht*/
                            store_STRONG(t,n,si,i);
                        }
                        else{
                            /*KOO wurde schon erreicht, pruefe: hat der Punkt die
                            Prioritaetswarteschlange schon wieder verlassen, falls
                            nicht: pruefe, ob Distanz jetzt kuerzer ist*/
                            if( n->nb->cd->s[si].via == NULL &&
                                ((T*)(n->nb->cd->s[si].from))->d > d + n->d){
                                /*alten Eintrag einschlaefern*/
                                ((T*)(n->nb->cd->s[si].from))->d = -1;
                                store_STRONG(t,n,si,i);
                            }
                        }
                    }
                }
                n = n->next;
            }

            /*Liste der schwersten laufenden STRONGs ggf. aktualualisiern*/
            if( i >= 0 && mind[i] > d ){
                mind[i] = d ;
                mindSTRONG[i] = cS;
            }

            /*naechstes Element der Prioritaetswarteliste*/
            do{
                delete t;
                t = f[i]->extmin();
                if(t!=NULL)
                    d = t->d;
                else
                    d= -1;
            }while(t != NULL && d < 0);
        }

        /*Ein der i.te FibunacciHeap ist abgearbeitet wurden. Das zwischenzeilich
        erreichte Paretooptimum soll in trck gespeichert werden*/
        STRONG_to_trck(i);

        emit refresh_progress(i);
        if(calcstopped)
            i = N;
    }
}
void STRONGcalc::init_Strong(){
    /*Arrays initialisieren*/
    calcstopped = 0;
    foundSTRONG = 0;
    f = new FibunacciHeap<STRONGfib>*[N];
    *trck = new Track*[N];
    mind = new double[N];
    mindSTRONG = new STRONG*[N];
    dummy = new Neighbour;
    dummy->brthr = dummy;
    dummy->d = dummy->hm = 0;
    for(int j = 0; j < N; j++){
        /*Arrays auf Startwert setzen*/
        (*trck)[j] = NULL;
        mind[j] = 100000000000000000.;
        mindSTRONG[j] = NULL;
        f[j] = new FibunacciHeap<STRONGfib>;
    }
    setSTRONG(o->get_first_KOO());
    if(s != NULL){
        /*soll mit festen Startpunkt routen.
        Der 0. FibunacciHeap wird nur mit dem Startknoten beladen.
        Das Gebiet wird begrenzt.*/
        STRONGfib* t = f[0]->ins(0);
        t->from = NULL;
        t->hm = 0.;
        t->k = s;
        t->via = dummy;
        s->cd->s[0].from = t;
        s->cd->s[0].via = dummy;
    }
    else{
        /*offener Start und offenes Ende.
        Der FibunacciHeap wird mit allen Kreuzungsknoten gleichzeitig
        gestartet.
        Das Gebiet wird nicht begrenzt.*/
        init_AreaStrong(o->get_first_KOO());
    }
}
void STRONGcalc::init_StrongPlus(){
    /*Arrays initialisieren*/
    calcstopped = 0;
    foundSTRONG = 0;
    fplus = new FibunacciHeap<STRONGPlusfib>*[N];
    *trck = new Track*[N];
    mind = new double[N];
    mindSTRONG = new STRONG*[N];
    dummy = new Neighbour;
    dummy->brthr = dummy;
    for(int j = 0; j < N; j++){
        /*Arrays auf Startwert setzen*/
        (*trck)[j] = NULL;
        mind[j] = 100000000000000000.;
        mindSTRONG[j] = NULL;
        fplus[j] = new FibunacciHeap<STRONGPlusfib>;
    }
    setSTRONG(o->get_first_KOO());
    if(s != NULL){
        /*soll mit festen Startpunkt routen.
        Der 0. FibunacciHeap wird nur mit dem Startknoten beladen.
        Das Gebiet wird begrenzt.*/
        STRONGPlusfib* t = fplus[0]->ins(0);
        t->from = NULL;
        t->hm = 0.;
        t->hmup = 0.;
        t->hmdown = 0.;
        t->k = s;
        t->via = dummy;
        s->cd->s[0].from = t;

        s->cd->s[0].via = dummy;
    }
    else{
        /*offener Start und offenes Ende.
        Der FibunacciHeap wird mit allen Kreuzungsknoten gleichzeitig
        gestartet.
        Das Gebiet wird nicht begrenzt.*/
        init_AreaStrongPlus(o->get_first_KOO());
    }
}
void STRONGcalc::init_StrongClimb(){
    /*Arrays initialisieren*/
    calcstopped = 0;
    foundSTRONG = 0;
    fclimb = new FibunacciHeap<STRONGClimbfib>*[N];
    *trck = new Track*[N];
    mind = new double[N];
    mindSTRONG = new STRONG*[N];
    dummy = new Neighbour;
    dummy->brthr = dummy;
    for(int j = 0; j < N; j++){
        /*Arrays auf Startwert setzen*/
        (*trck)[j] = NULL;
        mind[j] = 100000000000000000.;
        mindSTRONG[j] = NULL;
        fclimb[j] = new FibunacciHeap<STRONGClimbfib>;
    }
    setSTRONG(o->get_first_KOO());
    if(s != NULL){
        /*soll mit festen Startpunkt routen.
        Der 0. FibunacciHeap wird nur mit dem Startknoten beladen.
        Das Gebiet wird begrenzt.*/
        STRONGClimbfib* t = fclimb[0]->ins(0);
        t->from = NULL;
        t->hm = 0.;
        t->hmup = 0.;
        t->hmdown = 0.;
        t->Psum = 0;
        t->dP = 0;
        t->k = s;
        t->via = dummy;
        s->cd->s[0].from = t;

        s->cd->s[0].via = dummy;
    }
    else{
        /*offener Start und offenes Ende.
        Der FibunacciHeap wird mit allen Kreuzungsknoten gleichzeitig
        gestartet.
        Das Gebiet wird nicht begrenzt.*/
        init_AreaStrongClimb(o->get_first_KOO());
    }
}
void STRONGcalc::init_AreaStrong(KOO* k){
    if(k != NULL){
        if(k->cd != NULL){
            STRONGfib* t = (STRONGfib*) f[0]->ins(0);
            t->from = NULL;
            t->hm = 0;
            t->k = k;
            t->via = dummy;
            k->cd->s[0].via = dummy;
            k->cd->s[0].from = t;
        }
        init_AreaStrong(k->l);
        init_AreaStrong(k->r);
    }
}
void STRONGcalc::init_AreaStrongPlus(KOO* k){
    if(k != NULL){
        if(k->cd != NULL){
            STRONGPlusfib* t = (STRONGPlusfib*) fplus[0]->ins(0);
            t->from = NULL;
            t->hm = 0.;
            t->hmup = 0.;
            t->hmdown = 0.;
            t->k = k;
            t->via = dummy;
            k->cd->s[0].via = dummy;
            k->cd->s[0].from = t;
        }
        init_AreaStrongPlus(k->l);
        init_AreaStrongPlus(k->r);
    }
}
void STRONGcalc::init_AreaStrongClimb(KOO* k){
    if(k != NULL){
        if(k->cd != NULL){
            STRONGClimbfib* t = (STRONGClimbfib*) fclimb[0]->ins(0);
            t->from = NULL;
            t->hm = 0.;
            t->hmup = 0.;
            t->hmdown = 0.;
            t->dP = 0;
            t->Psum = 0;
            t->k = k;
            t->via = dummy;
            k->cd->s[0].via = dummy;
            k->cd->s[0].from = t;
        }
        init_AreaStrongClimb(k->l);
        init_AreaStrongClimb(k->r);
    }
}

void STRONGcalc::setSTRONG(KOO* k){
    if(k != NULL){
        if(k->cd != NULL){
            delete(k->cd->s);
            if( s == NULL || e == NULL ||
                distance(k->lat,k->lon,s->lat,s->lon)
               +distance(k->lat,k->lon,e->lat,e->lon) < radius){
                k->cd->s = new STRONG[N];
                for(int i = 0; i < N; i++){
                    k->cd->s[i].from = NULL;
                    k->cd->s[i].via = NULL;
                }
            }
            else
                k->cd->s = NULL;
        }
        setSTRONG(k->l);
        setSTRONG(k->r);
    }
}
void STRONGcalc::STRONG_to_trck(int i){
    /*Strecke rekonstruieren*/
    if(e != NULL){
        /*STRONG mit festgelegtem Ende*/
        if(e->cd->s[i].via != NULL){
            Neighbour** n;
            long nbc;
            extract_neighbourlist(NULL,&(e->cd->s[i]),&n,&nbc);
            if(nbc > 1) {
                (*trck)[i] = new Track(&(n[1]),nbc-1);
                foundSTRONG = 1;
            }
            delete n;
        }
    }
    else{
        /*STRONG mit offenem Ende*/
        if(mindSTRONG[i]!= NULL){
            Neighbour** n;
            long nbc;
            extract_neighbourlist(NULL,mindSTRONG[i],&n,&nbc);
            if(nbc > 1) {
                (*trck)[i] = new Track(&(n[1]),nbc-1);
                foundSTRONG = 1;
            }
            delete n;
        }
    }
}
short STRONGcalc::traceback(STRONG* s, Neighbour* n){
    if(s == NULL)
        return 1;
    else{
        STRONG *k = s;
        while((k->from != NULL) && (k->via != n) && (k->via != n->brthr))
            k = (STRONG*) k->from;
        if(k->from != NULL)
            return 0;
        else
            return 1;
    }
}
int STRONGcalc::index_STRONG(STRONGfib* t,Neighbour* n){
        return int((t->hm + n->hm)/hs->hmstep);
}
int STRONGcalc::index_STRONG(STRONGPlusfib* t,Neighbour* n){
    hm = t->hm;
    hmup = t->hmup;
    hmdown = t->hmdown;

    extract_STRONGPlus_restriciton(n);
    if(hmup > hs->dhmin)
        return int((hm + hmup)/hs->hmstep);
    else
        return int(hm/hs->hmstep);
}
int STRONGcalc::index_STRONG(STRONGClimbfib* t,Neighbour* n){
    hm = t->hm;
    hmup = t->hmup;
    hmdown = t->hmdown;
    Psum = t->Psum;
    dP = t->dP;
    extract_STRONGClimb_restriciton(n);
    if(dP > hs->minP)
        return int((Psum + dP)/hs->hmstep);
    else
        return int(Psum/hs->hmstep);
}

int STRONGcalc::extract_STRONGPlus_restriciton(Neighbour* n){
    /*addiert die Höhenmeter eines Weges zu den Gesamthöhenmetern, sofern die
    STRONGPlus_restriciton dabei erfüllt ist*/
    short result = 1;
    if(n->rd == fw){
        /*Lese die Höhendaten vorwaerts*/
        for(int i = 1; i < n->tpc; i++){
            if(n->tp[i].h > n->tp[i-1].h)
                hmup = hmup + n->tp[i].h - n->tp[i-1].h;
            else
                hmdown = hmdown + n->tp[i-1].h - n->tp[i].h;
            if(hmup > 0 && 1.*(hmdown)/(hmup) > hs->downtoupmax){
                /*die STRONGPlus_restricition "Anstiege muessen wesentlich mehr
                bergauf als bergab gehen" ist verletzt, der Anstieg endet an
                dieser Stelle*/
                result = 0;
                if(hmup > hs->dhmin)
                    /*aber die zweite restricition ist erfüllt, der Anstieg hat
                    die Mindesthöhendifferenz dhmin*/
                    hm = hm + hmup;

                hmup = 0.;              //Reset
                hmdown = 0.;            //Reset
            }
        }
    }
    else{
        /*Lese die Hoehendaten rueckwaerts*/
        for(int i = n->tpc-2; i >= 0; i--){
            if(n->tp[i].h > n->tp[i+1].h)
                hmup = hmup + n->tp[i].h - n->tp[i+1].h;
            else
                hmdown = hmdown + n->tp[i+1].h - n->tp[i].h;
            if(hmup > 0 && 1.*(hmdown)/(hmup) > hs->downtoupmax){
                /*die STRONGPlus_restricition "Anstiege muessen wesentlich mehr
                bergauf als bergab gehen" ist verletzt, der Anstieg endet an
                dieser Stelle*/
                result = 0;
                if(hmup > hs->dhmin)
                    /*aber die zweite restricition ist erfüllt, der Anstieg hat
                    die Mindesthöhendifferenz dhmin*/
                    hm = hm + hmup;

                hmup = 0.;              //Reset
                hmdown = 0.;            //Reset
            }
        }
    }
    return result;
}
int STRONGcalc::extract_STRONGClimb_restriciton(Neighbour* n){
    // refreshs Prec if neccessary
    short result = 1;
    float slope, dd;
    if(n->rd == fw){
        /*Lese die Höhendaten vorwaerts*/
        for(int i = 1; i < n->tpc; i++){
            if(n->tp[i].h > n->tp[i-1].h){
                hmup = hmup + n->tp[i].h - n->tp[i-1].h;
                dd = n->tp[i].d - n->tp[i-1].d;
                if(dd > 0){
                    slope = qMin(float(0.28),(n->tp[i].h - n->tp[i-1].h)/(dd*1000));
                    if(slope > 0.035)
                        dP += slope*slope*dd*1000;
                }
            }
            else
                hmdown = hmdown + n->tp[i-1].h - n->tp[i].h;
            if(hmup > 0 && 1.*(hmdown)/(hmup) > hs->downtoupmax){
                /*die STRONGPlus_restricition "Anstiege muessen wesentlich mehr
                bergauf als bergab gehen" ist verletzt, der Anstieg endet an
                dieser Stelle*/
                result = 0;
                if(hmup > hs->dhmin)
                    /*aber die zweite restricition ist erfüllt, der Anstieg hat
                    die Mindesthöhendifferenz dhmin*/
                    hm = hm + hmup;
                hmup = 0.;              //Reset
                hmdown = 0.;            //Reset
                if(dP > hs->minP)
                    Psum += dP;
                dP = 0.;

            }
        }
    }
    else{
        /*Lese die Hoehendaten rueckwaerts*/
        for(int i = n->tpc-2; i >= 0; i--){
            if(n->tp[i].h > n->tp[i+1].h){
                hmup = hmup + n->tp[i].h - n->tp[i+1].h;
                dd = n->tp[i+1].d - n->tp[i].d;
                if(dd > 0){
                    slope = qMin(float(0.28),(n->tp[i].h - n->tp[i+1].h)/(dd*1000));
                    if(slope > 0.035)
                        dP += slope*slope*dd*1000;
                }
            }
            else
                hmdown = hmdown + n->tp[i+1].h - n->tp[i].h;
            if(hmup > 0 && 1.*(hmdown)/(hmup) > hs->downtoupmax){
                /*die STRONGPlus_restricition "Anstiege muessen wesentlich mehr
                bergauf als bergab gehen" ist verletzt, der Anstieg endet an
                dieser Stelle*/
                result = 0;
                if(hmup > hs->dhmin)
                    /*aber die zweite restricition ist erfüllt, der Anstieg hat
                    die Mindesthöhendifferenz dhmin*/
                    hm = hm + hmup;

                hmup = 0.;              //Reset
                hmdown = 0.;            //Reset
                if(dP > hs->minP)
                    Psum += dP;
                dP = 0.;
            }
        }
    }
    return result;
}

void STRONGcalc::extract_neighbourlist(STRONG* s, STRONG* e,
                                    Neighbour ***nl,long int* nc){
    STRONG* st = e;
    int nct = 0;
    while(st != s){
        st = (STRONG*)st->from;
        nct++;
    }
    *nl = new Neighbour*[nct];
    *nc = nct;
    st = e;
    while(st != s){
        nct--;
        (*nl)[nct] = st->via;
        st = (STRONG*)st->from;
    }
}
void STRONGcalc::store_STRONG(STRONGfib* t, Neighbour* n, int si, int i){
   /*als STRONG speichern*/
   STRONGfib* t2 = f[si]->ins(t->d + n->d);
   t2->k = n->nb;
   t2->from = &(t->k->cd->s[i]);
   t2->via = n;
   t2->hm = t->hm + n->hm;
   n->nb->cd->s[si].from = t2;

}
void STRONGcalc::store_STRONG(STRONGPlusfib* t, Neighbour* n, int si, int i){
   /*als STRONGplus speichern*/
   STRONGPlusfib* t2 = fplus[si]->ins(t->d + n->d);
   t2->k = n->nb;
   t2->from = &(t->k->cd->s[i]);
   t2->via = n;
   t2->hm = hm;
   t2->hmup = hmup;
   t2->hmdown = hmdown;
   n->nb->cd->s[si].from = t2;
}
void STRONGcalc::store_STRONG(STRONGClimbfib* t, Neighbour* n, int si, int i){
   /*als STRONGclimb speichern*/
   STRONGClimbfib* t2 = fclimb[si]->ins(t->d + n->d);
   t2->k = n->nb;
   t2->from = &(t->k->cd->s[i]);
   t2->via = n;
   t2->hm = hm;
   t2->hmup = hmup;
   t2->hmdown = hmdown;
   t2->Psum = Psum;
   t2->dP = dP;
   n->nb->cd->s[si].from = t2;
}


void STRONGcalc::stop_calculations(){
    calcstopped = 1;
}
STRONGcalc::STRONGcalc(OSM* o, int N, char* filename,Track***results){
    // saves STRONG calculation
    this->o = o;
    strcpy(this->filename,filename);
    runmode = RMsave;
    this->N = N;
    this->trck = results;
}
void STRONGcalc::save_crossdata(KOO *k, FILE* f){
    if(k != NULL){
        if(k->cd != NULL && k->cd->s != NULL){
            fwrite(&(k->id),sizeof(qint64),1,f);
            for(int i = 0; i < N; i++)
                if(k->cd->s[i].from != NULL){
                    fwrite(&(k->cd->s[i].via->brthr->nb->id),sizeof(qint64),1,f);
                    fwrite(&(k->cd->s[i].via->way->id),sizeof(qint64),1,f);
                    int sindex = (STRONG*)k->cd->s[i].from
                               - &(k->cd->s[i].via->brthr->nb->cd->s[0]);
                    fwrite(&(sindex),sizeof(int),1,f);
                }
                else{
                    qint64 buf64 = -1;
                    int bufint = -1;
                    fwrite(&(buf64),sizeof(qint64),1,f);
                    fwrite(&(buf64),sizeof(qint64),1,f);
                    fwrite(&(bufint),sizeof(int),1,f);
                }
        }
        save_crossdata(k->l,f);
        save_crossdata(k->r,f);
    }
}
void STRONGcalc::load_crossdata(FILE* f){
    qint64 kid,wid;
    int sindex;
    fread(&(kid),sizeof(qint64),1,f);
    KOO* k = o->search(kid,o->get_first_KOO());
    if(k != NULL && k->cd != NULL){
        counter++;
        for(int i = 0; i < N; i++){
            fread(&(kid),sizeof(qint64),1,f);
            fread(&(wid),sizeof(qint64),1,f);
            fread(&(sindex),sizeof(int),1,f);

            Neighbour* nb = k->cd->neighbours;
            while(nb != NULL && (nb->nb->id != kid || nb->way->id != wid))
                nb = nb->next;
            if(nb != NULL){
                k->cd->s[i].via = nb->brthr;
                k->cd->s[i].from = &(nb->nb->cd->s[sindex]);
            }
            else{
                k->cd->s[i].via = dummy;
                k->cd->s[i].from = NULL;
            }
        }
    }
    else
        fseek(f,N*(2*sizeof(qint64)+sizeof(int)),SEEK_CUR);
}

STRONGcalc::STRONGcalc(OSM* o, int*N, char* filename,Track*** results){
    // loads STRONG calculation
    this->o = o;
    strcpy(this->filename,filename);
    runmode = RMload;
    Nout = N;
    this->trck = results;
}
void STRONGcalc::load_STRONG(){
    // loads STRONG calculation
    qint64 kid;
    FILE* f = fopen(filename,"rb");
    if(f != NULL){
        fread(Nout,sizeof(int),1,f);
        N = *Nout;
        s = e = NULL;
        STRONGsetting hst;
        hs = &hst;
        init_Strong();
        counter = 0;
        int crosscount;
        fread(&(crosscount),sizeof(int),1,f);
        for(int i = 0; i < crosscount; i++)
            load_crossdata(f);
        *trck = new Track*[N];
        for(int i = 0; i < N; i++){
            fread(&(kid),sizeof(qint64),1,f);
            KOO* k = o->search(kid,o->get_first_KOO());
            if(k != NULL && k->cd != NULL){
                e = k;
                STRONG_to_trck(i);
            }
            else
                (*trck)[i] = NULL;
        }
        fclose(f);
        delete this->f;
        delete mind;
        delete mindSTRONG;
        foundSTRONG = 1;
    }
    else
        foundSTRONG = 0;
}
void STRONGcalc::save_STRONG(){
    FILE* f = fopen(filename,"wb");
    if(f != NULL){
        this->N = N;
        fwrite(&(N),sizeof(int),1,f);
        int crosscount = o->count_STRONG(o->get_first_KOO());
        fwrite(&(crosscount),sizeof(int),1,f);
        save_crossdata(o->get_first_KOO(),f);
        for(int i = 0; i < N; i++)
            if((*trck)[i] != NULL)
                fwrite(&((*trck)[i]->get_last_KOO()->id),sizeof(qint64),1,f);
            else{
                qint64 buf64 = -1;
                fwrite(&(buf64),sizeof(qint64),1,f);
            }
        foundSTRONG = 1;
        fclose(f);
    }
    else
        foundSTRONG = 0;

}