SpiderBuilder::SpiderBuilder(){
Spider spider();
this->spider.frame = 0;
Leg l = Leg(-10, 50, 0.55, 0.5);
this->spider.legs.push_back(l);
l = Leg(5, 40, 0.52, 0.4);
this->spider.legs.push_back(l);
l = Leg(-10, 50, 0.52, 0.4);
this->spider.legs.push_back(l);
l = Leg(10, 45, 0.6, 0.5);
this->spider.legs.push_back(l);
this->spider.isRedirecting = false;
this->spider.redirectFinish = false;
this->spider.aliveFlag = true;
this->done = false;
}
Set::Set(bool playerstart, int set):
playertostart(playerstart),
setnumber(set)
{
bool temp = playertostart;
for (int i = 0; i < 5; i++) {
legs[i] = Leg(playertostart, setnumber);
playertostart = !playertostart;
}
playertostart = temp;
for (int i = 0; i < 11; i++) {
tiebreaker[i] = Leg(playertostart, setnumber);
playertostart = !playertostart;
}
playertostart = legs[4].playertothrow;
}
Spider(glm::vec3 _position, glm::vec3 _view_direction, std::function<double(glm::vec3)> _get_height_at) : position(_position), view_direction(_view_direction), get_height_at(_get_height_at)
{
height = position.y;
legs_geometry = std::make_shared<geogo::Mesh>();
for (auto foot_pos : {glm::vec3(0.75, 0., 2.), glm::vec3(1.,0.,1.), glm::vec3(1.,0.,-0.5), glm::vec3(0.75,0.,-2.),
glm::vec3(-0.75, 0., 2.), glm::vec3(-1.,0.,1.), glm::vec3(-1.,0.,-0.5), glm::vec3(-0.75,0.,-2.)})
{
legs.push_back(Leg(legs_geometry, foot_pos));
}
update_local2world();
}
Leg FixedRateLeg::load_fixedRateLeg(const std::string& legID)
{
// load ÂÞ¿í.
Leg leg = Leg();
clsMAST_CF_FIXED_TB clstb = clsMAST_CF_FIXED_TB();
clstb.LEG_ID = legID;
clstb._LEG_IDSelectFlag = true;
std::vector<boost::shared_ptr<clsMAST_CF_FIXED_TB>> cfList
= clstb.create(clstb.selectQuery_raw());
QL_REQUIRE(cfList.size() > 0, "fixedRate cash-flow does not exist : " + legID);
Size cashflow_num = cfList.size();
for (Size i = 0; i < cashflow_num ; i++)
{
const Date& paymentDate = DateParser::parseDB(cfList[i]->PAYMENT_DT);
Real nominal = cfList[i]->NOTIONAL;
Real rate = cfList[i]->FIXED_RATE;
const DayCounter& dayCounter = DayCounterFactory::load_dayCounter("act/365f");
const Date& startDate = DateParser::parseDB(cfList[i]->CALC_START_DT);
const Date& endDate = DateParser::parseDB(cfList[i]->CALC_END_DT);
boost::shared_ptr<FixedRateCoupon> frc
= boost::shared_ptr<FixedRateCoupon>(
new FixedRateCoupon(paymentDate,
nominal,
rate,
dayCounter,
startDate,
endDate));
leg.push_back(frc);
}
// sort ?
return leg;
}
Tripod::Tripod (int ID_front_knee, int ID_middle_knee, int ID_back_knee, unordered_map<int, DnxHAL*>& servo_map, double height_in, const BodyParams& robot_params) :
legs{ Leg(ID_front_knee, ID_front_knee+6, ID_front_knee+18, servo_map, height_in, robot_params),
Leg(ID_middle_knee, ID_middle_knee+6, ID_middle_knee+18, servo_map, height_in, robot_params),
Leg(ID_back_knee, ID_back_knee+6, ID_back_knee+18, servo_map, height_in, robot_params)
} {}
bool Plan_File::Read (long offset)
{
//---- check the file status ----
if (!Check_File ()) return (false);
if (plan == NULL) return (Status (RECORD_SIZE));
if (File_Access () != READ) return (Status (ERROR));
//---- move to a specified location in the file ----
if (offset >= 0) {
if (!Offset (offset)) return (false);
}
//---- allocate space ----
if (allocate_memory) {
if (!Setup_Record ()) return (false);
}
//---- read the next plan ----
if (Record_Format () == BINARY) {
int num_token;
if (!Db_File::Read (plan, (sizeof (Plan_Data) - sizeof (int)))) return (false);
if (time_sort) {
int temp = plan->key1;
plan->key1 = plan->key2;
plan->key2 = temp;
}
num_record++;
num_plan++;
if (Leg () == 2) {
num_trip++;
} else if (Leg () == 1 && Trip () == 1) {
num_traveler++;
}
num_token = Tokens ();
if (num_token > 0) {
if (!Check_Size (num_token)) return (false);
if (!Db_File::Read (&(plan->data [0]), num_token * sizeof (int))) return (Status (PLAN_FIELDS));
num_record++;
}
return (true);
} else {
int field, max_field, value;
char buffer [40], *ptr;
field = max_field = 0;
while (Db_File::Read ()) {
num_record++;
ptr = Clean_Record ();
//---- check for a blank record ----
if (ptr == NULL || *ptr == '\0') continue;
//---- process the plan record ----
while (ptr != NULL) {
ptr = Get_Token (ptr, buffer, sizeof (buffer));
if (buffer [0] == '\0') break;
field++;
value = atol (buffer);
switch (field) {
case 1: //---- traveler id ----
Traveler (value);
num_plan++;
break;
case 2: //---- user field ----
break;
case 3: //---- trip id ----
Trip (value);
break;
case 4: //---- leg id ----
Leg (value);
if (value == 2) {
num_trip++;
} else if (value == 1 && Trip () == 1) {
num_traveler++;
}
break;
case 5: //---- time ----
Time (value);
break;
case 6: //---- start id ----
Start_ID (value);
break;
case 7: //---- start type ----
Start_Type (value);
break;
case 8: //---- end id ----
End_ID (value);
break;
case 9: //---- end type ----
End_Type (value);
break;
case 10: //---- duration ----
Duration (value);
break;
case 11: //---- stop time ----
Stop_Time (value);
break;
case 12: //---- max time flag ----
break;
case 13: //---- cost ----
Cost (value);
break;
case 14: //---- gcf ----
GCF (value);
break;
case 15: //---- driver flag ----
Driver_Flag (value);
break;
case 16: //---- mode ----
Mode (value);
break;
case 17: //---- number of tokens ----
if (value < 0) {
Status (PLAN_FIELDS);
return (false);
}
Tokens (value);
max_field = value + 17;
if (value == 0) return (true);
if (!Check_Size (value)) return (false);
break;
default: //---- token value ----
if (field > max_field) {
Status (PLAN_FIELDS);
return (false);
}
plan->data [field - 18] = value;
if (field == max_field) return (true);
break;
}
}
}
if (field != 0) {
return (Status (PLAN_FIELDS));
}
return (false);
}
}
bool Plan_File::Write (Plan_Data *data)
{
int num_token;
FILE *file;
//---- check the file status ----
if (!Check_File ()) return (false);
if (File_Access () == READ) return (Status (ERROR));
Plan_Data *backup = NULL;
if (data != NULL) {
backup = plan;
plan = data;
} else {
if (plan == NULL) return (Status (RECORD_SIZE));
}
//---- write the plan data ----
file = File ();
num_token = Tokens ();
if (Record_Format () == BINARY) {
if (time_sort) {
int size, temp;
size = sizeof (Plan_Data) - sizeof (int);
memcpy (backup, plan, size);
temp = backup->key1;
backup->key1 = backup->key2;
backup->key2 = temp;
if (!Db_File::Write (backup, size)) goto reset;
} else {
if (!Db_File::Write (plan, (sizeof (Plan_Data) - sizeof (int)))) goto reset;
}
num_record++;
num_plan++;
if (Leg () == 2) {
num_trip++;
} else if (Leg () == 1 && Trip () == 1) {
num_traveler++;
}
if (num_token > 0) {
if (!Db_File::Write (&(plan->data [0]), num_token * sizeof (int))) goto reset;
num_record++;
}
} else {
if (fprintf (file, "%d 0 %d %d\n%d %d %d %d %d\n%d %d %d %d %d\n%d %d\n%d\n",
Traveler (), Trip (), Leg (),
Time (), Start_ID (), Start_Type (), End_ID (), End_Type (),
Duration (), Stop_Time (), 1, Cost (), GCF (),
Driver_Flag (), Mode (),
num_token) < 0) goto reset;
num_record += 5;
num_plan++;
if (Leg () == 2) {
num_trip++;
} else if (Leg () == 1 && Trip () == 1) {
num_traveler++;
}
//---- write tokens ----
if (num_token > 0) {
int field;
int i = 0;
switch (Mode ()) {
case AUTO_MODE: //---- auto ----
if (Driver_Flag ()) {
//---- vehicle ID and number of passengers ----
i = 2;
if (fprintf (file, "%d %d\n", plan->data [0], plan->data [1]) < 0) goto reset;
num_record++;
}
break;
case TRANSIT_MODE: //---- transit ----
if (Driver_Flag ()) {
//---- schedule pairs, vehicle ID, and route ID ----
i = 3;
if (fprintf (file, "%d %d %d\n", plan->data [0], plan->data [1], plan->data [2]) < 0) goto reset;
num_record++;
}
break;
default:
break;
}
//---- print the rest of the fields in groups of 10 ----
for (field=0; i < num_token; i++, field++) {
if (!field) {
if (fprintf (file, "%d", plan->data [i]) < 0) goto reset;
num_record++;
} else if (!(field % 10)) {
if (fprintf (file, "\n%d", plan->data [i]) < 0) goto reset;
num_record++;
} else {
if (fprintf (file, " %d", plan->data [i]) < 0) goto reset;
}
}
if (field) {
if (fprintf (file, "\n") < 0) goto reset;
}
}
//---- add a blank line at the end of the plan ----
if (fprintf (file, "\n") < 0) goto reset;
num_record++;
Flush ();
}
if (data != NULL) {
plan = backup;
}
return (true);
reset:
if (data != NULL) {
plan = backup;
}
return (false);
}
Leg Spider::getLeg(byte index) {
return Leg(_legs[index]);
}
void draw_model_independent(){
for(int nJets=4; nJets<=8; nJets++){
for (int nb=0; nb<=2; nb++) {
TLegend Leg(0.65,0.65,0.85,0.8);
Leg.SetFillColor(10);
Leg.SetBorderSize(0);
Leg.SetLineColor(10);
TString nameObs=Form("ModelIndependent_obs_nJets%d_nb%d",nJets,nb);
TString nameExp=Form("ModelIndependent_exp_nJets%d_nb%d",nJets,nb);
TString nameExp_1S=Form("ModelIndependent_exp_1sigma_nJets%d_nb%d",nJets,nb);
TString nameExp_2S=Form("ModelIndependent_exp_2sigma_nJets%d_nb%d",nJets,nb);
CreateCanvas(Form("ModelIndependent_Plots_nJets%d_%dbtags",nJets,nb), "", 600,600);
CName[Form("ModelIndependent_Plots_nJets%d_%dbtags",nJets,nb)]->cd();
gPad->SetLogy();
grName[nameObs]->SetLineColor(kBlack);
grName[nameExp]->SetLineColor(kBlack);
grName["stop_xs_st_Acc0p5"]->SetLineColor(kRed);
grName["stop_xs_st_Acc0p5"]->SetLineWidth(2);
grName[nameExp]->SetLineStyle(kDashed);
grName[nameExp_1S]->SetFillStyle(1001);
grName[nameExp_2S]->SetFillStyle(1001);
grName[nameExp_1S]->SetFillColor(3);
grName[nameExp_2S]->SetFillColor(5);
grName[nameExp_1S]->Draw("a3");
grName[nameExp_1S]->GetXaxis()->SetRangeUser(300,2000);
grName[nameExp_1S]->GetYaxis()->SetRangeUser(0.05,20);
grName[nameExp_1S]->GetXaxis()->SetNdivisions(6);
//grName[nameExp_1S]->GetYaxis()->SetRangeUser(5,1.5*grName["squark_xs"]->Eval(300));
grName[nameExp_1S]->GetXaxis()->SetTitle("S_{T}^{min} (GeV)");
grName[nameExp_1S]->GetYaxis()->SetTitle("#sigma*A (fb)");
Leg.AddEntry(grName[nameObs],"observed","L");
Leg.AddEntry(grName[nameExp],"expected","L");
Leg.AddEntry(grName[nameExp_1S],"#pm 1SD","F");
TLatex txt;
txt.SetNDC(kTRUE);
grName[nameExp_1S]->Draw("a3");
grName[nameExp]->Draw("l same");
grName[nameObs]->Draw("l same");
//grName["stop_xs_st_Acc0p5"]->Draw("l same");
Leg.DrawClone();
txt.DrawLatex(0.5,0.8,Form("%d-jets, %d b-tags",nJets,nb));
draw_header();
gPad->RedrawAxis();
}
}
}
void draw_sensitivity(int mass){
CreateCanvas(Form("Limit_sensitivity_M%d",mass),"",600,600);
CName[Form("Limit_sensitivity_M%d",mass)]->cd();
hName[Form("h_sensitivity_M%d_exp",mass)]->SetLineStyle(kDashed);
hName[Form("h_sensitivity_M%d_obs",mass)]->SetLineWidth(2);
hName[Form("h_sensitivity_M%d_exp_1sigmaP",mass)]->SetLineStyle(kDashed);
hName[Form("h_sensitivity_M%d_exp_1sigmaM",mass)]->SetLineStyle(kDashed);
hName[Form("h_sensitivity_M%d_exp_1sigmaP",mass)]->SetLineColor(kRed);
hName[Form("h_sensitivity_M%d_exp_1sigmaM",mass)]->SetLineColor(kRed);
hName[Form("h_sensitivity_M%d_exp",mass)]->SetMinimum(0);
double max=1.5*hName[Form("h_sensitivity_M%d_exp_1sigmaP",mass)]->GetMaximum();
hName[Form("h_sensitivity_M%d_exp",mass)]->SetMaximum(max);
hName[Form("h_sensitivity_M%d_exp",mass)]->Draw("histo");
hName[Form("h_sensitivity_M%d_obs",mass)]->Draw("histo same");
hName[Form("h_sensitivity_M%d_exp_1sigmaP",mass)]->Draw("histo same");
hName[Form("h_sensitivity_M%d_exp_1sigmaM",mass)]->Draw("histo same");
TLegend Leg(0.65,0.65,0.85,0.8);
Leg.SetFillColor(10);
Leg.SetBorderSize(0);
Leg.SetLineColor(10);
Leg.AddEntry(hName[Form("h_sensitivity_M%d_exp",mass)],"Expected","L" );
Leg.AddEntry(hName[Form("h_sensitivity_M%d_exp_1sigmaP",mass)],"#pm 1 #sigma","L");
Leg.AddEntry(hName[Form("h_sensitivity_M%d_obs",mass)],"Observed","L");
Leg.DrawClone();
TLatex txt;
txt.SetNDC(kTRUE);
txt.DrawLatex(0.62,0.85,Form("M_{#tilde{q}}=%d GeV",mass));
/*
CreateGraph(Form("sensitivity_M%d_obs",mass) );
CreateGraph(Form("sensitivity_M%d_exp",mass) );
CreateGraph(Form("sensitivity_M%d_exp_1sigma",mass) );
CreateGraph(Form("sensitivity_M%d_exp_2sigma",mass) );
for(int i=0; i<grName[Form("sensitivity_M%d_exp",mass)]->GetN(); i++){
cout << " x: " << grName[Form("sensitivity_M%d_exp",mass)]->GetX()[i] << " ";
cout << " y: " << grName[Form("sensitivity_M%d_exp",mass)]->GetY()[i] << endl;
}
grName[Form("sensitivity_M%d_obs",mass)]->SetLineStyle(kDashed);
grName[Form("sensitivity_M%d_obs",mass)]->SetLineColor(kBlack);
grName[Form("sensitivity_M%d_exp",mass)]->SetFillStyle(1001);
grName[Form("sensitivity_M%d_exp_1sigma",mass)]->SetFillColor(419);
grName[Form("sensitivity_M%d_exp",mass)]->Draw("ap");
int nJ=4;
for(int i=0; i<15; i++){
TString label=Form("%d",nJ);
if(nJ==8)label=Form("#geq %d",nJ);
grName[Form("sensitivity_M%d_exp",mass)]->GetXaxis()->SetBinLabel(i+1,label);
nJ++;
if(nJ>8)nJ=4;
}
// grName[Form("sensitivity_M%d_exp",mass)]->GetXaxis()->SetRangeUser(4,24);
// grName["xs_limit_1sigma"]->Draw("a3");
grName[Form("sensitivity_M%d_exp",mass)]->Draw("ap ");
//grName["xs_limit_2sigma"]->Draw("a3 same");
grName[Form("sensitivity_M%d_obs",mass)]->Draw("p same");
*/
}
void draw_plots(){
CreateCanvas(Form("Limit_Plot"),"",600,600);
CName["Limit_Plot"]->cd();
gPad->SetLogy();
grName["squark_xs"]->SetLineColor(kBlack);
grName["squark_xs"]->SetLineStyle(kDotted);
grName["squark_xs"]->SetFillColor(46);
grName["xs_exp_combined"]->SetLineColor(kBlack);
grName["xs_obs_combined"]->SetLineColor(kBlack);
grName["xs_exp_combined"]->SetLineStyle(kDashed);
grName["xs_exp_combined_1sigma"]->SetFillStyle(1001);
grName["xs_exp_combined_2sigma"]->SetFillStyle(1001);
grName["xs_exp_combined_1sigma"]->SetFillColor(3);
grName["xs_exp_combined_2sigma"]->SetFillColor(5);
grName["xs_exp_combined_1sigma"]->Draw("a3");
grName["xs_exp_combined_2sigma"]->Draw("a3");
grName["xs_exp_combined_1sigma"]->GetXaxis()->SetRangeUser(300,900);
grName["xs_exp_combined_2sigma"]->GetXaxis()->SetRangeUser(300,900);
grName["xs_exp_combined_1sigma"]->GetYaxis()->SetRangeUser(5,1.5*grName["squark_xs"]->Eval(300));
grName["xs_exp_combined_2sigma"]->GetYaxis()->SetRangeUser(5,1.5*grName["squark_xs"]->Eval(300));
grName["xs_exp_combined_1sigma"]->GetXaxis()->SetTitle("M_{#tilde{q}} (GeV)");
grName["xs_exp_combined_1sigma"]->GetYaxis()->SetTitle("#sigma (fb)");
grName["xs_exp_combined_2sigma"]->GetXaxis()->SetTitle("M_{#tilde{q}} (GeV)");
grName["xs_exp_combined_2sigma"]->GetYaxis()->SetTitle("#sigma (fb)");
//grName["xs_exp_combined_2sigma"]->Draw("a3 same");
grName["xs_exp_combined_1sigma"]->Draw("a3");
grName["xs_exp_combined"]->Draw("l same");
grName["xs_obs_combined"]->Draw("l same");
grName["squark_xs"]->Draw("3 same");
grName["squark_xs"]->Draw("cx0 same");
grName["xs_exp_combined"]->Draw("l same");
grName["xs_obs_combined"]->Draw("l same");
TLegend Leg(0.6,0.5,0.85,0.67);
Leg.SetFillColor(10);
Leg.SetBorderSize(0);
Leg.SetLineColor(10);
Leg.AddEntry(grName["xs_exp_combined"],"Expected","L" );
Leg.AddEntry(grName["xs_obs_combined"],"Observed","L");
Leg.AddEntry(grName["xs_exp_combined_1sigma"],"#pm 1 #sigma_{ex}","f");
// Leg.AddEntry(grName["xs_exp_combined_2sigma"],"#pm 2 SD","f");
Leg.AddEntry(grName["squark_xs"],"#sigma_{#tilde{q}#tilde{q}} #pm 1 #sigma_{th} ","LF");
Leg.DrawClone();
//TLatex txt(0.4,0.85,"M_{#tilde{#chi}_{1}^{#pm}}=1/2#timesM_{#tilde{q}}, Br(#tilde{#chi}_{1}^{#pm}#rightarrowW^{#pm},#tilde{S})=1");
TLatex txt(0.6,0.85,"pp #rightarrow #tilde{q}_{L}#tilde{q}_{L}");
//TLatex txt1(0.2,0.3,"M_{ #tilde{#chi}_{1}^{#pm} }=1/2#timesM_{ #tilde{q} }");
TLatex txt1(0.2,0.3,"M_{ #tilde{#chi}_{1}^{#pm} }=1/2#timesM_{ #tilde{q} }");
TLatex txt2(0.2,0.2,"M_{#tilde{S}} = 100 GeV, M_{S} = 90 GeV");
//, Br(#tilde{#chi}_{1}^{#pm}#rightarrowW^{#pm},#tilde{S})=1");
txt.SetTextSize(0.045);
txt.SetNDC(kTRUE);
txt.DrawClone();
txt.DrawLatex(0.6,0.77,"#tilde{q}_{L}#rightarrow q #tilde{#chi}_{1}^{#pm}");
txt.DrawLatex(0.6,0.69,"#tilde{#chi}_{1}^{#pm}#rightarrow W^{#pm} #tilde{S}");
txt.DrawLatex(0.2,0.4,"#tilde{q}_{L}: #tilde{u}, #tilde{d}, #tilde{s}, #tilde{c}");
txt1.SetTextSize(0.045);
txt1.SetNDC(kTRUE);
txt2.SetTextSize(0.045);
txt2.SetNDC(kTRUE);
txt1.DrawClone();
txt2.DrawClone();
//txt.DrawLatex(0.4,0.75,"M_{#tilde{S}}=100 GeV, M_{S}=90 GeV");
CMS_lumi(CName["Limit_Plot"],2,10);
//draw_header();
gPad->RedrawAxis();
}
qf::core::utils::TreeTable RelaysPlugin::nlegsResultsTable(int class_id, int leg_count, int places, bool exclude_not_finish)
{
int max_leg = 0;
qfs::Query q;
{
qfs::QueryBuilder qb;
qb.select("relayLegCount")
.from("classdefs")
.where("classId=" QF_IARG(class_id));
q.execThrow(qb.toString());
if(q.next())
max_leg = q.value(0).toInt();
}
if(max_leg == 0) {
qfError() << "Leg count not defined for class id:" << class_id;
return qf::core::utils::TreeTable();
}
if(leg_count > max_leg)
leg_count = max_leg;
QList<Relay> relays;
//QStringList relay_ids;
{
qfs::QueryBuilder qb;
qb.select2("relays", "id, club, name, number")
.select2("clubs", "name")
.from("relays")
.join("relays.club", "clubs.abbr")
.where("relays.classId=" QF_IARG(class_id));
q.execThrow(qb.toString());
while(q.next()) {
Relay r;
r.relayId = q.value("relays.id").toInt();
r.name = (q.value("relays.number").toString()
+ ' ' + q.value("relays.club").toString()
+ ' ' + q.value("relays.name").toString()
+ ' ' + q.value("clubs.name").toString()).trimmed();
for (int i = 0; i < leg_count; ++i)
r.legs << Leg();
relays << r;
//relay_ids << QString::number(r.relayId);
}
}
{
qfs::QueryBuilder qb;
qb.select2("competitors", "id, registration")
.select2("runs", "id, relayId, leg")
.select("COALESCE(competitors.lastName, '') || ' ' || COALESCE(competitors.firstName, '') AS competitorName")
.from("runs")
.join("runs.competitorId", "competitors.id")
.joinRestricted("runs.relayId", "relays.id", "relays.classId=" QF_IARG(class_id), qfs::QueryBuilder::INNER_JOIN)
//.where("runs.relayId IN (" + relay_ids.join(',') + ")")
.where("runs.leg>0 AND runs.leg<=" + QString::number(leg_count))
.orderBy("runs.relayId, runs.leg");
q.execThrow(qb.toString());
while(q.next()) {
int relay_id = q.value("runs.relayId").toInt();
for (int i = 0; i < relays.count(); ++i) {
if(relays[i].relayId == relay_id) {
Relay &relay = relays[i];
int legno = q.value("runs.leg").toInt();
Leg &leg = relay.legs[legno - 1];
leg.name = q.value("competitorName").toString();
leg.runId = q.value("runs.id").toInt();
leg.reg = q.value("competitors.registration").toString();
break;
}
}
}
}
for (int legno = 1; legno <= leg_count; ++legno) {
qfs::QueryBuilder qb;
qb.select2("runs", "id, relayId, timeMs, disqualified")
.from("runs")
.joinRestricted("runs.relayId", "relays.id",
"relays.classId=" QF_IARG(class_id)
" AND runs.leg=" QF_IARG(legno)
" AND runs.isRunning"
" AND NOT runs.notCompeting"
" AND runs.finishTimeMs>0"
, qfs::QueryBuilder::INNER_JOIN)
.orderBy("runs.disqualified, runs.timeMs");
q.execThrow(qb.toString());
int run_pos = 1;
while(q.next()) {
int relay_id = q.value("runs.relayId").toInt();
for (int i = 0; i < relays.count(); ++i) {
if(relays[i].relayId == relay_id) {
int run_id = q.value("runs.id").toInt();
Relay &relay = relays[i];
Leg &leg = relay.legs[legno - 1];
if(leg.runId != run_id) {
qfError() << "internal error, leg:" << legno << "runId check:" << leg.runId << "should equal" << run_id;
}
else {
leg.notfinish = false;
leg.disq = q.value("runs.disqualified").toBool();
leg.time = q.value("timeMs").toInt();
leg.pos = leg.disq? 0: run_pos;
run_pos++;
}
break;
}
}
}
}
/// compute overal legs positions
for (int legno = 1; legno <= leg_count; ++legno) {
QList<QPair<int, int>> relay_stime;
for (int i = 0; i < relays.count(); ++i) {
Relay &relay = relays[i];
Leg &leg = relay.legs[legno - 1];
if(!leg.notfinish && !leg.disq) {
if(legno == 1)
leg.stime = leg.time;
else if(relay.legs[legno-2].stime > 0)
leg.stime = leg.time + relay.legs[legno-2].stime;
}
if(leg.stime > 0)
relay_stime << QPair<int, int>(relay.relayId, leg.stime);
}
std::sort(relay_stime.begin(), relay_stime.end(), [](const QPair<int, int> &a, const QPair<int, int> &b) {return a.second < b.second;});
int pos = 0;
for(const QPair<int, int> &p : relay_stime) {
int relay_id = p.first;
for (int i = 0; i < relays.count(); ++i) {
if(relays[i].relayId == relay_id) {
Relay &relay = relays[i];
Leg &leg = relay.legs[legno - 1];
leg.spos = ++pos;
break;
}
}
}
}
if(exclude_not_finish) {
/*
relays.erase(std::remove_if(relays.begin(),
relays.end(),
[](const Relay &r){return r.time(leg_count) == TIME_NOT_FINISH;}),
relays.end());
*/
QMutableListIterator<Relay> i(relays);
while (i.hasNext()) {
const Relay &r = i.next();
if(r.time(leg_count) == qog::TimeMs::NOT_FINISH_TIME_MSEC)
i.remove();
}
}
/// sort relays
std::sort(relays.begin(), relays.end(), [leg_count](const Relay &a, const Relay &b) {
return a.time(leg_count) < b.time(leg_count);
});
int time0 = 0;
qf::core::utils::TreeTable tt;
tt.appendColumn("pos", QVariant::Int);
tt.appendColumn("name", QVariant::String);
tt.appendColumn("time", QVariant::Int);
tt.appendColumn("loss", QVariant::Int);
for (int i = 0; i < qMin(relays.count(), places); ++i) {
qf::core::utils::TreeTableRow rr = tt.appendRow();
Relay &relay = relays[i];
int time = relay.time(leg_count);
if(i == 0)
time0 = time;
int prev_time = (i > 0)? relays[i-1].time(leg_count): 0;
rr.setValue("pos", (time <= qog::TimeMs::MAX_REAL_TIME_MSEC && time > prev_time)? i+1: 0);
rr.setValue("name", relay.name);
rr.setValue("time", time);
rr.setValue("loss", (time <= qog::TimeMs::MAX_REAL_TIME_MSEC)?time - time0: 0);
qf::core::utils::TreeTable tt2;
tt.appendColumn("name", QVariant::String);
tt.appendColumn("reg", QVariant::String);
tt.appendColumn("time", QVariant::Int);
tt.appendColumn("pos", QVariant::Int);
tt.appendColumn("stime", QVariant::Int);
tt.appendColumn("spos", QVariant::Int);
//tt.appendColumn("disq", QVariant::Bool);
for (int j = 0; j < relay.legs.count(); ++j) {
Leg &leg = relay.legs[j];
qf::core::utils::TreeTableRow rr2 = tt2.appendRow();
rr2.setValue("competitorName", leg.name);
rr2.setValue("registration", leg.reg);
rr2.setValue("time",
leg.disq? qog::TimeMs::DISQ_TIME_MSEC
: (leg.time == 0)? qog::TimeMs::NOT_FINISH_TIME_MSEC
: leg.time);
rr2.setValue("pos", leg.pos);
rr2.setValue("stime", leg.stime);
rr2.setValue("spos", leg.spos);
//rr2.setValue("disq", leg.disq);
}
rr.appendTable(tt2);
}
//qfInfo() << tt.toString();
return tt;
}
