TheTechIdea OilGas - Developer guide User guide →

TheTechIdea.OilGas.Training

30 public types. Summaries come from the XML documentation of the compiled assembly.

TheTechIdea.OilGas.Training

TypeSummary
AnswerclassA trainee's answer to one question; the fields used depend on the question's type.
AttemptclassOne attempt at a scenario by a trainee. The answers are kept with the score so the attempt can be re-scored if the answer key is ever corrected.
AttemptQuestionclassThe score of one question as recorded.
AttemptRequestclassThe body of an attempt posted by the page.
CourseLibrarystatic classLoading and checking course files.
CoursePackclassA course: an ordered set of scenarios, one data file (name.course.json) beside the scenario files.
CourseResultclassA trainee's result for a course.
CourseScenarioResultclassOne scenario's part of a course result.
MapExhibitclassA map shown instead of a well: a surface gridded from picks, a bubble map, or wells and markers on a plan. Everything that shapes an answer is declared here - the grid, the method, the contour interval (or the number of lines aimed at) and the index frequency - so the right answer does not depend on the machine the trainee uses. Colours, theme and language still follow the environment. Picks should sit exactly on grid nodes: inverse-distance gridding then reproduces them there, and the grid's range is the data's range, which makes counts of contours computable by hand.
MapExhibitRenderstatic classChecking and drawing a map exhibit with the same views as every other map.
MapExhibitSolutionclassWhat the trainee is shown after answering: more labels, the picks' values, extra markers.
MapPointclassA point of a map exhibit: a pick, a marker or a bubble (metres in the exhibit's own frame).
MultiScoringenumHow a multiple-selection question is scored.
QuestionResultclassThe result of one question.
QuestionTypeenumKind of question.
ResultsLedgerclassThe record of trainees' attempts: scores with the answers behind them, the course results that follow (which attempt counts is training.attemptPolicy), re-scoring against a corrected answer key, JSON persistence, and CSV exports. Where it is stored is the host's decision - nothing is written anywhere by itself - and the only personal datum is the trainee identifier the host supplies.
SamplePacksstatic classSample course packs - one per toolbox (core schematic reading, well integrity, drilling, production, data management) - written as scenario and course files an instructor can read, change and extend. The numeric keys were calculated independently of the engines and are checked against them by the test suite; String) produces the files, so they are never out of step with the file format.
SampleWellRecordclassOne well record of the duplicate-wells sample exercise (plain data - the same facts feed the exercise text and its check against the reconciliation engine).
ScenarioclassA training exercise: a well shown on the views as evidence, questions about it, and the answer key - one data file, written by an instructor. The trainee's well and the solution's well are separate so the exercise never gives its answer away.
ScenarioLibrarystatic classLoading and checking scenario files.
ScenarioOptionclassOne option of a choice or multi question.
ScenarioQuestionclassOne question of a scenario; the fields used depend on Type.
ScenarioRenderstatic classRenders a scenario's well on the existing well views (the trainee's well, or the solution's after answering). By default the whole well is fitted on one paper-sized page - the environment's print scale (say 1:500) would make a deep well's picture tens of thousands of points tall, which is right for a plot and useless on a screen.
ScenarioResultclassThe result of a scenario.
ScenarioScoringstatic classScoring: a pure function of the scenario and the answers - the same answers always score the same. Choice: full or nothing. Multi: exact set, or (right picks - wrong picks) / right, never below zero. Depth and number: full within the tolerance (the answer converted to the question's unit); with a partialTolerance, points fall linearly to zero there; otherwise nothing. Each hint used costs the question's hintPenalty of its points. Unanswered scores zero. No rounding.
TrainingServerclassA small local web server for trainees: a page to choose a course, read a scenario, see the well, answer and get feedback. The scoring stays in the C# engine - the page only shows questions and sends answers. It serves trainee-safe copies of scenarios (never an answer key), sends the solution picture only in the reply to a submitted attempt, listens on loopback by default, refuses requests for another host or from another web origin (a page on the internet cannot post results to it), and exports results only with an admin key. It has no sign-in: the trainee name is typed, not verified - it is a practice tool, not an exam.
TrainingServerOptionsclassOptions of the training server.
TrainingServerSettingsclassSettings of the trainee web app.
TrainingSettingsclassSettings of the training toolbox (environment section toolboxes.training).
TrainingToolboxstatic classTraining toolbox: scenario-based exercises on the well views, scoring, course packs.

Answer class

A trainee's answer to one question; the fields used depend on the question's type.

MemberSummary
int HintsUsed { get; set; }Hints the trainee used on this question.
string Option { get; set; }The option chosen (choice).
List<string> Options { get; set; }The options chosen (multi).
string Unit { get; set; }Its unit; none means the question's own unit.
double? Value { get; set; }The value given (depth, number).

Attempt class

One attempt at a scenario by a trainee. The answers are kept with the score so the attempt can be re-scored if the answer key is ever corrected.

MemberSummary
Dictionary<string, Answer> Answers { get; set; }What the trainee answered, by question id.
string CourseId { get; set; }The course the attempt was made in, if any.
double Fraction { get; }Score / MaxScore.
double MaxScore { get; set; }Points available.
bool? Passed { get; set; }Pass or fail against the pass mark in force then; null when there was none.
List<AttemptQuestion> Questions { get; set; }Per-question scores.
string ScenarioId { get; set; }The scenario.
double Score { get; set; }Points earned.
string Trainee { get; set; }The trainee (a staff number or user name - whatever the host uses; nothing else about the person is recorded).
DateTime Utc { get; set; }When (UTC).

AttemptQuestion class

The score of one question as recorded.

MemberSummary
bool Answered { get; set; }Whether it was answered.
bool FullyCorrect { get; set; }Whether it earned every point it could (before hint penalties).
string Id { get; set; }Question id.
double Points { get; set; }Points available.
double Score { get; set; }Points earned.

AttemptRequest class

The body of an attempt posted by the page.

MemberSummary
Dictionary<string, Answer> Answers { get; set; }Answers by question id.
string CourseId { get; set; }The course the trainee is working in, if any.
string Trainee { get; set; }The trainee.

CourseLibrary static class

Loading and checking course files.

MemberSummary
static List<CoursePack> LoadConfigured(IReadOnlyList<Scenario> scenarios, List<string> problems)The courses of the environment's training.scenarioFolders (courses sit beside the scenarios they group).
static List<CoursePack> LoadFolder(string folder, IReadOnlyList<Scenario> scenarios, List<string> problems)Loads the *.course.json files of a folder; an unreadable file, a duplicate id or an unsound course is a problem, not an exception.
static List<string> Validate(CoursePack c, IEnumerable<Scenario> known)Problems with one course (empty = sound): ids, an unknown or repeated scenario, a pass mark out of range.

CoursePack class

A course: an ordered set of scenarios, one data file (name.course.json) beside the scenario files.

MemberSummary
string Description { get; set; }What the course covers.
string File { get; set; }The course file's path (set on load).
string Id { get; set; }Id (unique across course files).
double? PassMark { get; set; }Fraction of the course's points that passes it; overrides training.passMark for this course. None: the setting applies.
List<string> Scenarios { get; set; }Ids of the course's scenarios, in order.
string Title { get; set; }Title.
static CoursePack Load(string path)Reads a course file.
string ToJson()The course as JSON.

CourseResult class

A trainee's result for a course.

MemberSummary
bool Completed { get; }Whether every scenario of the course has been attempted.
string CourseId { get; set; }Course id.
double Fraction { get; }Score / MaxScore.
double MaxScore { get; }Points available over the whole course.
bool? Passed { get; set; }Passed: the course is complete and the fraction reaches the pass mark (the course's, else training.passMark); null when there is no pass mark.
List<CourseScenarioResult> Scenarios { get; set; }Per-scenario results in the course's order.
double Score { get; }Points earned (unattempted scenarios count zero).
string Trainee { get; set; }Trainee.

CourseScenarioResult class

One scenario's part of a course result.

MemberSummary
bool Attempted { get; set; }Whether the trainee has attempted it.
double MaxScore { get; set; }Points available.
string ScenarioId { get; set; }Scenario id.
double Score { get; set; }Points of the attempt that counts (0 when not attempted).

MapExhibit class

A map shown instead of a well: a surface gridded from picks, a bubble map, or wells and markers on a plan. Everything that shapes an answer is declared here - the grid, the method, the contour interval (or the number of lines aimed at) and the index frequency - so the right answer does not depend on the machine the trainee uses. Colours, theme and language still follow the environment. Picks should sit exactly on grid nodes: inverse-distance gridding then reproduces them there, and the grid's range is the data's range, which makes counts of contours computable by hand.

MemberSummary
List<MapPoint> Bubbles { get; set; }Bubbles: a value per well, the area proportional to it.
double CellSize { get; set; }Cell size (m).
double? ContourInterval { get; set; }The contour interval, in the value unit.
int GridNx { get; set; }Nodes east-west.
int GridNy { get; set; }Nodes north-south.
double GridX0 { get; set; }West edge of the grid (m).
double GridY0 { get; set; }South edge of the grid (m).
int Height { get; set; }Picture height.
int IndexEvery { get; set; }Every n-th contour is an index contour (0: none).
List<MapPoint> Markers { get; set; }Wells or places marked on the plan (their value is not used).
string Method { get; set; }inverseDistance (never beyond the data), minimumCurvature, or kriging (ordinary, with the variogram below, from every pick).
List<MapPoint> Points { get; set; }The picks a surface is gridded from (none, or at least three).
bool ShowContours { get; set; }Draw the contours.
bool ShowFill { get; set; }Colour the surface.
bool ShowLabels { get; set; }Label the index contours.
bool ShowValues { get; set; }Write each pick's value beside its name.
bool ShowWells { get; set; }Draw the picks as wells.
MapExhibitSolution Solution { get; set; }What is revealed after answering.
int? TargetContours { get; set; }Or the number of lines to aim at, from which a round interval is chosen (Heckbert).
string Title { get; set; }Title above the map.
bool Uncertainty { get; set; }Draw the kriging error standard deviation instead of the surface (the contour interval is then in the value's unit, as a deviation).
string ValueUnit { get; set; }Unit of the picks' values (shown in the legend).
string VariogramModel { get; set; }Kriging: spherical, exponential or gaussian.
double VariogramNugget { get; set; }Kriging: the nugget (the unit of the values, squared).
double? VariogramRange { get; set; }Kriging: the practical range (m).
double? VariogramSill { get; set; }Kriging: the sill, nugget included (the unit squared). Stated in the exhibit, never taken from the trainee's environment: a different variogram is a different answer.
int Width { get; set; }Picture width.
MapExhibit Stripped()A copy for the trainee's page: the title and size only. The page asks for the picture; it must not be given the data the picture hides.

MapExhibitRender static class

Checking and drawing a map exhibit with the same views as every other map.

MemberSummary
static ContourMapView Build(MapExhibit m, bool solution)The view of the exhibit; solution adds what is revealed after answering.
static Grid Grid(MapExhibit m)The grid the exhibit's picks make (its own spec, its own method).
static Grid Grid(MapExhibit m, string method, bool uncertainty)The grid the picks make by the given method (or, for kriging, its error standard deviation). Kriging is done here from every pick with the exhibit's own variogram, so no setting of the trainee's environment takes part.
static double? Interval(MapExhibit m, Grid g)The contour interval of the exhibit: stated, or the round interval for the number of lines aimed at; none when neither is given (the picture then follows the environment).
static List<string> Problems(MapExhibit m)Problems with an exhibit (empty = sound). The surface is gridded once to be sure it can be.
static byte[] ToPng(MapExhibit m, bool solution)The exhibit as a PNG image.
static string ToSvg(MapExhibit m, bool solution)The exhibit as SVG.

MapExhibitSolution class

What the trainee is shown after answering: more labels, the picks' values, extra markers.

MemberSummary
List<MapPoint> AddMarkers { get; set; }Markers added to the map.
double? ContourInterval { get; set; }The contour interval of the revealed picture, when its values are on another scale than the exhibit's.
string Method { get; set; }Grid the same picks another way: inverseDistance, minimumCurvature or kriging (with the exhibit's variogram) - the surface that was not shown, to compare.
bool? ShowLabels { get; set; }Label the index contours (when they were not before).
bool? ShowValues { get; set; }Write each pick's value beside its name.
string Title { get; set; }The title of the revealed picture, when it shows something other than the exhibit (another method, the surface rather than its uncertainty): a picture must never be captioned as another.
bool? Uncertainty { get; set; }Show (true) or hide (false) the kriging error standard deviation instead of the surface.

MapPoint class

A point of a map exhibit: a pick, a marker or a bubble (metres in the exhibit's own frame).

MemberSummary
string Label { get; set; }Name shown beside it.
double Value { get; set; }The value (a depth for a pick, the size of a bubble).
double X { get; set; }Easting (m).
double Y { get; set; }Northing (m).

MultiScoring enum

How a multiple-selection question is scored.

MemberSummary
ExactFull points only for exactly the right set.
PartialPoints for each right pick less each wrong one, never below zero.

QuestionResult class

The result of one question.

MemberSummary
bool Answered { get; set; }Whether it was answered at all.
string Explanation { get; set; }The worked reasoning, if the author gave one.
string Feedback { get; set; }Feedback (the author's, or a default).
bool FullyCorrect { get; set; }Whether it earned every point it could (before hint penalties).
string Id { get; set; }Question id.
double Points { get; set; }Points available.
double Score { get; set; }Points earned.

QuestionType enum

Kind of question.

MemberSummary
ChoiceOne option out of several (which barrier element failed).
MultiAny number of options out of several (which elements are impaired).
DepthA depth, within a tolerance (pick the top of a formation).
NumberA number, within a tolerance (a ratio, a separation factor).

ResultsLedger class

The record of trainees' attempts: scores with the answers behind them, the course results that follow (which attempt counts is training.attemptPolicy), re-scoring against a corrected answer key, JSON persistence, and CSV exports. Where it is stored is the host's decision - nothing is written anywhere by itself - and the only personal datum is the trainee identifier the host supplies.

MemberSummary
List<Attempt> Attempts { get; set; }All attempts, in the order recorded.
string AttemptsCsv()One row per attempt (invariant numbers, ISO times).
Attempt Counted(string trainee, string scenarioId)The attempt of a scenario that counts for a trainee under training.attemptPolicy; null when there is none.
List<CourseResult> Course(CoursePack course, IReadOnlyList<Scenario> scenarios)The results of every trainee who has an attempt in the course.
CourseResult Course(string trainee, CoursePack course, IReadOnlyList<Scenario> scenarios)A trainee's result for a course.
static string CourseResultsCsv(IEnumerable<CourseResult> results)One row per trainee and course.
static ResultsLedger FromJson(string json)Reads a ledger from JSON.
string QuestionsCsv()One row per question of every attempt.
Attempt Record(string trainee, Scenario scenario, IReadOnlyDictionary<string, Answer> answers, string courseId = null, double? passMark = null)Scores the answers and records the attempt.
static ScenarioResult Rescore(Attempt attempt, Scenario scenario)Scores an attempt's stored answers again against a scenario (after its answer key was corrected); the recorded attempt is not changed.
string ToJson()The ledger as JSON.

SamplePacks static class

Sample course packs - one per toolbox (core schematic reading, well integrity, drilling, production, data management) - written as scenario and course files an instructor can read, change and extend. The numeric keys were calculated independently of the engines and are checked against them by the test suite; String) produces the files, so they are never out of step with the file format.

MemberSummary
static IReadOnlyList<(string, SampleWellRecord, SampleWellRecord, bool)> DuplicatePairs { get; }The pairs of the duplicate-wells exercise: a label, two records, and whether they are the same well.
const double DuplicateToleranceMetres = 100Location tolerance assumed by the duplicate-wells exercise (stated in its text).
static (WellModel, AnnulusInfo) AnnulusWell()The well of the annulus-pressure exercise: tubing, 7 in production casing and 9 5/8 in intermediate casing, all L80; annulus A is between the tubing and the 7 in casing.
static WellModel BarrierWell()The well of the well-integrity-categories exercise: the primary envelope has a failed packer, the secondary is intact.
static WellModel BuildSectionWell(bool solution)The trainee's well of the build-section exercise (no survey); the solution well adds the planned trajectory.
static WellModel CasingProgramWell()The well of the casing-program exercise.
static WellModel CorrodedJointWell()The well of the corroded-joint exercise: 7 in 29 lb/ft L80 casing.
static WellModel HookLoadWell()The well of the hook-load exercise: vertical to 2 000 m.
static List<MapPoint> StructurePicks()The picks of the map exercises: eighteen wells on the nodes of a 100 m grid, on a smooth cone round W-9: depth below sea level = 2 210 + 380 r, where r = sqrt(((x - 1000) / 1200)^2 + ((y - 1200) / 1039.23)^2) (rounded to the metre). r is 0 at W-9, the shallowest at 2 210 m, and exactly 1 at W-3, the deepest at 2 590 m; every other pick is inside the ellipse (r below 1). On a node inverse-distance gridding returns the pick itself, so the grid's range is exactly 380 m - which is what makes the counts of contours computable by hand - and the picks follow one smooth surface, so the map has no bullseyes round the wells.
static List<string> Write(string folder)Writes the sample packs (scenario files, well files and course files) to a folder; returns the file names.

SampleWellRecord class

One well record of the duplicate-wells sample exercise (plain data - the same facts feed the exercise text and its check against the reconciliation engine).

MemberSummary
string Field { get; set; }Field.
string Id { get; set; }Id in the source.
double Latitude { get; set; }Latitude.
double Longitude { get; set; }Longitude.
string Name { get; set; }Well name.
string Source { get; set; }Source system.
string Uwi { get; set; }UWI / API number.

Scenario class

A training exercise: a well shown on the views as evidence, questions about it, and the answer key - one data file, written by an instructor. The trainee's well and the solution's well are separate so the exercise never gives its answer away.

MemberSummary
string Course { get; set; }Course the exercise belongs to (optional).
string DepthUnit { get; set; }The depth unit the well is drawn in: "m" or "ft". Without it the picture follows the environment's depth unit - so an exercise that asks for depths in metres should say "m", or a trainee reads feet off the picture. Validation checks depth questions against it.
string Directory { get; set; }Folder the scenario file is in (set on load; not part of the file).
string File { get; set; }The scenario file's path (set on load; not part of the file).
string Id { get; set; }Id (unique across scenario files).
string Instructions { get; set; }What the trainee is asked to do.
string Level { get; set; }Level, e.g. basic / intermediate / advanced (free text).
MapExhibit Map { get; set; }A map shown instead of a well (a scenario shows one exhibit: a well or a map).
double MaxScore { get; }Total points.
List<ScenarioQuestion> Questions { get; set; }The questions.
string SolutionWell { get; set; }The well shown after answering, with the answer visible (optional; relative to this file).
string Title { get; set; }Title.
string Well { get; set; }The well shown to the trainee (a well model JSON file, relative to this file).
static Scenario Load(string path)Reads a scenario file.
WellModel LoadWell(bool solution = false)Loads the trainee's well (or the solution's when asked and present - otherwise the trainee's well again: there is nothing more to reveal).
string ToJson()The scenario as JSON (for authoring tools).
Scenario WithoutAnswers()A copy safe to show a trainee: the answer keys, tolerances, feedback, explanations and the solution well are removed. A scenario file contains its answers, so a front end must present this copy - never the file itself - until the trainee has answered.

ScenarioLibrary static class

Loading and checking scenario files.

MemberSummary
static List<Scenario> LoadConfigured(List<string> problems)The scenarios of the environment's training.scenarioFolders (relative to the environment file).
static List<Scenario> LoadFolder(string folder, List<string> problems)Loads every scenario file (*.scenario.json) of a folder, not its subfolders - well files may sit beside them as plain .json. A file that cannot be read, a duplicate id, or an unsound scenario is a problem, not an exception.
static List<string> Validate(Scenario s)Problems with one scenario (empty = sound): ids, options, answer keys, tolerances, and that its well files exist and differ.

ScenarioOption class

One option of a choice or multi question.

MemberSummary
string Id { get; set; }Id the answer refers to.
string Text { get; set; }Text shown.

ScenarioQuestion class

One question of a scenario; the fields used depend on Type.

MemberSummary
string CorrectFeedback { get; set; }Shown when the answer is fully right (default text otherwise).
string CorrectOption { get; set; }The right option (choice).
List<string> CorrectOptions { get; set; }The right options (multi).
double? CorrectValue { get; set; }The right value (depth, number).
string Explanation { get; set; }The worked reasoning, shown after the trainee has answered.
string Hint { get; set; }A hint the trainee may ask for.
double HintPenalty { get; set; }Fraction of the question's points each hint used costs (0 = hints are free); policy of the author.
string Id { get; set; }Id (unique within the scenario).
string IncorrectFeedback { get; set; }Shown when it is not (default text otherwise).
List<ScenarioOption> Options { get; set; }Options (choice, multi).
double? PartialTolerance { get; set; }Optional: beyond the tolerance, points fall linearly to zero at this distance. Without it a miss earns nothing.
double Points { get; set; }Points the question is worth.
string Prompt { get; set; }The question.
MultiScoring Scoring { get; set; }How a multi question is scored (default exact).
double? Tolerance { get; set; }An answer this close to the right value (in Unit) earns full points.
QuestionType Type { get; set; }Kind.
string Unit { get; set; }Unit of the right value (depth: a length unit; number: any unit of the environment, or none for a pure number).

ScenarioRender static class

Renders a scenario's well on the existing well views (the trainee's well, or the solution's after answering). By default the whole well is fitted on one paper-sized page - the environment's print scale (say 1:500) would make a deep well's picture tens of thousands of points tall, which is right for a plot and useless on a screen.

MemberSummary
static WellboreDocument Document(Scenario scenario, bool solution, List<string> warnings)The view document of the scenario's well.
static WellborePrintOptions FitToPage()The default layout of an exercise picture: the whole well fitted on one page.
static byte[] ToPng(Scenario scenario, bool solution = false)The scenario's well as a PNG image, fitted on one page.
static byte[] ToPng(Scenario scenario, bool solution, WellborePrintOptions options)The scenario's well as a PNG image with the given print layout.
static string ToSvg(Scenario scenario, bool solution = false)The scenario's well as SVG, fitted on one page, drawn by the same code as every other well view.
static string ToSvg(Scenario scenario, bool solution, WellborePrintOptions options)The scenario's well as SVG with the given print layout (for example a fixed scale).

ScenarioResult class

The result of a scenario.

MemberSummary
double Fraction { get; }Score / MaxScore.
double MaxScore { get; }Points available.
bool? Passed { get; set; }Pass or fail against training.passMark; null when no pass mark is set.
List<QuestionResult> Questions { get; }Per-question results, in the scenario's order.
string ScenarioId { get; set; }Scenario id.
double Score { get; }Points earned.

ScenarioScoring static class

Scoring: a pure function of the scenario and the answers - the same answers always score the same. Choice: full or nothing. Multi: exact set, or (right picks - wrong picks) / right, never below zero. Depth and number: full within the tolerance (the answer converted to the question's unit); with a partialTolerance, points fall linearly to zero there; otherwise nothing. Each hint used costs the question's hintPenalty of its points. Unanswered scores zero. No rounding.

MemberSummary
static ScenarioResult Score(Scenario scenario, IReadOnlyDictionary<string, Answer> answers)Scores the answers (question id to answer); an id the scenario does not have is an error, never ignored.

TrainingServer class

A small local web server for trainees: a page to choose a course, read a scenario, see the well, answer and get feedback. The scoring stays in the C# engine - the page only shows questions and sends answers. It serves trainee-safe copies of scenarios (never an answer key), sends the solution picture only in the reply to a submitted attempt, listens on loopback by default, refuses requests for another host or from another web origin (a page on the internet cannot post results to it), and exports results only with an admin key. It has no sign-in: the trainee name is typed, not verified - it is a practice tool, not an exam.

MemberSummary
TrainingServer(IReadOnlyList<Scenario> scenarios, IReadOnlyList<CoursePack> courses, ResultsLedger ledger, TrainingServerOptions options = null)Creates the server (call Start).
string Url { get; }The address the server listens on (set by Start).
void Dispose()Stops the server.
static bool IsLoopback(string host)Whether an address is a loopback address (a server listening elsewhere should be put behind sign-in).
void Start()Starts listening.

TrainingServerOptions class

Options of the training server.

MemberSummary
string AdminKey { get; set; }Key that unlocks the result exports (sent in the X-Admin-Key header). None: the exports are switched off.
string Host { get; set; }Address to listen on; the environment's (loopback unless it says otherwise: the server has no sign-in).
string LedgerPath { get; set; }File the ledger is saved to after every attempt (none: kept in memory only).
int MaxBodyBytes { get; set; }Largest request body accepted.
int Port { get; set; }Port; 0 picks a free one. From toolboxes.training.server.port unless set.
int TraineeNameMaxLength { get; set; }Longest trainee name accepted (characters).

TrainingServerSettings class

Settings of the trainee web app.

MemberSummary
string Bind { get; set; }Address to listen on. Loopback: the app has no sign-in, so it is for the machine it runs on unless you decide otherwise.
int MaxBodyBytes { get; set; }Largest request body accepted (bytes).
int Port { get; set; }Port to listen on (0 picks a free one).
string ResultsFile { get; set; }The results file (relative to the environment file).
int TraineeNameMaxLength { get; set; }Longest trainee name or staff number accepted (characters).

TrainingSettings class

Settings of the training toolbox (environment section toolboxes.training).

MemberSummary
string AttemptPolicy { get; set; }Which attempt of a scenario counts towards a course result: "latest", "best" or "first". A policy of the training department - "latest" is the default, the plainest reading of what a trainee scored last.
double? PassMark { get; set; }Fraction of the points that passes a scenario (e.g. 0.7). No default: a pass mark is the training department's policy; without one a result reports its score only.
List<string> ScenarioFolders { get; set; }Folders (relative to the environment file) holding scenario files (.json); every scenario found is loaded. Empty: none.
TrainingServerSettings Server { get; set; }The trainee web app (wellbore-config training-serve): where it listens and what it accepts. Command-line options override these for one run.

TrainingToolbox static class

Training toolbox: scenario-based exercises on the well views, scoring, course packs.

MemberSummary
static TrainingSettings Settings { get; }The toolbox's settings in the current environment.
const string Name = "training"Section name in the environment's toolboxes.
static void Register()Registers the toolbox with the environment (idempotent); hosts call it at start-up, the toolbox's own entry points call it too.