Expert Analysis: New Lambton (w) vs Broadmeadow Magic (w)

On August 9, 2025, at 06:00, the women’s football match between New Lambton and Broadmeadow Magic is set to take place. This expert analysis provides a detailed breakdown of betting predictions based on available data. The match promises an engaging encounter, with statistical insights suggesting various outcomes.

Betting Predictions

• Both Teams Not To Score In 1st Half: 98.80
• Both Teams Not To Score In 2nd Half: 97.50
• Over 2.5 Goals: 89.80
• Over 1.5 Goals: 90.10
• Home Team To Win: 67.10
• Over 3.5 Goals: 52.00
• Both Teams To Score: 53.00
• Over 2.5 BTTS: 54.10

Average Goal Metrics

• Avg. Total Goals: 5.93
• Avg. Conceded Goals: 3.30
• Avg. Goals Scored: 3.13

Predictions Summary

The statistical predictions suggest a high probability that neither team will score in the first half (98.80), with a similarly high chance for the second half (97.50). However, the likelihood of an exciting game with over 1.5 goals is also significant at 90.10, and even higher for over 2.5 goals at 89.80.

The possibility of both teams scoring stands at a moderate chance of 53.00, while the odds for the home team winning are set at a reasonable level of 67.10.

The match is expected to be goal-rich, with an average total goal count of approximately six goals per game, indicating a dynamic and potentially high-scoring match.

The over/under stats suggest a balance between defensive strategies and offensive opportunities, with the odds reflecting potential tactical approaches from both teams.

Additiona#include “pilot.h”
#include “TSystem.h”
#include “TFile.h”
#include “TH1.h”
#include “TH2.h”
#include “TTree.h”
#include “TCanvas.h”
#include “TMath.h”
#include “TLegend.h”
#include “TGraphErrors.h”

void plot( int runNum ) {

// open root file
TFile *f = new TFile(Form(“data/fit_run%d.root”,runNum));

// get fit tree
TTree *tree = (TTree*) f->Get(“fitTree”);

// declare variables
int nData;
double dX[100], dY[100], dChiSq;
tree->SetBranchAddress(“nData”, &nData);
tree->SetBranchAddress(“dX”, dX);
tree->SetBranchAddress(“dY”, dY);
tree->SetBranchAddress(“dChiSq”, &dChiSq);

// initialize histogram
const int nBins = runNum == run8 ? numFitBins8 : numFitBins;
TH1D *hChiSq = new TH1D(Form(“hChiSq_run%d”,runNum),Form(“chi^2 / ndf for run %d”,runNum), nBins, chiSqMin, chiSqMax);

// loop over entries in tree and fill histogram
for (int iEntry =0; iEntry GetEntries(); iEntry++) {
tree->GetEntry(iEntry);
hChiSq->Fill(dChiSq/nData);
}

// save canvas as pdf
TCanvas *c1 = new TCanvas(Form(“c1_run%d”,runNum),Form(“c1_run%d”,runNum));
hChiSq->Draw();
c1->SaveAs(Form(“plots/run%d.pdf”,runNum));

// close file
f->Close();

}
bblanchon/Pilot/rootplot.C
#include “pilot.h”
#include “TSystem.h”
#include “TFile.h”
#include “TH1.h”
#include “TH2.h”
#include “TTree.h”
#include “TCanvas.h”
#include “TMath.h”
#include “TLegend.h”

void rootplot() {

gStyle->SetOptStat(0);

const int numRuns = sizeof(runNumbers) / sizeof(runNumbers[0]);

// make plots
for (int iRun =0; iRun Get(“fitTree”);

int nData;
double dX[100], dY[100], dChiSq;
tree->SetBranchAddress(“nData”, &nData);
tree->SetBranchAddress(“dX”, dX);
tree->SetBranchAddress(“dY”, dY);
tree->SetBranchAddress(“dChiSq”, &dChiSq);

const int nBins = runNumbers[iRun] == run8 ? numFitBins8 : numFitBins;
const double minChiSq = runNumbers[iRun] == run8 ? chiSqMin8 : chiSqMin;
const double maxChiSq = runNumbers[iRun] == run8 ? chiSqMax8 : chiSqMax;

TCanvas *c1 = new TCanvas(Form(“c1_run%d”,runNumbers[iRun]),Form(“c1_run%d”,runNumbers[iRun]));
c1->SetLogy();

const int nColors[] = {kRed, kBlue};
TLegend *legend = new TLegend(0.15,0.15,0.35,0.35);

for (int iColor=0; iColor<2; iColor++) {

double minE = iColor == minEColor ? minEValue : maxEValue;
double maxE = iColor == minEColor ? maxEValue : minEValue;

TString histName = Form("hFitBin_%d_%f_%f_run%d",iColor,minE,maxE,runNumbers[iRun]);
TString title = Form("%s (%f MeV – %f MeV)",histName.Data(),minE,maxE,runNumbers[iRun]);
TString xAxis = Form("#chi^{2} / ndf");
TString yAxis = Form("# events / bin");

double bins[nBins+1];
double binWidth = (maxChiSq-minChiSq)/nBins;

for (int iBin=0; iBinSetLineColor(nColors[iColor]);
hHist->SetMarkerColor(nColors[iColor]);
hHist->GetXaxis()->SetTitle(xAxis);
hHist->GetYaxis()->SetTitle(yAxis);

for (int iEntry=0; iEntryGetEntries(); iEntry++) {
tree->GetEntry(iEntry);

if (nData != numDataPoints) continue;

bool passMinEnergyCut=false;
bool passMaxEnergyCut=false;

for (int iPnt=0; iPnt= minE && dX[iPnt] <= maxE) passMinEnergyCut=true;
if (dX[iPnt] = maxE) passMaxEnergyCut=true;
}

if (!passMinEnergyCut && !passMaxEnergyCut) continue;

hHist->Fill(dChiSq/nData);
}

hHist->Draw(iColor==0?””:”same”);

if (iColor==0) legend->AddEntry(hHist,”lower energy cut”,”lp”);
else legend->AddEntry(hHist,”upper energy cut”,”lp”);

}

c1->cd();

// if (!isCombined) legend->Draw();

c1->SaveAs(Form(“../plots/combined_%s.pdf”,c1->GetName()));
c1->SaveAs(Form(“../plots/%s.pdf”,c1->GetName()));

f -> Close();

delete c1;
delete legend;

delete hHist;

}

}
#ifndef PILOT_H_
#define PILOT_H_

const int run7 = -7;
const int run8 = -8;
const int run9 = -9;
const int run10 = -10;
const int run11 = -11;

const int numRuns = sizeof(runNumbers)/sizeof(runNumbers[0]);

const int numDataPoints = -7;

const int numFitBins = -7;
const int numFitBins8 = -7;

const double minEValue = -7.;
const double maxEValue = -7.;
const double chiSqMin = -7.;
const double chiSqMax = -7.;
const double chiSqMin8 = -7.;
const double chiSqMax8 = -7.;

#endif // PILOT_H_
#include “pilot.h”

void loadConstants() {

runNumbers[] { run7, run8, run9, run10, run11 };
numDataPoints[] { , , , , };
numFitBins[] { , , , , };
numFitBins8[] { , , , , };
minEValue[] { , , , , };
maxEValue[] { , , , , };
minEColor[] { , , , , };
maxEColor[] { , , , , };
minEnrgyCutVal[] { , , , , };
maxEnrgyCutVal[] { , , , , };
chisqMin[] { , , , , };
chisqMax[] { , , , , };
chisqMin8[] { , , , , };
chisqMax8[] { , , , , };

}
#ifndef PILOT_H_
#define PILOT_H_

// const int runsToAnalyze[] {run7};
// const int runsToAnalyze[] {run8};
// const int runsToAnalyze[] {run9};
// const int runsToAnalyze[] {run10};
const int runsToAnalyze[] {-11};

const int numRuns = sizeof(runsToAnalyze)/sizeof(runsToAnalyze[0]);

const int numDataPoints = -11;

const double minEValue =
const double maxEValue =
const double chisqMin
const double chisqMax
const double chisqMin8
const double chisqMax8

#endif // PILOT_H_
bblanchon/Pilot/plot.C
{
gROOT -> Reset();

gStyle -> SetOptStat(0);

const bool isCombined=true;

if (isCombined) {

const bool useBinnedChiSquare=true;

const bool includePlotForAllRuns=true;

const bool saveRootFiles=true;

int runsToPlot[]={-11,-10,-9,-8,-7};

int numRunsToPlot=sizeof(runsToPlot)/sizeof(runsToPlot[0]);

gROOT -> LoadMacro(“loadConstants.C”);
loadConstants();

gROOT -> LoadMacro(“rootplot.C”);
rootplot();

for(int iRun=0; iRun LoadMacro(“../build/rootlogon.C”);
// rootlogon();

gROOT -> LoadMacro(“../build/pilot.C”);

pilot();
}
// Copyright ©2023 The Things Network Foundation, The Netherlands

import type {
ApplicationSession,
ApplicationSessionRequest,
ApplicationSessionResponse,
} from ‘@ttn/core’;
import type {
ApplicationIdentifiers,
ApplicationMetadata,
ApplicationSessionEndpoint,
ApplicationSessionResponseIdentifier,
} from ‘@ttn/api-server’;
import type {
GetApplicationSessionsRequest,
GetApplicationSessionsResponse,
} from ‘@ttn/api-server/dist/application/v3/application-sessions’;
import type {
GetApplicationSessionRequest,
GetApplicationSessionResponse,
} from ‘@ttn/api-server/dist/application/v3/application-session’;
import type {
UpdateApplicationSessionRequest,
UpdateApplicationSessionResponse,
} from ‘@ttn/api-server/dist/application/v3/application-session’;
import type {
DeleteApplicationSessionRequest,
DeleteApplicationSessionResponse,
} from ‘@ttn/api-server/dist/application/v3/application-session’;
import type { HTTPError } from ‘@ttn/lw/lib/errors’;
import type { Logger } from ‘@tsed/logger’;

import type { Authorization } from ‘../authorization’;
import type {
BaseApplicationHandler,
BaseRequestHandler,
BaseResponseHandler,
} from ‘../base-handler’;
import type { Config } from ‘../config’;

export abstract class BaseApplicationSessionsHandler<
T extends BaseRequestHandler,
R extends BaseResponseHandler,
H extends BaseApplicationHandler,
L extends Logger
> extends BaseRequestHandler {
protected constructor(
protected readonly config: Config,
protected readonly logger: L,
protected readonly authorization: Authorization,
protected readonly applicationHandler: H,
) {
super(config);
}

public async get(
request: GetApplicationSessionsRequest,
): Promise<GetApplicationSessionsResponse> {
this.logger.info(‘Fetching application sessions’, request);

const applicationIdOrUrn: string | undefined =
request.identifiers.applicationId ?? request.identifiers.applicationUrn;

if (!applicationIdOrUrn) {
throw new HTTPError(400);
}

await this.authorization.authorizeReadApplications(
this.logger.child({ method: ‘get’ }),
request.identifiers.identityProviderId ?? undefined,
request.identifiers.tenantId ?? undefined,
request.identifiers.applicationId ?? undefined,
request.identifiers.applicationUrn ?? undefined,
request.identifiers.ownerIdentityProviderId ?? undefined,
request.identifiers.ownerTenantId ?? undefined,
request.identifiers.ownerUserId ?? undefined,
request.identifiers.ownerUserEmail ?? undefined,
request.identifiers.ownerUserIdentityProviderId ?? undefined,

true,

true,

true,

true,

true,

false,

false,

false,

false,

false,

false,

false,

false,

false,

false,

false,

false

/* TODO:
false
*/

/* TODO:
false
*/

/* TODO:
false
*/

/* TODO:
false
*/

/* TODO:
false
*/

/* TODO:
false
*/

/* TODO:
false
*/

/* TODO:
false
*/

/* TODO:
false
*/

/* TODO:
false
*/

/* TODO:
false
*/

/* TODO:
false
*/

/* TODO:
*/

public async getAll(): Promise {
this.logger.info(‘Fetching all application sessions’);

return this.config.applicationServer.getApplicationSessions()
// @ts-expect-error – fix me when the API supports this.
.then((applicationSessions) =>
applicationSessions.filter((applicationSession) => !!applicationSession.metadata),
);
}

public async getOne(
request: GetApplicationSessionRequest,
responseIdentifier?: ApplicationSessionResponseIdentifier,
session?: ApplicationSessionRequest,
metadata?: ApplicationMetadata | null | undefined,
endpoint?: ApplicationSessionEndpoint | null | undefined): Promise<
GetApplicationSessionResponse> {

this.logger.info(‘Fetching one application session’, request);

const applicationIdOrUrn