@@ -59,25 +59,11 @@ class FT3Layer : public TObject
   /// \param motherVolume the TGeoVolume owing the volume structure
   virtual void createLayer(TGeoVolume* motherVolume);
 
-  static void initialize_mat();
-
   // create layer for disk support
   void createSeparationLayer(TGeoVolume* motherVolume, const std::string& separationLayerName);
   void createSeparationLayer_waterCooling(TGeoVolume* motherVolume, const std::string& separationLayerName);
   void createReferenceCircles(TGeoVolume* motherVolume, const std::string& name);
 
-  static TGeoMaterial* carbonFiberMat;
-  static TGeoMedium* medCarbonFiber;
-
-  static TGeoMixture* kaptonMat;
-  static TGeoMedium* kaptonMed;
-
-  static TGeoMaterial* waterMat;
-  static TGeoMedium* waterMed;
-
-  static TGeoMaterial* foamMat;
-  static TGeoMedium* medFoam;
-
  private:
   Int_t mLayerNumber = -1;    ///< Current layer number
   Int_t mDirection;           ///< Layer direction 0=Forward 1 = Backward
 
@@ -15,6 +15,7 @@
 #ifndef FT3MODULE_H
 #define FT3MODULE_H
 
+#include <TGeoMedium.h>
 #include <TGeoVolume.h>
 #include <string>
 #include <vector>
@@ -33,19 +34,12 @@ class FT3Module
 {
 
  public:
-  static void initialize_materials();
-  static TGeoMaterial* siliconMat;
-  static TGeoMedium* siliconMed;
-  static TGeoMaterial* copperMat;
-  static TGeoMedium* copperMed;
-  static TGeoMixture* kaptonMat;
-  static TGeoMedium* kaptonMed;
-  static TGeoMaterial* epoxyMat;
-  static TGeoMedium* epoxyMed;
-  static TGeoMaterial* AluminumMat;
-  static TGeoMedium* AluminumMed;
-  static TGeoMaterial* carbonFiberMat;
-  static TGeoMedium* carbonFiberMed;
+  /*
+   * The media themselves are created by Detector::createMaterials() from the
+   * table in FT3ModuleConstants.h, before the geometry is built. This only
+   * looks them up again in the MaterialManager by their MaterialID.
+   */
+  static TGeoMedium* getMedium(Constants::MaterialID id);
 
   const char* mDetName;
 
 
@@ -15,6 +15,8 @@
 #ifndef FT3MODULECONSTANTS_H
 #define FT3MODULECONSTANTS_H
 
+#include <array>
+#include <unordered_map>
 #include <vector>
 #include <map>
 #include <TColor.h>
@@ -29,17 +31,19 @@ namespace o2::ft3::ModuleConstants
  * When stacking 2x1 modules, there is a 0.2mm gap between them. By default, we assume this
  * gap to be ABOVE the most recently placed module.
  *
- * |<- 25mm ->|<- 25mm ->|
+ * |<- 25mm ->||<- 25mm ->|
  * _______________________
- * -----------------------  0.2mm gap above
- * | |        |        | |
- * | |        |        | |
- * | |        |        | |
- * | |        |        | |  29mm sensor height
- * | |        |        | |
- * | |        |        | |
+ * ------------------------  0.2mm gap above
+ * | |        ||        | |
+ * | |        ||        | |
+ * | |        ||        | |
+ * | |        ||        | |  29mm sensor height
+ * | |        ||        | |
+ * | |        ||        | |
  * ------------------------
- *
+ *            ^
+ *            |
+ *   0.2mm gap in the middle
  */
 // First set all layout constants for the rest of the function
 const double single_sensor_width = 2.5;
@@ -98,12 +102,88 @@ inline const double z_offsetStave(double x_midpoint_spacing)
          (2 - x_midpoint_spacing / (sensor2x1_width / 2 + staveSensorGap));
 }
 
-const int SiColor = kGreen;
+/*
+ * Materials of the FT3 module.
+ *
+ * Everything the simulation needs to know about a material lives in the
+ * materials map below, keyed by its FT3-local ID: composition, density,
+ * transport parameters and the colour its volumes are drawn in.
+ * Detector::createMaterials() registers the whole map with the MaterialManager,
+ * and FT3Module/FT3Layer look the media up again by MaterialID, so no ID,
+ * density or colour is ever written out by hand.
+ */
+enum class MaterialID : unsigned {
+  Air = 1,
+  Silicon,
+  Copper,
+  Kapton,
+  CarbonFiber,
+  Epoxy,
+  Aluminum,
+  Foam,
+  Water
+};
+
+// Transport parameters of a medium, in the order expected by Detector::Medium()
+struct TrackingParams {
+  float tmaxfd; // maximum field-induced angular deviation per step, degrees
+  float stemax; // maximum step length, cm
+  float deemax; // maximum fractional energy loss per step
+  float epsil;  // tracking precision, cm
+  float stmin;  // minimum step length, cm
+};
+
+constexpr TrackingParams sensitiveTracking = {0.1f, 0.0075f, 0.1f, 1.0e-4f, 0.0f};
+constexpr TrackingParams passiveTracking = {0.1f, 1.0f, 0.1f, 1.0e-4f, 0.0f};
+
+// Maximum number of elements any of the mixtures below is built from
+constexpr unsigned maxMaterialComponents = 4;
+using ComponentArray = std::array<float, maxMaterialComponents>;
+
+struct MaterialProperties {
+  const char* name;
+  int colour;         // ROOT colour every volume made of this material is drawn in
+  float density;     // g/cm3
+  // Radiation and nuclear interaction length, cm. Only single elements carry
+  // them: Mixture() derives both from the composition and takes no such
+  // arguments. A non-positive value lets the transport engine compute it.
+  float radl;
+  float absl;
+  int nComponents;   // 0: single element; > 0: mixture by weight; < 0: mixture by atom count
+  ComponentArray a;  // mass numbers; only a[0] is used for a single element
+  ComponentArray z;  // atomic numbers; only z[0] is used for a single element
+  ComponentArray w;  // weight fractions or atom counts; unused for a single element
+  TrackingParams tracking;
+};
+
+/*
+ * Silicon, copper and carbon fibre are shared with TRK and are kept numerically
+ * identical to its SILICON$, COPPER$ and CARBONFIBER$ (TRK Detector::createMaterials()),
+ * down to the radiation lengths. Kapton, epoxy and aluminium have no TRK
+ * counterpart: TRK models the flex as the effective FPC$ mixture instead.
+ */
+inline const std::unordered_map<MaterialID, MaterialProperties> materials = {
+  // Air volumes get their colour set individually where they are built
+  {MaterialID::Air, {"AIR$", kWhite, 1.20479e-3f, 0.0f, 0.0f, 4, {12.0107f, 14.0067f, 15.9994f, 39.948f}, {6.0f, 7.0f, 8.0f, 18.0f}, {0.000124f, 0.755267f, 0.231781f, 0.012827f}, passiveTracking}},
+  {MaterialID::Silicon, {"SILICON$", kGreen, 2.33f, 9.36f, 999.0f, 0, {28.086f}, {14.0f}, {}, sensitiveTracking}},
+  // Copper planes of the end-of-stave cards: X0 = 1.436 cm
+  {MaterialID::Copper, {"COPPER$", kOrange, 8.96f, 1.436f, 999.0f, 0, {63.546f}, {29.0f}, {}, passiveTracking}},
+  // Kapton: C22 H10 N2 O5, by weight fraction. Also the cooling pipe material.
+  {MaterialID::Kapton, {"KAPTON$", kYellow, 1.346f, 0.0f, 0.0f, 4, {12.0107f, 1.00794f, 14.0067f, 15.999f}, {6.0f, 1.0f, 7.0f, 8.0f}, {0.5641f, 0.2564f, 0.0513f, 0.1282f}, passiveTracking}},
+  // Carbon fibre: density tuned so X0 ~ 27 cm, as in TRK
+  // TODO: Check with Rene the exact type of carbon fiber
+  {MaterialID::CarbonFiber, {"CARBONFIBER$", kGray + 1, 1.45f, 27.0f, 999.0f, 0, {12.0107f}, {6.0f}, {}, passiveTracking}},
+  // Epoxy: C18 H19 O3, by atom count (negative nComponents)
+  {MaterialID::Epoxy, {"EPOXY$", kBlue, 2.186f, 0.0f, 0.0f, -3, {12.0107f, 1.00794f, 15.999f}, {6.0f, 1.0f, 8.0f}, {18.0f, 19.0f, 3.0f}, passiveTracking}},
+  // No TRK counterpart; X0 and lambda are left to the transport engine
+  {MaterialID::Aluminum, {"ALUMINUM$", kBlack, 2.7f, 0.0f, 0.0f, 0, {26.98f}, {13.0f}, {}, passiveTracking}},
+  // Carbon foam core of the disk separation layer
+  {MaterialID::Foam, {"FOAM$", kBlack, 0.17f, 0.0f, 0.0f, 0, {12.0107f}, {6.0f}, {}, passiveTracking}},
+  // Coolant inside the kapton pipes
+  {MaterialID::Water, {"WATER$", kBlue, 1.064f, 0.0f, 0.0f, 0, {18.01528f}, {8.0f}, {}, passiveTracking}}};
+// The inactive rim of a sensor is made of silicon as well, but is drawn
+// separately so that it can be told apart from the active area.
 const int SiInactiveColor = kRed;
-const int glueColor = kBlue;
-const int CuColor = kOrange;
-const int kaptonColor = kYellow;
-const int carbonFiberColor = kGray + 1;
 
 // Struct for stave position configuration (varies between ML/OT)
 struct StaveConfig {
 
@@ -20,6 +20,7 @@
 #include "FT3Base/FT3BaseParam.h"
 #include "FT3Base/GeometryTGeo.h"
 #include "FT3Simulation/FT3Layer.h"
+#include "FT3Simulation/FT3ModuleConstants.h"
 
 // FairRoot includes
 #include "FairDetector.h"    // for FairDetector
@@ -39,6 +40,7 @@
 
 #include <fairlogger/Logger.h> // for LOG, LOG_IF
 
+#include <array>
 #include <cstdio> // for NULL, snprintf
 
 #define MAX_SENSORS 2000
@@ -495,29 +497,26 @@ void Detector::createMaterials()
   float fieldm = 10.0;
   o2::base::Detector::initFieldTrackingParams(ifield, fieldm);
 
-  float tmaxfdSi = 0.1;    // .10000E+01; // Degree
-  float stemaxSi = 0.0075; //  .10000E+01; // cm
-  float deemaxSi = 0.1;    // 0.30000E-02; // Fraction of particle's energy 0<deemax<=1
-  float epsilSi = 1.0E-4;  // .10000E+01;
-  float stminSi = 0.0;     // cm "Default value used"
-
-  float tmaxfdAir = 0.1;        // .10000E+01; // Degree
-  float stemaxAir = .10000E+01; // cm
-  float deemaxAir = 0.1;        // 0.30000E-02; // Fraction of particle's energy 0<deemax<=1
-  float epsilAir = 1.0E-4;      // .10000E+01;
-  float stminAir = 0.0;         // cm "Default value used"
-
-  // AIR
-  float aAir[4] = {12.0107, 14.0067, 15.9994, 39.948};
-  float zAir[4] = {6., 7., 8., 18.};
-  float wAir[4] = {0.000124, 0.755267, 0.231781, 0.012827};
-  float dAir = 1.20479E-3;
-
-  o2::base::Detector::Mixture(1, "AIR$", aAir, zAir, dAir, 4, wAir);
-  o2::base::Detector::Medium(1, "AIR$", 1, 0, ifield, fieldm, tmaxfdAir, stemaxAir, deemaxAir, epsilAir, stminAir);
-
-  o2::base::Detector::Material(3, "SILICON$", 0.28086E+02, 0.14000E+02, 0.23300E+01, 0.93600E+01, 0.99900E+03);
-  o2::base::Detector::Medium(3, "SILICON$", 3, 0, ifield, fieldm, tmaxfdSi, stemaxSi, deemaxSi, epsilSi, stminSi);
+  // Every FT3 material is described by the map in FT3ModuleConstants.h: name,
+  // composition, density, radiation length, transport parameters and display
+  // colour, keyed by its MaterialID. FT3Module and FT3Layer retrieve the media
+  // from the MaterialManager by the same ID, so nothing is written out twice.
+  for (const auto& [materialID, material] : ModuleConstants::materials) {
+    const int id = static_cast<int>(materialID);
+    if (material.nComponents == 0) {
+      o2::base::Detector::Material(id, material.name, material.a[0], material.z[0], material.density,
+                                   material.radl, material.absl);
+    } else {
+      // Mixture() takes non-const pointers, so hand it copies of the table rows
+      ModuleConstants::ComponentArray a = material.a;
+      ModuleConstants::ComponentArray z = material.z;
+      ModuleConstants::ComponentArray w = material.w;
+      o2::base::Detector::Mixture(id, material.name, a.data(), z.data(), material.density, material.nComponents, w.data());
+    }
+    const auto& tracking = material.tracking;
+    o2::base::Detector::Medium(id, material.name, id, 0, ifield, fieldm, tracking.tmaxfd, tracking.stemax,
+                               tracking.deemax, tracking.epsil, tracking.stmin);
+  }
 }
 
 //_________________________________________________________________________________________________