Have you ever wondered what happens when a skilled software, electrical, or control systems engineer opens a nuclear plant simulator for the first time? You instantly recognize the generators, turbines, and grid connection. But then you hit a screen labeled Reactor Kinetics, a value called pcm, or a button marked SCRAM, and find yourself in uncharted territory.

From Grid to Core is written specifically to bridge that gap.

Unlike traditional nuclear textbooks that begin with dense atomic physics and hand down axioms from page one, this book takes a deliberately reversed engineering approach. We start at the 400 kV switchyard—ground you already own as an engineer—and walk upstream, room by room, until we reach the nuclear core. Every new concept is explained using the language you already speak: control loops, negative feedback paths, numerical solvers, and component degradation.

Try the Live Software Demo Now!

This book is a hands-on, deeply integrated companion guide to NEXUS-1, a fully interactive, browser-based nuclear plant operator console and digital twin.

No server, no installation, and zero setup required. The entire simulator runs locally in your browser. You can load it right now, play with the control rods, monitor the core parameters, and watch the physics engines calculate the math live:

👉 Play with the Live Simulator: https://gregory82gr.github.io/Nexus-1-phase-0/

What’s Under the Hood? (The Engineering Blueprint)

This is not a cosmetic layout or a sci-fi game. The companion book explains the literal software architecture and mathematical implementations executing live inside the NEXUS-1 Phase 0 demonstrator:

• The Point-Kinetics Engine: Learn how the simulator solves the standard reactor dynamics equations using 6 delayed-neutron precursor groups (U-235 data) and a 12-group decay heat afterheat model.
• The Closed-Loop Feedback: Explore how the system self-regulates through physical negative feedback loops: Doppler gain (fuel temperature), moderator gain (coolant temperature), and Xenon-135 worth.
• Solver Validation & Verification: See how the live numerical integration scheme (built to handle stiff differential equations) is verified in real-time against textbook closed-form equations like the inhour equation and prompt-jump formula.
• Advanced Modules: Dive into the architecture of predictive diagnostics, automated alarm flood correlation using causal fault-propagation graphs, and interpretable reinforcement learning (Q-learning) for autonomous rod control.

How Every Chapter is Structured

To ensure maximum utility, every single chapter follows a predictable engineering blueprint:

1. What You Already Know: The structural bridge from your existing enterprise software, electronics, or control systems background.
2. The Concept: A clear, prose explanation of the system's real-world physics.
3. See it in NEXUS-1: Direct guidance on where and how that concept lives live on your simulator screen.
4. Try It (Drills): Guided interactive drills to manipulate the console (e.g., triggering a +10 pcm step or a post-shutdown Xenon transient) and analyze the telemetry response.
5. Honest Boundary: A completely transparent look at exactly where the Phase 0 simulator simplifies engineering realities and where it faithfully integrates exact textbook physics.

👤 Who This Is For

This project requires zero prior nuclear knowledge. If you are fluent in software engineering, systems design, control theory, or basic engineering, and you want to demystify how a modern Pressurized Water Reactor (PWR) works by driving a real, live-computed simulator, this book is built for you.

Author: Grigorios Kyriakos Agathangelidis.

Greek name: Γρηγόριος Κυριάκος Αγαθαγγελίδης.

Also searchable as: Αγαθαγγελίδης Γρηγόριος, Αγαθαγγελιδης Γρηγοριος, Grigorios Agathangelidis.

Something trips. In the next four seconds, two hundred alarms fire. The board is a wall of red, every annunciator is screaming, and the one alarm that actually matters — the cause — is buried somewhere in the flood, indistinguishable from the two hundred consequences stacked on top of it. "Loudest alarm wins" is how that ends badly.

And now there's a new temptation: point a large language model at the flood and ask it what happened. It will give you a fluent, confident, beautifully-worded answer — and you will have no way to know whether any of it is true.

From Flood to Cause is written to resolve both problems at once, around a single governing principle:

The engine decides, the model explains.

A deterministic causal engine — not a neural network — identifies the root cause from an engineered fault-propagation graph and corroborating telemetry. The language model never diagnoses, never ranks, never votes. It runs strictly downstream, in an advisory-only role, to put the engine's conclusion into cited language a person can audit — and it abstains the moment grounding is absent. This book shows you, end to end, how to build a system like that and why every piece is where it is.

Try the Live Console Now!

This is a hands-on companion to NEXUS-1, a fully interactive, browser-based root-cause console. No server, no installation, zero setup. Every incident, graph node, edge weight, and delay window in the book is drawn from this live system — nothing is invented. Load it, trigger a cascade, and watch the engine collapse the flood to a single origin:

👉 Play with the live console: https://gregory82gr.github.io/Nexus-1-phase-0/

What's Under the Hood? (The Engineering Blueprint)

This is not a prompt-engineering listicle. It's the literal architecture and the discipline that makes an LLM safe to put near an operating decision:

• The Engineered Causal Graph — backbone, learned-weight, artefact, and rejected edges; delay windows; how the engine separates the one origin from the cascade it caused.
• The Grounding Triangle — database, telemetry, and documentation as three independent witnesses, assembled into a single Unified Context.
• The Anti-Hallucination Engine (H1–H10) — ten concrete controls, each with a worked example: the closed-world contract, the grounding gate, entity and citation validation, structured output, forced abstention, and a hash-chained audit trail.
• What the Model May Read — building a RAG corpus you can trust: hybrid retrieval, retrieval evaluation, and corpus governance.
• The Reference Stack — OpenTelemetry, Prometheus, Grafana, and Microsoft Semantic Kernel used as a constrained orchestration layer (explicitly not an agent that picks its own tools), implemented in C# and SQL Server 2025 with vector retrieval.
• Three Case Studies from the Console — a cascade, an EMI artefact, and a QA escape, each diagnosed and explained from real console data.
• Five Developer Appendices (F–J) — copy-pasteable quickstart: project layout, the Ollama Modelfile, the closed-world prompt and validation schema, observability wiring, and a CI evaluation harness — everything needed to stand the explain side up on your own machine.

How Every Chapter Is Structured

Every chapter follows the same engineering blueprint:

1. What You Already Know — the bridge from your existing software, data, or control-systems background to the concept at hand.
2. The Concept — a clear, prose explanation of the mechanism and why it exists.
3. One Figure — a single precise diagram, drawn from real console data, never decoration.
4. See It in NEXUS-1 — exactly where that concept lives on the live console screen.
5. Honest Boundary — a transparent statement of what the Phase-0 system genuinely does versus where it simplifies, including the limits of the controls themselves. No claim that something works better than it does.

👤 Who This Is For

If you are a software, data, control-systems, or SRE engineer — comfortable with C#/.NET, SQL, and systems design — and you are being asked to put a language model somewhere its answers actually matter, this book is built for you. It assumes no background in alarm management or nuclear engineering; it builds the reasoning up from the screens and the code. It is the diagnostic-and-AI companion to From Grid to Core, and it stands entirely on its own.

Author: Grigorios Kyriakos Agathangelidis
Greek name: Γρηγόριος Κυριάκος Αγαθαγγελίδης
Also searchable as: Αγαθαγγελίδης Γρηγόριος, Αγαθαγγελιδης Γρηγοριος, Grigorios Agathangelidis.

Power is drifting below target.

An operator can correct it. A conventional controller can correct it. A page of carefully tuned if-rules can probably correct it too.

But what happens when the operating conditions change, the assumptions behind those rules begin to break down, and the trade-off between accuracy, stability, and actuator wear becomes too complex to tune by hand?

And now there is a new temptation: hand the problem to a machine-learning model and let it learn for itself.

It will produce recommendations.

It may even produce excellent recommendations.

But if the recommendation affects a control system, one question matters more than all the others:

Can you explain exactly why it chose that action?

From Trial to Policy is written around a single governing principle:

The agent learns, the engineer understands.

This book shows how to build a reinforcement-learning agent that remains completely readable after training. No hidden layers. No black-box neural network. No mysterious weights distributed across millions of parameters. The result of learning is a simple, inspectable Q-table: a finite set of states, a finite set of actions, and a number describing the long-term value of each possible choice.

Every recommendation can be traced.

Every action can be explained.

Every learned policy can be read directly by a human.

The book takes reinforcement learning apart piece by piece and rebuilds it from first principles. Agent. Environment. Reward. State. Action. Exploration. Policy. Nothing is assumed, and nothing is hidden behind mathematical jargon. Each concept is mapped directly to C#, .NET, SQL Server, and a working industrial-style control problem.

Try the Live Console Now!

This is a hands-on companion to NEXUS-1, a fully interactive browser-based optimization console. No installation, no server, zero setup. Every state, action, reward curve, policy grid, and training result shown in the book comes directly from this live system.

Open the console, start training, and watch the policy emerge from thousands of episodes of trial and error.

👉 Play with the live console:
https://gregory82gr.github.io/Nexus-1-phase-0/

What's Under the Hood? (The Engineering Blueprint)

This is not a machine-learning theory book. It is the architecture of a working, interpretable reinforcement-learning system.

• The Control Problem — how a familiar feedback loop becomes a learning problem.

• Agent, Environment, Reward — the three building blocks of reinforcement learning, mapped directly to C# interfaces and classes.

• The Digital Twin Training Ground — why learning happens inside a fast surrogate model rather than on the real system.

• State and Action Design — turning a continuous world into 35 readable states and five discrete control actions.

• The Q-Table — the entire learned policy stored as 175 auditable numbers.

• The Learning Algorithm — Q-learning explained step by step, arithmetic by arithmetic, without requiring a machine-learning background.

• Exploration versus Exploitation — why an agent must sometimes try apparently bad actions in order to discover better policies.

• Policy Interpretation — reading the learned table directly and understanding why every decision was selected.

• Advisory Deployment — how a learned policy becomes operational advice while remaining bounded, inspectable, and human-approved.

• C# and SQL Server Implementation — complete architecture, persistence model, training workflow, reward logging, and policy storage.

How Every Chapter Is Structured

Every chapter follows the same engineering blueprint:

What You Already Know — connecting new reinforcement-learning concepts to familiar software-engineering ideas.

The Concept — a precise explanation of the mechanism and why it exists.

One Figure — a focused diagram illustrating the idea being discussed.

See It in NEXUS-1 — exactly where the concept appears in the live console.

Honest Boundary — a transparent discussion of limitations, assumptions, and what the demonstration genuinely does versus what it deliberately simplifies.

No magic.

No hype.

No claims that learning systems are smarter than they are.

Only mechanisms that can be inspected, explained, and reproduced.

👤 Who This Is For

If you are a C#/.NET developer, software architect, controls engineer, simulation engineer, or systems designer who has never studied reinforcement learning but wants to understand how a real learning agent works, this book is for you.

It assumes you are comfortable with software development and basic engineering reasoning. It assumes no prior knowledge of machine learning, neural networks, statistics, or control theory.

By the final chapter you will be able to open a policy table, inspect every learned action, and understand exactly how trial and error became a decision-making strategy.

This volume is the reinforcement-learning companion to NEXUS-1 and the third book in the companion series following From Grid to Core and From Flood to Cause.

Author: Grigorios Kyriakos Agathangelidis
Greek name: Γρηγόριος Κυριάκος Αγαθαγγελίδης
Also searchable as: Αγαθαγγελίδης Γρηγόριος, Αγαθαγγελιδης Γρηγοριος, Grigorios Agathangelidis.

About the Book

Have you ever worked on a system where the code, the database, and the business language slowly stopped agreeing with each other?

A table says one thing.
A service says another.
A controller knows too much.
An entity is only an anemic bag of properties.
A “rule” lives in five different places.
And everyone uses the same word — Unit, Event, Case, Model, Policy — with slightly different meanings.

From Domain to Twin is written to solve that problem from the ground up.

This book teaches Domain-Driven Design from zero, in plain human language, for mid-level .NET developers who already understand C#, EF Core, SQL tables, APIs, services, DTOs, and application structure, but have never had DDD explained slowly and practically.

It does not begin with abstract theory. It begins with the normal developer problems you already know: confusing models, unclear service boundaries, misplaced business rules, overgrown DbContext classes, fragile database relationships, and systems where nobody is quite sure who owns the truth.

Then it introduces DDD step by step.

You will learn what a domain is, what a model is, why a shared language matters, how entities differ from value objects, why aggregates protect consistency, what repositories should and should not do, where application services belong, what domain events really mean, and how bounded contexts prevent one word from meaning five different things.

But the book does not stop at definitions.

The second half applies every idea to NEXUS-1, a browser-based industrial digital-twin demonstrator. NEXUS-1 contains a plant/fleet model, instrumentation, alarms, root-cause reasoning, digital-twin snapshots, reinforcement-learning recommendations, audit, compliance, reporting, and EF Core persistence. That makes it a much richer DDD example than the usual shopping cart, invoice, or order-processing system.

Through NEXUS-1, the book shows how DDD can organize a serious engineering-style platform:

• A Unit is not just a string or dropdown value; it is part of the plant domain.
• A Signal is not an alarm; it is measured instrumentation data.
• An AlarmEvent is not a root cause; it is a domain fact that something crossed a configured condition.
• A RootCauseCase protects hypotheses, evidence, rejected candidates, and final verdicts.
• A TwinDivergence is the system admitting that the model and measured reality disagree.
• A reinforcement-learning Recommendation is not a command; it is advisory output that must stay inside its boundary.
• An AuditEntry is not log noise; it is part of the accountability story.

The final part turns the model into implementation. It connects bounded contexts to project structure, SQL schemas, EF Core mappings, aggregate roots, owned value objects, domain methods, application services, repositories, read models, reporting screens, and audit trails.

This book is not a theoretical contribution to DDD. It is a practical learning journey: DDD explained from first principles, then applied to a complex NEXUS-1 digital-twin architecture until the meaning of the system becomes visible.

What You Will Learn

• How to understand DDD without academic language
• How to distinguish entities, value objects, aggregates, services, repositories, and events
• How to decide where business rules belong
• How bounded contexts prevent language and ownership confusion
• How to define a ubiquitous language for a real system
• How to map DDD ideas to C#, EF Core, SQL Server, and application services
• How to separate commands, events, recommendations, decisions, and read models
• How to think about audit and traceability as part of the domain, not as an afterthought
• How NEXUS-1 can be read as a domain model, not merely as a dashboard

Who This Is For

This book is for software developers, especially .NET developers, who want a practical entry point into Domain-Driven Design.

You do not need prior DDD knowledge. You only need normal development experience: classes, services, controllers, databases, APIs, DTOs, and business rules.

It is especially useful if you have ever asked:

• Where should this rule live?
• Is this object an entity or a value object?
• Is this service doing too much?
• Should this table be part of the same context?
• Is this event a fact, a command, or just a log?
• Why does the database model feel different from the code model?
• How do I stop a large system from becoming a pile of tables and services?

The NEXUS-1 Boundary

NEXUS-1 is a demonstration and educational platform. It is not connected to any real plant, not safety-class software, not certified operational code, and not intended for use in any real nuclear facility.

In this book, NEXUS-1 is used as a rich software-architecture case study: a way to explain how domain language, boundaries, rules, data, and decisions can be organized in a complex industrial-style system.

Author: Grigorios Kyriakos Agathangelidis
Greek name: Γρηγόριος Κυριάκος Αγαθαγγελίδης
Also searchable as: Αγαθαγγελίδης Γρηγόριος, Αγαθαγγελιδης Γρηγοριος, Grigorios Agathangelidis.

Have you ever opened the database behind a system you thought you understood, and found two answers where you expected one? You recognize the tables — Unit, Signal, WorkOrder — but then you hit a folder of EF Core migrations that doesn't quite match the SQL someone else wrote by hand, a DbContext with shadow foreign keys nobody named, and a quiet, nagging question: which one of these is actually telling the truth about my data?

From Table to Twin is written specifically to answer that question.

Unlike most Entity Framework books, which hand you a DbContext on page one and never look back, this book takes a deliberately two-path approach. You build the same industrial schema twice — once by hand in SQL Server, reverse-engineered into C#; once from C# with Code First, generating its own migrations — and then you put the two builds side by side. Where Scaffold-DbContext and Fluent API disagree on naming, shadow keys, and inferred relationships, this book doesn't pick a winner and move on. It prints the disagreement, in a dedicated reconciliation chapter, and shows you which one to trust and when.

Try the Live Software Demo Now!

This book is a hands-on, deeply integrated companion guide to NEXUS-1, the same fully interactive, browser-based digital-twin console used throughout the series — except this volume is the one that finally writes down where all of it actually lives.

No server, no installation, and zero setup required. Open the console, and every schema named in this book, every query quoted, and every row counted can be counted again, live, in your browser:

👉 Play with the Live Console: https://gregory82gr.github.io/Nexus-1-phase-0/

What's Under the Hood? (The Schema Blueprint)

This is not a toy Blog/Post sample database. The companion book walks the literal data backbone of an industrial nuclear-plant digital twin — a schema plausibly past two hundred tables, built to the same standard throughout:

• One schema, seventeen bounded contexts. Reactor Fleet, Instrumentation, Alarm Management, Digital Twin, Root Cause Analysis, Reinforcement Learning, and the rest — every sector the first three NEXUS-1 volumes already wrote to, finally given a single, coherent home.
• Two builds, one model. Part 1 authors the database by hand in SQL Server — schemas, keys, indexes, constraints, views — then reverse-engineers it with Scaffold-DbContext. Part 2 rebuilds the identical model from C#: configuration classes, value converters, owned types, and generated migrations.
• The uniform lookup-table generator. Rather than forty near-identical CREATE TABLE listings, the book teaches one shape, one SQL generator, and one generic IEntityTypeConfiguration<T> — and proves it in an appendix that lists every table the generator actually produced.
• Advanced relationships, taken seriously. Owned types, table-per-type inheritance for equipment hierarchies, many-to-many joins, alternate keys — modelled the way an industrial schema actually needs them, not the way a tutorial simplifies them.
• Audit, history, and performance, with evidence. Soft delete with query filters, SQL Server temporal tables, RowVersion concurrency — then indexes measured the honest way, with logical reads and execution plans shown before and after, never asserted from memory.
• Beyond the ORM. A dedicated appendix on Dapper, SqlBulkCopy, and raw SQL — and the harder discipline of knowing the handful of places in a two-hundred-table schema where EF Core is genuinely the wrong tool.

How Every Chapter Is Structured

To keep sixteen chapters of database design from turning into a wall of DDL, every chapter follows the same five-beat scaffold the NEXUS-1 series has used since Volume I:

1. What You Already Know: The bridge from engineering instincts you already have — a bounded context is just a SQL schema with a passport; a foreign key is just the passport between them.
2. The Concept: A clear, prose explanation of the modelling decision, never a checklist of EF Core features for their own sake.
3. See It in NEXUS-1: Direct guidance on exactly where that table, that index, or that migration is live on your console screen.
4. Try It: Something to actually run — add a Status row and watch it appear without a redeploy; run a migration twice and watch nothing break.
5. Honest Boundary: A transparent account of what the model simplifies, defers, or deliberately does not claim — because nothing in this book claims to exist that does not.

👤 Who This Is For

This book assumes you're already fluent in C#, comfortable in .NET, and at home in SQL Server. It does not assume you want a guided tour of Entity Framework's feature list — that is not what this book is. If you've ever inherited a database you didn't trust, scaffolded a model you couldn't quite read, or wondered whether your Code First migrations and your DBA's hand-written schema actually agree with each other, this is the book that walks you through finding out — on a real, running reference you can open and check for yourself.

Author: Grigorios Kyriakos Agathangelidis
Greek name: Γρηγόριος Κυριάκος Αγαθαγγελίδης
Also searchable as: Αγαθαγγελίδης Γρηγόριος, Αγαθαγγελιδης Γρηγοριος, Grigorios Agathangelidis.

About the Book

What does a digital twin look like when you stop describing it in diagrams and actually give it a database?

From Schema to System is the complete data-backbone reference for the NEXUS-1 companion system. It takes the architecture introduced in From Table to Twin and writes it down as a full SQL Server / EF Core friendly schema atlas: one database, seventeen bounded contexts, hundreds of tables, typed lookup tables, primary keys, foreign keys, indexes, audit columns, and verification queries.

This is not a book about database theory in the abstract. It is a concrete schema reference for an industrial digital-twin platform built around the NEXUS-1 demonstration environment. The plant fleet, instrumentation layer, digital twin, alarm management, event management, maintenance records, root-cause engine, reinforcement-learning policy store, robotics fleet, radiation monitoring, emergency preparedness, compliance, reporting, and audit trail are all modelled as connected sectors of one database.

The central idea is simple:

A digital twin is only as trustworthy as the data backbone that holds it together.

If a unit exists in the reactor fleet, the same UnitId should be visible in instrumentation, alarms, root-cause analysis, maintenance, reporting, and audit. If a signal feeds a twin variable, that binding should be explicit. If an alarm becomes an incident, and the incident becomes a root-cause investigation, and the investigation produces corrective actions, the chain should be queryable. If the system claims that something happened, the database should be able to show where that claim came from.

This book is the schema map for that chain.

What This Book Contains

The book contains the complete NEXUS-1 schema atlas:

• 17 SQL Server schemas / bounded contexts
• 654 total tables
• 246 typed lookup or reference tables
• 408 substantive operational, historical, audit, fact, or relationship tables
• SQL Server / EF Core friendly DDL
• Primary-key and foreign-key definitions
• Lookup-table conventions
• ER diagrams and foreign-key passport maps
• Cross-schema dependency mappings
• Index definitions
• Seed-data examples
• Verification queries

The schemas covered are:

1. CorePlatform
2. Security
3. Organization
4. ReactorFleet
5. Instrumentation
6. DigitalTwin
7. AlarmManagement
8. EventManagement
9. Maintenance
10. RootCause
11. ReinforcementLearning
12. Robotics
13. RadiationMonitoring
14. EmergencyPreparedness
15. Compliance
16. Reporting
17. Audit

Together, these sectors form the complete data backbone behind the NEXUS-1 digital-twin concept.

Why This Book Exists

The earlier NEXUS-1 books each explained one major part of the platform.

From Grid to Core explained the plant and its physics.
From Flood to Cause explained alarm-flood collapse and root-cause reasoning.
From Trial to Policy explained the interpretable reinforcement-learning agent.
From Table to Twin explained why the data model matters and how a schema becomes a digital twin.

From Schema to System is the technical reference that follows from all of them.

It answers the question:

If all of those systems really lived in one coherent platform, what would the database look like?

The answer is not a single table, not a toy schema, and not a collection of disconnected examples. It is a complete, sector-by-sector architecture where every table has a place, every lookup has a type, and every cross-sector relationship is made explicit by a foreign key.

Who This Book Is For

This book is written for:

• software architects
• database designers
• .NET and EF Core developers
• SQL Server developers
• engineers interested in digital-twin platforms
• readers of the NEXUS-1 series who want the complete data model
• anyone studying how large operational systems can be organized into bounded contexts

You do not need nuclear-industry experience to read it. The nuclear-plant setting is the reference system, not the assumption. The real subject is enterprise data architecture for complex industrial systems.

If you have ever wondered how to model a system where telemetry, alarms, incidents, maintenance, root-cause analysis, compliance, reporting, and audit all need to speak about the same physical world, this book is for you.

What Makes It Different

Most database examples are too small to teach architecture. They show customers, orders, products, invoices, and perhaps a few lookup tables. That is useful, but it does not show what happens when a platform grows large enough to need real boundaries.

This book starts where small examples stop.

It shows:

• how to divide a large system into schemas without losing referential integrity
• how to use lookup tables without falling into hardcoded constants
• how to make foreign keys act as passports between bounded contexts
• how to keep operational records, history, evidence, and audit separate but connected
• how to design for EF Core without giving up SQL Server clarity
• how to make a digital twin queryable instead of merely visual

The result is not only a schema. It is a way of thinking about system truth.

Honest Boundary

NEXUS-1 is a Phase-0 demonstration and educational companion system. The schema in this book is a serious software-architecture reference, but it is not a licensed nuclear-plant information model, not safety-class software, not certified for operational use, and not connected to any real facility.

The purpose of this book is to show how a complex digital-twin platform can be structured, keyed, audited, and reasoned about at database level.

It is a schema atlas, not an operating manual.

In One Sentence

From Schema to System is the complete SQL Server / EF Core schema atlas for the NEXUS-1 digital-twin platform: one database, seventeen sectors, fully keyed.

Author: Grigorios Kyriakos Agathangelidis
Greek name: Γρηγόριος Κυριάκος Αγαθαγγελίδης
Also searchable as: Αγαθαγγελίδης Γρηγόριος, Αγαθαγγελιδης Γρηγοριος, Grigorios Agathangelidis.

About the Book

What does an enterprise EF Core model look like when the DbContext stops being a dumping ground and every entity gets its own professional configuration file?

From Entity to Context is the EF Core configuration companion to the NEXUS-1 schema atlas. It takes the database backbone defined in From Schema to System and shows how that structure can be mapped cleanly into C# using Entity Framework Core, Fluent API, configuration classes, migrations, indexes, relationships, defaults, constraints, and schema-aware folder organization.

This is not a general EF Core tutorial. It is a practical configuration atlas for a large industrial digital-twin platform. The focus is Code First, but not Code First as a toy example. The book shows how Code First can be organized in an enterprise-level project where the model is too large to live inside one OnModelCreating method.

The central idea is simple:

One entity should have one clear mapping, and the context should remain clean.

Instead of filling the DbContext with hundreds or thousands of mapping lines, each entity receives its own IEntityTypeConfiguration<T> class. Keys, table names, schema names, indexes, precision, default values, relationships, delete behavior, row versions, lookup-table conventions, and foreign-key names are placed where they belong: beside the entity they configure.

The result is a model that a programmer can navigate, review, test, migrate, and maintain.

What This Book Contains

The book contains the complete EF Core configuration atlas for the NEXUS-1 companion system.

It includes:

• EF Core Code First reminder chapter
• clean DbContext pattern
• ApplyConfigurationsFromAssembly
• schema-based folder structure
• configuration classes using IEntityTypeConfiguration<T>
• Fluent API mapping examples
• table and schema naming conventions
• primary-key configuration
• alternate keys and unique indexes
• required and optional properties
• SQL Server default values
• DATETIME2, decimal precision, and string-length conventions
• row-version and concurrency patterns
• lookup-table configuration patterns
• cross-schema foreign-key mapping
• migration and verification notes
• configuration indexes for the full atlas

The schema sectors covered are:

1. CorePlatform
2. Security
3. Organization
4. ReactorFleet
5. Instrumentation
6. DigitalTwin
7. AlarmManagement
8. EventManagement
9. Maintenance
10. RootCause
11. ReinforcementLearning
12. Robotics
13. RadiationMonitoring
14. EmergencyPreparedness
15. Compliance
16. Reporting
17. Audit

Together, these chapters show how the full NEXUS-1 data model can be represented in EF Core without losing structure, naming discipline, or database clarity.

Why This Book Exists

From Schema to System answered one question:

If the NEXUS-1 digital twin lived in one coherent SQL Server database, what would that database look like?

From Entity to Context answers the next question:

If that database is mapped professionally in a .NET application, what should the EF Core configuration layer look like?

The answer is not one giant DbContext.
It is not a pile of attributes scattered across entity classes.
It is not a migration file nobody understands.

The answer is a configuration atlas: one entity, one configuration file, one clear place where the database contract is expressed in C#.

Who This Book Is For

This book is written for:

• .NET developers
• EF Core developers
• backend engineers
• software architects
• database-aware C# programmers
• developers working on large enterprise systems
• readers of the NEXUS-1 series who want the C# mapping layer behind the schema

You do not need nuclear-industry experience to read it. The nuclear digital-twin setting is the reference system, not the prerequisite. The real subject is enterprise EF Core organization for large, schema-rich applications.

If you have ever opened a project where OnModelCreating became unreadable, where indexes had random generated names, where relationship configuration was scattered, or where nobody knew which class truly owned the database mapping, this book is for you.

What Makes It Different

Most EF Core examples are intentionally small. They show a few entities, a simple DbContext, and perhaps one or two Fluent API rules. That is useful for learning the basics, but it does not show what happens when the model grows into dozens or hundreds of tables across multiple bounded contexts.

This book starts where small examples stop.

It shows:

• how to keep DbContext clean in a large project
• how to organize configuration files by schema
• how to use Fluent API as the database contract
• how to give indexes and constraints stable professional names
• how to map lookup tables consistently
• how to configure cross-schema relationships
• how to keep Code First readable at scale
• how to prepare migrations that a real team can review
• how to make EF Core serve the database model instead of hiding it

The result is not only EF Core code. It is a way of keeping a large C# data model honest.

Honest Boundary

NEXUS-1 is a Phase-0 demonstration and educational companion system. The EF Core mappings in this book are serious software-architecture material, but they are not certified nuclear software, not a licensed plant data model, not safety-class implementation guidance, and not connected to any real facility.

The purpose of this book is to show how a complex digital-twin schema can be mapped professionally in EF Core using Code First discipline, configuration classes, clear naming, and explicit relationships.

It is a configuration atlas, not an operating manual.

In One Sentence

From Entity to Context is the complete EF Core configuration atlas for the NEXUS-1 digital-twin platform: one entity, one mapping, clean context.

Author: Grigorios Kyriakos Agathangelidis
Greek name: Γρηγόριος Κυριάκος Αγαθαγγελίδης
Also searchable as: Αγαθαγγελίδης Γρηγόριος, Αγαθαγγελιδης Γρηγοριος, Grigorios Agathangelidis.