mirror of
https://gitlab.com/wgp/dougal/software.git
synced 2025-12-06 08:47:07 +00:00
279 lines
13 KiB
YAML
279 lines
13 KiB
YAML
# QC definition file
|
|
|
|
-
|
|
name: "Missing shots"
|
|
iterate: "sequences"
|
|
labels: [ "QC" ]
|
|
id: missing_shots
|
|
check: |
|
|
const sequence = currentItem;
|
|
let results;
|
|
if (sequence.missing_shots) {
|
|
results = {
|
|
shots: {}
|
|
}
|
|
const missing_shots = missingShotpoints.filter(i => !i.ntba);
|
|
for (const shot of missing_shots) {
|
|
results.shots[shot.point] = { remarks: "Missed shot", labels: [ "QC", "QCAcq" ] };
|
|
}
|
|
} else {
|
|
results = true;
|
|
}
|
|
|
|
results;
|
|
-
|
|
name: "Gun QC"
|
|
disabled: false
|
|
labels: [ "QC", "QCGuns" ]
|
|
children:
|
|
-
|
|
name: "Sequences without gun data"
|
|
iterate: "sequences"
|
|
id: seq_no_gun_data
|
|
check: |
|
|
shotpoints.some(i => i.meta?.raw?.smsrc) || "Sequence has no gun data"
|
|
-
|
|
name: "Missing gun data"
|
|
id: missing_gun_data
|
|
ignoreAllFailed: true
|
|
check: |
|
|
!!currentItem._("raw_meta.smsrc.guns")
|
|
? true
|
|
: "Missing gun data"
|
|
|
|
-
|
|
name: "No fire"
|
|
id: no_fire
|
|
check: |
|
|
// const currentShot = currentItem;
|
|
// const gunData = currentItem._("raw_meta.smsrc");
|
|
// (gunData && gunData.guns && gunData.guns.length != gunData.num_active)
|
|
// ? `Source ${gunData.src_number}: No fire (${gunData.guns.length - gunData.num_active} guns)`
|
|
// : true;
|
|
// Disabled due to changes in Smartsource software. It now returns all guns on every shot, not just active ones.
|
|
true
|
|
|
|
-
|
|
name: "Pressure errors"
|
|
id: pressure_errors
|
|
check: |
|
|
const pressure=11;
|
|
const gunData = currentItem._("raw_meta.smsrc");
|
|
const results = gunData &&
|
|
gunData
|
|
.guns
|
|
.filter(gun => ((gun[2] == gunData.src_number) && (gun[pressure]/parameters.gunPressureNominal - 1) > parameters.gunPressureToleranceRatio))
|
|
.map(gun =>
|
|
`source ${gun[2]}, string ${gun[0]}, gun ${gun[1]}, pressure: ${gun[pressure]} / ${parameters.gunPressureNominal} = ${(Math.abs(gun[pressure]/parameters.gunPressureNominal - 1)*100).toFixed(2)}% > ${(parameters.gunPressureToleranceRatio*100).toFixed(2)}%`
|
|
).join(" \n");
|
|
results && results.length
|
|
? results
|
|
: true
|
|
|
|
-
|
|
name: "Single gun / cluster"
|
|
children:
|
|
-
|
|
name: "Source depth"
|
|
id: source_depth
|
|
check: |
|
|
const currentShot = currentItem;
|
|
let _result_;
|
|
_depth=10;
|
|
const gunData = currentShot._("raw_meta.smsrc.guns");
|
|
if (!gunData) {
|
|
// We check for missing data elsewhere, so don't fail this test
|
|
_result_ = true
|
|
} else if (gunData.every(gun => Math.abs(gun[_depth]-parameters.gunDepth) <= parameters.gunDepthTolerance)) {
|
|
_result_ = true;
|
|
} else {
|
|
const bad_guns = gunData.filter(gun => Math.abs(gun[_depth]-parameters.gunDepth) > parameters.gunDepthTolerance).map(gun => {
|
|
return `source ${gun[2]}, string ${gun[0]}, gun ${gun[1]}, depth: ${gun[10]}`;
|
|
});
|
|
_result_ = `Depth error: ${bad_guns.join("; ")}`;
|
|
}
|
|
_result_
|
|
|
|
-
|
|
name: "Synchronisation (error)"
|
|
id: sync_error
|
|
check: |
|
|
const currentShot = currentItem;
|
|
const gunData = currentShot._("raw_meta.smsrc");
|
|
let result = [];
|
|
if (gunData && gunData.num_nofire == 0) {
|
|
|
|
// These are the indices into the gun array for the different
|
|
// values of interest.
|
|
const subarray = 0;
|
|
const aimpoint = 7;
|
|
const firetime = 8;
|
|
|
|
// We only care about the source which actually fired (or was supposed to)
|
|
const sourceFired = gunData.guns.filter(g => g[2] == gunData.src_number);
|
|
|
|
// Let us check if the average delta for each string is within spec
|
|
let subarrayAverages = [];
|
|
sourceFired.forEach(g => {
|
|
const idx = g[subarray]-1;
|
|
const delta = g[firetime]-g[aimpoint];
|
|
if (!subarrayAverages[idx]) {
|
|
subarrayAverages[idx] = [];
|
|
}
|
|
subarrayAverages[idx].push(delta);
|
|
});
|
|
subarrayAverages = subarrayAverages.map(s => s.reduce( (a, b) => a+b, 0 ) / s.length);
|
|
|
|
subarrayAverages.forEach((value, idx) => {
|
|
if (value > parameters.gunTimingSubarrayAverage) {
|
|
result.push(`Average delta error: string ${idx+1}: ${value.toFixed(2)} > ${parameters.gunTimingSubarrayAverage}`);
|
|
}
|
|
});
|
|
|
|
// Let us see about individual guns
|
|
sourceFired
|
|
.filter(gun => Math.abs(gun[firetime]-gun[aimpoint]) > parameters.gunTiming)
|
|
.forEach(gun => {
|
|
const value = Math.abs(gun[firetime]-gun[aimpoint]);
|
|
result.push(`Delta error: source ${gun[2]}, string ${gun[0]}, gun ${gun[1]}: ${value.toFixed(2)} > ${parameters.gunTiming}`);
|
|
});
|
|
}
|
|
if (result.length) {
|
|
result.join("; ");
|
|
} else {
|
|
// Either there were no error or gun data was missing, which we take care of elsewhere
|
|
true;
|
|
}
|
|
|
|
-
|
|
name: "Synchronisation (warning)"
|
|
id: sync_warn
|
|
check: |
|
|
const currentShot = currentItem;
|
|
const gunData = currentShot._("raw_meta.smsrc");
|
|
let result = [];
|
|
if (gunData && gunData.num_nofire == 0) {
|
|
|
|
// These are the indices into the gun array for the different
|
|
// values of interest.
|
|
const subarray = 0;
|
|
const aimpoint = 7;
|
|
const firetime = 8;
|
|
|
|
// We only care about the source which actually fired (or was supposed to)
|
|
const sourceFired = gunData.guns.filter(g => g[2] == gunData.src_number);
|
|
|
|
sourceFired
|
|
.filter(gun => Math.abs(gun[firetime]-gun[aimpoint]) >= parameters.gunTimingWarning && Math.abs(gun[firetime]-gun[aimpoint]) <= parameters.gunTiming)
|
|
.forEach(gun => {
|
|
const value = Math.abs(gun[firetime]-gun[aimpoint]);
|
|
result.push(`Delta warning: source ${gun[2]}, string ${gun[0]}, gun ${gun[1]}: ${parameters.gunTimingWarning} ≤ ${value.toFixed(2)} ≤ ${parameters.gunTiming}`);
|
|
});
|
|
}
|
|
if (result.length) {
|
|
result.join("; ");
|
|
} else {
|
|
// Either there were no error or gun data was missing, which we take care of elsewhere
|
|
true;
|
|
}
|
|
|
|
-
|
|
name: "Autofire"
|
|
id: autofire
|
|
check: |
|
|
const currentShot = currentItem;
|
|
let _result_;
|
|
_autofire=5;
|
|
const gunData = currentShot._("raw_meta.smsrc.guns");
|
|
if (!gunData) {
|
|
// We check for missing data elsewhere, so don't fail this test
|
|
_result_ = true;
|
|
} else if (gunData.every(gun => gun[_autofire] == false)) {
|
|
_result_ = true;
|
|
} else {
|
|
const bad_guns = gunData.filter(gun => gun[_autofire]).map(gun => {
|
|
return `source ${gun[2]}, string ${gun[0]}, gun ${gun[1]}, depth: ${gun[10]}`;
|
|
});
|
|
_result_ = `Depth error: ${bad_guns.join(";\n")}`;
|
|
}
|
|
_result_
|
|
|
|
-
|
|
name: "Centre of source preplot deviation (single shots)"
|
|
labels: [ "QC", "QCNav" ]
|
|
disabled: false
|
|
children:
|
|
-
|
|
name: "Crossline"
|
|
id: crossline
|
|
check: |
|
|
const currentShot = currentItem;
|
|
Math.abs(currentShot.error_i) <= parameters.crosslineError
|
|
|| `Crossline error (${currentShot.type}): ${currentShot.error_i.toFixed(2)} > ${parameters.crosslineError}`
|
|
|
|
-
|
|
name: "Inline"
|
|
id: inline
|
|
check: |
|
|
const currentShot = currentItem;
|
|
Math.abs(currentShot.error_j) <= parameters.inlineError
|
|
|| `Inline error (${currentShot.type}): ${currentShot.error_j.toFixed(2)} > ${parameters.inlineError}`
|
|
|
|
-
|
|
name: "Centre of source preplot deviation (moving average)"
|
|
labels: [ "QC", "QCNav" ]
|
|
children:
|
|
-
|
|
name: "Crossline"
|
|
iterate: "sequences"
|
|
parameters: [ "crosslineErrorAverage" ]
|
|
id: crossline_average
|
|
check: |
|
|
const currentSequence = currentItem;
|
|
//const i_err = shotpoints.filter(s => s.error_i != null).map(a => a.error_i);
|
|
const i_err = shotpoints.map(i =>
|
|
(i.errorfinal?.coordinates ?? i.errorraw?.coordinates)[0]
|
|
)
|
|
.filter(i => !isNaN(i));
|
|
|
|
if (i_err.length) {
|
|
const avg = i_err.reduce( (a, b) => a+b)/i_err.length;
|
|
avg <= parameters.crosslineErrorAverage ||
|
|
`Average crossline error: ${avg.toFixed(2)} > ${parameters.crosslineErrorAverage}`
|
|
} else {
|
|
`Sequence ${currentSequence.sequence} has no shots within preplot`
|
|
}
|
|
|
|
-
|
|
name: "Inline"
|
|
iterate: "sequences"
|
|
parameters: [ "inlineErrorRunningAverageShots" ]
|
|
id: inline_average
|
|
check: |
|
|
const currentSequence = currentItem;
|
|
const n = parameters.inlineErrorRunningAverageShots; // For brevity
|
|
const results = shotpoints.slice(n/2, -n/2).map( (shot, index) => {
|
|
const shots = shotpoints.slice(index, index+n).map(i =>
|
|
(i.errorfinal?.coordinates ?? i.errorraw?.coordinates)[1]
|
|
).filter(i => i !== null);
|
|
if (!shots.length) {
|
|
// We are outside the preplot
|
|
// Nothing to see here, move along
|
|
return true;
|
|
}
|
|
const mean = shots.reduce( (a, b) => a+b ) / shots.length;
|
|
return Math.abs(mean) <= parameters.inlineErrorRunningAverageValue || [
|
|
shot.point,
|
|
{
|
|
remarks: `Running average inline error: ${mean.toFixed(2)} > ${parameters.inlineErrorRunningAverageValue}`,
|
|
labels: [ "QC", "QCNav" ]
|
|
}
|
|
]
|
|
}).filter(i => i !== true);
|
|
|
|
results.length == 0 || results.join("\n");
|
|
results.length == 0 || {
|
|
remarks: "Sequence exceeds inline error running average limit",
|
|
shots: Object.fromEntries(results)
|
|
}
|