poweranalysis.cpp

#include "poweranalysis.h"
#include <QApplication>
PowerAnalysis::~PowerAnalysis(){
    for(int i = 0; i < 9; i++)
        if(d[i] != NULL)
            delete d[i];
}

PowerAnalysis::PowerAnalysis(){
    for(int i = 0; i < 9; i++)
        d[i] = NULL;
}
PowerAnalysis::PowerAnalysis(PowerAnalysisSetting* s){
    setWindowTitle("Power Analysis");
    this->s = s;
    init();
    ip[0 ] = new Inputs("mass [kg]"          ,0  ,200 ,&(s->m));
    ip[1 ] = new Inputs("cr"                 ,0  ,1.  ,&(s->cr));
    ip[2 ] = new Inputs("temperatur [°C]"    ,-40,50  ,&(s->T));
    ip[3 ] = new Inputs("air pressure [hPa]" ,900,1100,&(s->p0));
    ip[4 ] = new Inputs("wind strength [bft]",0  ,12  ,&(s->ws));
    ip[5 ] = new Inputs("wind direction [°]" ,0  ,360 ,&(s->wd));
    ip[6 ] = new Inputs("Pmax [W]"           ,0  ,500 ,&(s->Pmax));
    ip[7 ] = new Inputs("Pvd [km/h]"         ,0  ,50  ,&(s->Pvd));
    ip[8 ] = new Inputs("PT [km/h]"          ,0  ,10  ,&(s->PT));
    ip[9 ] = new Inputs("cwAmax"             ,0.2,0.7 ,&(s->cwAmax));
    ip[10] = new Inputs("cwAmin"             ,0.0,0.7 ,&(s->cwAmin));
    ip[11] = new Inputs("cwAvd [km/h]"       ,0  ,50  ,&(s->cwAvd));
    ip[12] = new Inputs("cwAT [km/h]"        ,0  ,30  ,&(s->cwAT));
    ip[13] = new Inputs("a break  [m/s²]"    ,0  ,10  ,&(s->abrake));
    ip[14] = new Inputs("a radial [m/s²]"    ,0  ,10  ,&(s->aradial));

    QGridLayout* L = new QGridLayout();
    L->setContentsMargins(10,0,10,0);
    L->addWidget(ip[0],0,0);
    L->addWidget(ip[1],1,0);
    L->addWidget(ip[2],2,0);
    L->addWidget(ip[3],3,0);
    L->addWidget(&Pt,0,1,4,2);

    fwcb.setText("fight wind");
    connect(&fwcb,SIGNAL(clicked()),this,SLOT(toggle_fightwind()));
    L->addWidget(&fwcb,4,0);
    L->addWidget(ip[4],5,0);
    L->addWidget(ip[5],6,0);
    wl = new WindLabel(&(s->ws),&(s->wd));
    L->addWidget(wl,4,1,3,1);
    textbox.setSizePolicy(QSizePolicy::Minimum,QSizePolicy::Minimum);
    L->addWidget(&textbox,4,2,3,1);

    L->addWidget(ip[6],7,0);
    L->addWidget(ip[7],8,0);
    L->addWidget(ip[8],9,0);
    Pvl.setText("Power setting");
    Pvl.show();
    L->addWidget(&Pvl,10,0);
    L->addWidget(&Pv,7,1,4,2);

    L->addWidget(ip[9 ],11,0);
    L->addWidget(ip[10],12,0);
    L->addWidget(ip[11],13,0);
    L->addWidget(ip[12],14,0);
    cwAvl.setText("cwA setting");
    L->addWidget(&cwAvl,15,0);
    L->addWidget(&cwAv,11,1,5,2);

    L->addWidget(ip[13],16,0);
    L->addWidget(ip[14],17,0);
    bdefault.setText("Default");
    brecalc.setText("Recalc");
    btoggletimestamp.setText("Ignore/Subordinate time stamp");
    L->addWidget(&bdefault,18,0);
    L->addWidget(&brecalc,18,1);
    L->addWidget(&btoggletimestamp,18,2);
    setLayout(L);
    connect(&bdefault,SIGNAL(clicked()),this,SLOT(set_default_refresh()));
    connect(&brecalc,SIGNAL(clicked()),this,SLOT(recalc()));
    connect(&btoggletimestamp,SIGNAL(clicked()),this,SLOT(toggle_timestamp()));
    connect(ip[6],SIGNAL(changed()),this,SLOT(draw_Pv()));
    connect(ip[7],SIGNAL(changed()),this,SLOT(draw_Pv()));
    connect(ip[8],SIGNAL(changed()),this,SLOT(draw_Pv()));
    connect(&Pv,SIGNAL(mousex(double)),this,SLOT(update_Pvl(double)));
    connect(&cwAv,SIGNAL(mousex(double)),this,SLOT(update_cwAl(double)));
    connect(ip[9 ],SIGNAL(changed()),this,SLOT(draw_cwAv()));
    connect(ip[10],SIGNAL(changed()),this,SLOT(draw_cwAv()));
    connect(ip[11],SIGNAL(changed()),this,SLOT(draw_cwAv()));
    connect(ip[12],SIGNAL(changed()),this,SLOT(draw_cwAv()));
    connect(ip[4],SIGNAL(changed()),wl,SLOT(refresh()));
    connect(ip[5],SIGNAL(changed()),wl,SLOT(refresh()));
    connect(ip[4],SIGNAL(changed()),this,SLOT(bft_to_mpros()));
    connect(wl,SIGNAL(clicked()),ip[4],SLOT(refresh()));
    connect(wl,SIGNAL(clicked()),ip[5],SLOT(refresh()));
    connect(wl,SIGNAL(clicked()),this,SLOT(bft_to_mpros()));
    for(int i = 0; i < 15; i++)
        connect(ip[i],SIGNAL(changed()),this,SLOT(show_slopespeed_table()));

    setSizePolicy(QSizePolicy::Minimum,QSizePolicy::Minimum);
    BTP3setups(&pfs).init();
    pfs.singlecolor = true;
    pfs.fillcolor = QColor(255,0,0,140).rgba();
    pfs.showreduceddata = false;
    Pv.settings(&pfs);
    Pt.settings(&pfs);
    cwAv.settings(&pfs);
    draw_Pv();
    draw_cwAv();
}
void PowerAnalysis::init(){
    bft_to_mpros();
    plotdata[0] = new double[100];
    plotdata[1] = new double[100];
    for(int i = 0; i < 100; i++)
        plotdata[0][i] = 60./100.*i;
    count = 0;
    for(int i = 0; i < 9; i++)
        d[i] = NULL;
}
void PowerAnalysis::set_default(PowerAnalysisSetting *PA){
    PA->abrake   = 2;
    PA->aradial  = 5;
    PA->cr       = 0.006;
    PA->cwAmax   = 0.45;
    PA->cwAmin   = 0.25;
    PA->cwAT     = 10;
    PA->cwAvd    = 23/3.6;
    PA->fightwind= 0;
    PA->m        = 85;
    PA->p0       = 1013.25;
    PA->Pmax     = 320;
    PA->PT       = 1.94;
    PA->Pvd      = 30.0;
    PA->T        = 20;
    PA->wd       = 15;
    PA->ws       = 3;
}
Inputs::Inputs(QString labeltext,double min, double max, double* v){
    this->v = v;
    slider = new QSlider(Qt::Horizontal);
    label = new QLabel(labeltext);
    edit = new QLineEdit(QString("%1").arg(*v));
    smin = min;
    smax = max;
    slider->setMinimum(0);
    slider->setMaximum(1000);
    if(*v >= min && *v <= max){
        slider->setValue((*v-min)/(max-min));
    }
    slider->setValue(500);
    QBoxLayout* L = new QBoxLayout(QBoxLayout::LeftToRight);
    L->setContentsMargins(0,0,0,0);
    L->addWidget(label,2);
    L->addWidget(slider,2);
    L->addWidget(edit,1);
    setLayout(L);
    connect(slider,SIGNAL(sliderReleased()),this,SLOT(slidertoedit()));
    connect(edit,SIGNAL(textEdited(QString)),this,SLOT(checkedit(QString)));
    connect(slider,SIGNAL(valueChanged(int)),this,SLOT(sliderpreview(int)));
    connect(slider,SIGNAL(actionTriggered(int)),this,SLOT(slidertoedit()));
    }
void Inputs::slidertoedit(){
    edit->setText(QString("%1").arg(smin+1.*slider->value()/1000.*(smax-smin)));
    *v = edit->text().toDouble();
    emit changed();
}
void Inputs::sliderpreview(int i){
    edit->setText(QString("%1").arg(smin+1.*i/1000.*(smax-smin)));
}
void Inputs::checkedit(QString newedit){
    bool OK;
    double buf = newedit.toDouble(&OK);
    if(OK && buf > 0){
        *v = buf;
        emit changed();
    }
    else
        edit->setText("type number > 0");
}
void Inputs::refresh(){
    edit->setText(QString("%1").arg(*v));
}
WindLabel::WindLabel(double *ws, double *wd){
    setSizePolicy(QSizePolicy::Expanding,QSizePolicy::Minimum);
    this->wd = wd;
    this->ws = ws;
}
void WindLabel::set_para(double *ws, double *wd){
    this->wd = wd;
    this->ws = ws;
    update();
}
void WindLabel::paintEvent(QPaintEvent *){
    QPainter p(this);
    p.drawPixmap(0,0,pm);
}
void WindLabel::resizeEvent(QResizeEvent *){
    refresh_pixmap();
}
void WindLabel::mouseReleaseEvent(QMouseEvent *event){
    float r = qMin(width(),height())/2.-2;
    QPointF mouse = event->pos();
    QPointF center(width()/2,height()/2);
    QPointF d = mouse-center;
    *ws = sqrt(d.x()*d.x()+d.y()*d.y())/r*6;
    if(*ws > 0)
        *wd = atan2(d.x(),-d.y())/3.1415*180;
    else
        *wd = 0;
    if(*wd < 0) *wd += 360;
    emit clicked();
    refresh();
}
void WindLabel::refresh(){
    refresh_pixmap();
    update();
}
void WindLabel::refresh_pixmap(){
    pm = QPixmap(size());
    pm.fill(QPalette().color(QPalette::Window));
    QPainter p(&pm);
    p.setRenderHint(QPainter::Antialiasing);
    p.setPen(QPen(Qt::black,2));
    float r = qMin(width(),height())/2.-2;
    QPointF center(width()/2,height()/2);
    p.drawEllipse(center,r,r);
    p.drawEllipse(center,r/2,r/2);
    p.drawEllipse(center,r/4,r/4);
    QPointF tri[3];
    float l = *ws/6.*r;
    tri[0] = center + QPointF(l/1.*sin(*wd/180*3.1415),
                             -l/1.*cos(*wd/180*3.1415));
    tri[1] = center + QPointF(l/3.*sin((*wd+150)/180*3.1415),
                             -l/3.*cos((*wd+150)/180*3.1415));
    tri[2] = center + QPointF(l/3.*sin((*wd+210)/180*3.1415),
                             -l/3.*cos((*wd+210)/180*3.1415));
    p.setBrush(QBrush(Qt::red));
    p.drawPolygon(tri,3);
}
void PowerAnalysis::draw_Pv(){
    for(int i = 0; i < 100;i++){
        plotdata[0][i] = 1*i/1.5;
        plotdata[1][i] = P(plotdata[0][i]/3.6);
    }
    Pv.set_data(plotdata,100);
}
void PowerAnalysis::draw_cwAv(){
    for(int i = 0; i < 100;i++){
        plotdata[0][i] = 1*i/1.5;
        plotdata[1][i] = cwA(plotdata[0][i]/3.6);
    }
    cwAv.set_data(plotdata,100);
}
void PowerAnalysis::set_default_refresh(){
    set_default(s);
    for(int i = 0; i < 15; i++)
        ip[i]->refresh();
    draw_Pv();
    draw_cwAv();
    wl->refresh();
}
void PowerAnalysis::update_Pvl(double v){
    Pvl.setText(QString("%1 km/h:  P=%2 W").arg(v,0,'f',1)
                .arg(P(v),0,'f',1));
}
void PowerAnalysis::update_cwAl(double v){
    cwAvl.setText(QString("%1 km/h:  cwA=%2").arg(v,0,'f',1)
                .arg(cwA(v),0,'f',3));
}
void PowerAnalysis::show_slopespeed_table(){
    QString t;
    for(double s  = 0; s < 0.16; s += 0.01)
        t.append(QString("%1 % %2 km/h    %3 % %4 km/h\n")
                 .arg(s*100.,2,'f',0)
                 .arg(vmax( s,0)*3.6,5,'f',1)
                 .arg(s*-100.,3,'f',0)
                 .arg(vmax(-s,0)*3.6,5,'f',1));
    textbox.setPlainText(t);
}
double PowerAnalysis::vmax(double slope, double direction){
    double rho0 = rho(0);
    double vl = 0, vm = 10, vr = 50;
    double Pl = P(vl,slope,direction,rho0)-P(vl);
    double Pm = P(vm,slope,direction,rho0)-P(vm);
    double Pr = P(vr,slope,direction,rho0)-P(vr);
    while(Pr <= 0){
        vr = vr * 1.5;
        Pr = P(vr,slope,direction,rho0)-P(vr);
    }

    while(Pm < -0.3 || Pm > 0.3){
        if(Pm > 0){
            /*velocity has to be reduced*/
            vr = vm;
            Pr = Pm;
        }
        else{
            /*velocity can be increased*/
            vl = vm;
            Pl = Pm;
        }
        vm = (-Pl*vr+Pr*vl)/(Pr-Pl);
        Pm = P(vm,slope,direction,rho0)-P(vm);
    }
    return vm;
}

inline double PowerAnalysis::rho(double h){
    return 1./(273.15+T(h))*(s->p0*100*exp(-1.2931*9.81/101325*h))/287.058;
}

inline double PowerAnalysis::T(double h){
    return s->T + 0.75*(h/100.);
}
inline double PowerAnalysis::P(double v){
    return fermi(v*3.6,s->Pmax,s->PT,s->Pvd);
}
double PowerAnalysis::veff(double v, double direction){
    return v-vwind*cos(direction-s->wd/180*3.1415);
}

inline double PowerAnalysis::P(double v,double slope, double direction,
                               double rho0){
    double veff0 = veff(v,direction);
    return  cwA(veff0)*rho0*0.5*veff0*veff0*veff0
            +((s->cr+slope*sqrt(1./(slope*slope+1)))*s->m*9.81)*v;
}
inline double PowerAnalysis::cwA(double v){
    return s->cwAmin+fermi(v*3.6,s->cwAmax-s->cwAmin,s->cwAT,s->cwAvd);
}
double PowerAnalysis::bft_to_mpros(){
    vwind = 0.836*pow(s->ws,1.5)*0.72*0.5;
    return vwind;
}
void PowerAnalysis::calc_track(Track* t){
    track_to_data(t);
    timeexisting = false;
    calc_power();
}
void PowerAnalysis::track_to_data(Track* t){
    /* extract primary data*/
    double s = t->get_length()*1000.;
    count = ceil(s/5)+1;
    ds = s/(count-1);
    if(count > 0){
        for(int i = 0; i < 9; i++){
            if(d[i] != NULL)
                delete d[i];
            d[i] = new double[count];
        }
    }
    for(int i = 0; i < count; i++){
        d[0][i] = s*i/count;
        t->extract_h(d[0][i]/1000.,&(d[1][i]));
        t->extract_azimtut(d[0][i]/1000.,&(d[2][i]));
    }
    /* calc mean azimutal change data*/
    for(int i = 2; i < count-2; i++){
        double d1 = +d[2][i+2]-d[2][i-2];
        double d2 = +d[2][i+1]-d[2][i-1];
        if(d1 > M_PI) d1 -= 2*M_PI;
        if(d1 <-M_PI) d1 += 2*M_PI;
        if(d2 > M_PI) d2 -= 2*M_PI;
        if(d2 <-M_PI) d2 += 2*M_PI;
        d[3][i] =d1/4+d2/8;
    }
    if(count > 2){
        d[3][1] = -d[3][0]/2.+d[3][2]/2.;
        d[3][count-2] = -d[3][count-3]/2.+d[3][count-1]/2.;
    }
    if(count > 1){
        d[3][0] = -d[3][0]+d[3][1];
        d[3][count-1] = -d[3][count-2]+d[3][count-1];
    }
    /*calc bend radius frommean azimutal change*/
    for(int i = 0; i < count; i++){
        //d[2][i] = d[3][i]/M_PI*180;
        if(qAbs(d[3][i])<1e-10)
            d[3][i] = 1e100;
        else
            d[3][i] = qAbs(ds / 2. / sin(0.5*d[3][i]));
    }
}
void PowerAnalysis::calc_power(){
    /*calc vmax*/
    d[4][count-1] = sqrt(d[3][count-1]*s->aradial);
    for(int i = count-2; i >= 0; i--)
        d[4][i] = qMin(sqrt(d[4][i+1]*d[4][i+1] + 2*ds*s->abrake),
                       sqrt(d[3][i]*s->aradial));
    /*calc v,P*/
    d[5][0] = 1;
    d[6][0] = 0;
    d[7][0] = 0;
    d[8][0] = 0;
    double slope,rho0,st,E,v = 1,a,Pnom,Pis,dtt,dt,vnew;
    Ebrake = Eout = 0;
    double dE;
    if(timeexisting){
        for(int i = 0; i < count-1;i++){
            slope = (d[1][i+1]-d[1][i])/ds;
            rho0 = rho(d[1][i]);
            vnew =  (d[0][qMin(i+10,count-1)]-d[0][qMax(i-10,0)])
                   /(d[6][qMin(i+10,count-1)]-d[6][qMax(i-10,0)]);
            Pis = P(vnew,slope,d[2][i],rho0);
            a = (vnew-v)/(d[6][i+1]-d[6][i]);
            Pnom = a*v*s->m + Pis;
            v = vnew;
            if(Pnom > 0)
                dE = Pnom*(d[6][i+1]-d[6][i]);
            else{
                dE = 0;
                Ebrake += Pnom*(d[6][i+1]-d[6][i]);
                Pnom = 0;
            }
            Eout += dE;
            d[5][i+1] = vnew;
            d[7][i+1] = Pnom;
            d[8][i+1] = d[8][i]+dE;
        }
        /* create power mean value*/
        for(int i = 1; i < count-1;i++)
            d[7][i] = (d[8][qMin(i+20,count-1)]-d[8][qMax(i-20,0)])
                     /(d[6][qMin(i+20,count-1)]-d[6][qMax(i-20,0)]);
    }
    else{
        for(int i = 0; i < count-1;i++){
            slope = (d[1][i+1]-d[1][i])/ds;
            rho0 = rho(d[1][i]);
            st = E = dE = dt = 0;
            v = d[5][i];
            if(s->fightwind)    Pnom = P(veff(v,d[2][i]+M_PI));
            else                Pnom = P(v);
            Pis = P(v,slope,d[2][i],rho0);
            a = (Pnom-Pis)/s->m/v;
            while(st + v + a/2. < ds){
                st += v + a/2.;
                v += a;
                dE += Pnom;
                dt++;
                if(s->fightwind)    Pnom = P(veff(v,d[2][i]));
                else                Pnom = P(v);
                Pis = P(v,slope,d[2][i],rho0);
                a = (Pnom-Pis)/s->m/v;
                if(v+a < 0.1){
                    /* calculation should not crack due to lecking Pnom*/
                    a = v - 0.1;
                    Pnom = a*v*s->m + Pis;
                }
            }
            dtt = (-v+sqrt(2*(ds-st)*a+v*v))/a;
            dt += dtt;
            v += a*dtt;
            dE += Pnom*dtt;
            if(v < d[4][i+1]){
                /*v is not limited by bend vmax*/
                Eout += dE;
                d[5][i+1] = v;
                d[6][i+1] = d[6][i]+dt;
                d[7][i+1] = dE/dt;
                d[8][i+1] = d[8][i]+dE;
            }
            else{
                /*v is limited by bend vmax*/
                dt = 2*ds/(d[4][i+1]+d[5][i]);
                a = (d[4][i+1]-d[5][i])/dt;
                v = d[5][i];
                dE = 0;
                double jmax = ceil(dt);
                for(double j = 0; j < jmax; j++){
                    v = d[5][i] + (j+0.5)/jmax*(d[4][i+1]-d[5][i]);
                    Pis = P(v,slope,d[2][i],rho0);
                    Pnom = a*v*s->m + Pis;
                    if(Pnom > 0){
                        dE += Pnom *dt/jmax;
                    }
                    else
                        Ebrake += Pnom *dt/jmax;
                }
                Eout += dE;
                d[5][i+1] = d[4][i+1];
                d[6][i+1] = d[6][i]+dt;
                d[7][i+1] = dE/dt;
                d[8][i+1] = d[8][i]+dE;
            }
        }
    }
    //calculation is done, statistics
    double maxP = 0;
    for(int i = 0; i < count;i++)
        if(d[7][i] > maxP)
            maxP = d[7][i];
    for(int i = 0; i < 100;i++){
        plotdata[0][i] = maxP*i/100;
        plotdata[1][i] = 0;
    }
    int index;
    for(int i = 1; i < count;i++){
        index = qMax(0,qMin(int(floor(d[7][i]/maxP*100)),99));
        plotdata[1][index] += d[6][i]-d[6][i-1];
    }
    //QString er;
    //for(int i = 0; i < 100; i++)
    //    er.append(QString("%1\t%2\n").arg(plotdata[1][i]).arg(plotdata[0][i]));
    //QApplication::clipboard()->setText(er);
    Pt.set_data(plotdata,100);
    double Eflat = P(d[0][count-1]/d[6][count-1],0,s->wd+90,rho(0))
                  *d[6][count-1];
    textbox.setPlainText(QString("<v> = %1\n<P> = %2 W\n%3% Eflat\n%4% Ebrake\n%5% Eclimb+wind")
                         .arg(d[0][count-1]/d[6][count-1]*3.6)
                         .arg(Eout/d[6][count-1])
                         .arg(Eflat/Eout*100,100,'f',0)
                         .arg(-Ebrake/Eout*100,100,'f',0)
                         .arg((Eout+Ebrake-Eflat)/Eout*100,100,'f',0));
}
void PowerAnalysis::calc_track(Track* t,double* timed,
                               double* time, int count){
    track_to_data(t);
    timeexisting = true;
    double t0 = time[0];
    int r=1;
    for(int i = 0;i < this->count; i++){
        while(d[0][i] > timed[r]*1000 && r < count)
            r++;
        if(d[0][i] <= timed[r]*1000 && timed[r] > timed[r-1]){
            d[6][i] =( (d[0][i]      -timed[r-1]*1000)*time[r]
                      +(timed[r]*1000-        d[0][i])*time[r-1])
                     /(timed[r]*1000-timed[r-1]*1000)-t0;
            if(i > 0 && d[6][i] == d[6][i-1])
                timeexisting = false;
        }
        else
            d[6][i] = d[6][qMax(0,i-1)]+1;
    }
    if(d[6])
    calc_power();
}
double PowerAnalysis::get_v(){
    if(count>0)
        return d[0][count-1]/d[6][count-1]*3.6;
    else
        return 0.;
}

double PowerAnalysis::get_P(){
    if(count>0)
        return Eout/d[6][count-1];
    else
        return 0.;
}

double PowerAnalysis::get_t(double d){
    int index = int(ceil(count*d*1000/this->d[0][count-1]));
    if(index<count && index>=0)
        return this->d[6][index];
    else
        return 0;

}

double PowerAnalysis::get_v(double d){
    int index = int(ceil(count*d*1000/this->d[0][count-1]));
    if(index<count && index>=0)
        return this->d[5][index]*3.6;
    else
        return 0;
}

double PowerAnalysis::get_P(double d){
    int index = int(ceil(count*d*1000/this->d[0][count-1]));
    if(index<count && index>=0)
        return this->d[7][index];
    else
        return 0;

}
double PowerAnalysis::get_v(double dmin, double dmax){
    int index1 = int(ceil(count*dmin*1000/d[0][count-1]));
    int index2 = int(ceil(count*dmax*1000/d[0][count-1]));
    if(index1<count && index1>=0 && index2<count && index2>=0
       && d[6][index2]>d[6][index1])
        return  (d[0][index2]-d[0][index1])
               /(d[6][index2]-d[6][index1])*3.6;
    else
        return 0;
}

double PowerAnalysis::get_P(double dmin, double dmax){
    int index1 = int(ceil(count*dmin*1000/d[0][count-1]));
    int index2 = int(ceil(count*dmax*1000/d[0][count-1]));
    if(index1<count && index1>=0 && index2<count && index2>=0
       && d[6][index2]>d[6][index1])
        return  (d[8][index2]-d[8][index1])
               /(d[6][index2]-d[6][index1]);
    else
        return 0;
}

int PowerAnalysis::isready(){
    if(count>0)
        return 1;
    else
        return 0;
}
double** PowerAnalysis::get_Pdata(){
    if(count > 0){
        Pdata[0] = d[0];
        Pdata[1] = d[7];
        return Pdata;
    }
    else
        return NULL;
}

double** PowerAnalysis::get_vdata(){
    if(count > 0){
        vdata[0] = d[0];
        vdata[1] = d[5];
        return vdata;
    }
    else
        return NULL;

}

int PowerAnalysis::get_datacount(){
    return count;
}
void PowerAnalysis::recalc(){
    calc_power();
    emit recalced();
}
void PowerAnalysis::toggle_fightwind(){
    if(fwcb.isChecked())
        s->fightwind = 1;
    else
        s->fightwind = 0;
}
void PowerAnalysis::toggle_timestamp(){
    if(timeexisting){
        textbox.setPlainText("Calculation will be based on user defined, velocity dependend power output.");
        timeexisting = false;
    }
    else{
        // check if a good time stamp exist
        bool timeOK = true;
        for(int i = 0; i < count; i++)
            if(d[6][i] == d[6][i-1])
                timeOK = false;
        if(timeOK){
            textbox.setPlainText("Calculation will be based on current time/velocity stamps.");
            timeexisting = true;
        }
        else
            textbox.setPlainText("Time/velocity stamps are not valid, stamps will be ignored.");
    }
}