@@ -55,6 +55,19 @@ struct IOTOFBaseParam : public o2::conf::ConfigurableParamHelper<IOTOFBaseParam>
   float x2x0 = 0.02f;               // thickness expressed in radiation length, for all layers for the moment
   float sensorThickness = 0.0050f;  // thickness of the sensor in cm, for all layers for the moment, the default is set to 50 microns
 
+  // ITOF segmentation parameters
+  float itofRadius = 21.f;          // ITOF radius (cm)
+  float itofLength = 126.82f;       // ITOF length (cm)
+  int itofNStaves = 24;             // ITOF number of staves
+  float itofStaveTilt = 3;          // ITOF stave tilt angle (deg)
+
+  // OTOF segmentation parameters
+  float otofRadius = 92.f;          // OTOF radius (cm)
+  float otofLength = 680.f;         // OTOF length (cm)
+  int otofNStaves = 62;             // OTOF number of staves
+  float otofStaveTilt = 5;          // OTOF stave tilt angle (deg)
+
+
   O2ParamDef(IOTOFBaseParam, "IOTOFBase");
 };
 
 
@@ -11,6 +11,7 @@
 
 o2_add_library(IOTOFSimulation
                SOURCES src/Layer.cxx
+                       src/TF3Chip.cxx
                        src/Chip.cxx
                        src/Detector.cxx
                        src/Digitizer.cxx
@@ -23,6 +24,7 @@ o2_add_library(IOTOFSimulation
 o2_target_root_dictionary(IOTOFSimulation
                           HEADERS include/IOTOFSimulation/Detector.h
                                   include/IOTOFSimulation/Chip.h
+                                  include/IOTOFSimulation/TF3Chip.h
                                   include/IOTOFSimulation/Layer.h
                                   include/IOTOFSimulation/Digitizer.h
                                   include/IOTOFSimulation/DPLDigitizerParam.h
 
@@ -0,0 +1,58 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+#ifndef ALICEO2_IOTOF_TF3CHIP_H_
+#define ALICEO2_IOTOF_TF3CHIP_H_
+
+#include <TGeoManager.h> // for gGeoManager
+#include "Rtypes.h"      // for Int_t, Double_t, Bool_t, UInt_t, etc
+
+class TGeoVolume;
+class TGeoManager;
+
+namespace o2
+{
+
+namespace iotof
+{
+
+/// TF3Chip class creates a TGeoVolume representing the TF3 Chip
+
+class TF3Chip
+{
+ public:
+  TF3Chip() = default;
+  ~TF3Chip() = default;
+
+  /// Creates the TF3Chip
+  /// Returns the chip as a TGeoVolume
+  /// \param yc Y chip half lengths
+  /// \param ys sensor half thickness
+  /// \param chipName sensName default volume names
+  /// \param dummy if true creates a dummy air volume (for material budget studies)
+  /// \param mgr The GeoManager (used only to get the proper material)
+  static TGeoVolume* createChip(Double_t yc, Double_t ys,
+                                char const* chipName = "TF3Chip", char const* sensName = "TF3Sensor",
+                                Bool_t dummy = kFALSE, const TGeoManager* mgr = gGeoManager);
+
+  static void createMaterials(Int_t id, Int_t fieldType, Float_t maxField);
+
+ private:
+  static constexpr double chipSizeX = 2.6; // cm
+  static constexpr double chipSizeZ = 3; // cm (TODO: will be decreased to 3 cm)
+
+  ClassDefNV(TF3Chip, 0); // TF3Chip geometry
+};
+
+} // namespace iotof
+} // namespace o2
+
+#endif
@@ -61,8 +61,9 @@ void Detector::configLayers(bool itof, bool otof, bool ftof, bool btof, std::str
                             const float x2x0, const float sensorThickness)
 {
 
-  std::pair<float, float> dInnerTof = {21.f, 129.f};       // Radius and length
-  std::pair<float, float> dOuterTof = {92.f, 680.f};       // Radius and length
+  auto& iotofPars = IOTOFBaseParam::Instance();
+  std::pair<float, float> dInnerTof = {iotofPars.itofRadius, iotofPars.itofLength}; // Radius and length
+  std::pair<float, float> dOuterTof = {iotofPars.otofRadius, iotofPars.otofLength}; // Radius and length
   std::pair<float, float> radiusRangeDiskTof = {15.f, 100.f};
   float zForwardTof = 370.f;
   LOG(info) << "Configuring IOTOF layers with '" << pattern << "' pattern";
@@ -121,22 +122,23 @@ void Detector::configLayers(bool itof, bool otof, bool ftof, bool btof, std::str
   } else {
     LOG(fatal) << "IOTOF layer pattern " << pattern << " not recognized, exiting";
   }
+
   if (itof) { // iTOF
     const std::string name = GeometryTGeo::getITOFLayerPattern();
-    const int nStaves = itofSegmented ? 24 : 0;              // number of staves in segmented case
-    const double staveWidth = itofSegmented ? 5.42 : 0.0;    // cm
-    const double staveTiltAngle = itofSegmented ? 3.0 : 0.0; // degrees
-    const int modulesPerStave = itofSegmented ? 10 : 0;      // number of modules per stave in segmented case
+    const int nStaves = itofSegmented ? iotofPars.itofNStaves : 0;               // number of staves in segmented case
+    const double staveWidth = itofSegmented ? 5.42 : 0.0;                        // cm
+    const double staveTiltAngle = itofSegmented ? iotofPars.itofStaveTilt : 0.0; // degrees
+    const int modulesPerStave = itofSegmented ? 7 : 0;                          // number of modules per stave in segmented case
     mITOFLayer = ITOFLayer(name,
                            dInnerTof.first, 0.f, dInnerTof.second, 0.f, x2x0, itofSegmented ? ITOFLayer::kBarrelSegmented : ITOFLayer::kBarrel,
                            nStaves, staveWidth, staveTiltAngle, modulesPerStave, itofSegmented ? sensorThickness : 0.0f);
   }
   if (otof) { // oTOF
     const std::string name = GeometryTGeo::getOTOFLayerPattern();
-    const int nStaves = otofSegmented ? 62 : 0;              // number of staves in segmented case
-    const double staveWidth = otofSegmented ? 9.74 : 0.0;    // cm
-    const double staveTiltAngle = otofSegmented ? 5.0 : 0.0; // degrees
-    const int modulesPerStave = otofSegmented ? 54 : 0;      // number of modules per stave in segmented case
+    const int nStaves = otofSegmented ? iotofPars.otofNStaves : 0;               // number of staves in segmented case
+    const double staveWidth = otofSegmented ? 9.74 : 0.0;                        // cm
+    const double staveTiltAngle = otofSegmented ? iotofPars.otofStaveTilt : 0.0; // degrees
+    const int modulesPerStave = otofSegmented ? 54 : 0;                          // number of modules per stave in segmented case
     mOTOFLayer = OTOFLayer(name,
                            dOuterTof.first, 0.f, dOuterTof.second, 0.f, x2x0, otofSegmented ? OTOFLayer::kBarrelSegmented : OTOFLayer::kBarrel,
                            nStaves, staveWidth, staveTiltAngle, modulesPerStave, otofSegmented ? sensorThickness : 0.0f);
 
@@ -15,6 +15,7 @@
 #pragma link off all classes;
 #pragma link off all functions;
 
+#pragma link C++ class o2::iotof::TF3Chip + ;
 #pragma link C++ class o2::iotof::Layer + ;
 #pragma link C++ class o2::iotof::ITOFLayer + ;
 #pragma link C++ class o2::iotof::OTOFLayer + ;
 
@@ -11,6 +11,7 @@
 
 #include "IOTOFSimulation/Layer.h"
 #include "IOTOFBase/GeometryTGeo.h"
+#include "IOTOFSimulation/TF3Chip.h"
 
 #include "Framework/Logger.h"
 
@@ -185,42 +186,45 @@ void ITOFLayer::createLayer(TGeoVolume* motherVolume)
       setLayerStyle(layerVol);
 
       // Now we create the volume for a single stave
-      TGeoBBox* stave = new TGeoBBox(staveSizeX * 0.5, staveSizeY * 0.5, staveSizeZ * 0.5);
-      TGeoVolume* staveVol = new TGeoVolume(staveName, stave, medAir);
+      TGeoBBox* stave = new TGeoBBox(staveSizeX * 0.5, staveSizeY * 0.5 - 0.5 * 300.e-4, staveSizeZ * 0.5);
+      TGeoVolume* staveVol = new TGeoVolume(staveName, stave, medSi);
       setStaveStyle(staveVol);
 
+      // Now we create the volume for a single chip (chip + sensor)
+//      TGeoVolume* chipVol1 = o2::iotof::TF3Chip::createChip(0.5 * 300.e-4, mSensorThickness, chipName, sensName);
+
+
       // Now we create the volume for a single module (sensor + chip)
       const int modulesPerStaveX = 1;                           // we assume that each stave is divided in 1 modules along the x direction
-      const double moduleSizeX = staveSizeX / modulesPerStaveX; // cm
+      const double moduleSizeX = 5.22; //staveSizeX / modulesPerStaveX; // cm
       const double moduleSizeY = staveSizeY;                    // cm
-      const double moduleSizeZ = staveSizeZ / mModulesPerStave; // cm
-      TGeoBBox* module = new TGeoBBox(moduleSizeX * 0.5, moduleSizeY * 0.5, moduleSizeZ * 0.5);
+      const double moduleSizeZ = 18.1; //staveSizeZ / mModulesPerStave; // cm
+      TGeoBBox* module = new TGeoBBox(0.5 * moduleSizeX, 300.e-4 * 0.5, moduleSizeZ * 0.5);
       TGeoVolume* moduleVol = new TGeoVolume(moduleName, module, medAir);
       setModuleStyle(moduleVol);
 
       // Now we create the volume of the chip, which is the same for all modules
       const int chipsPerModuleX = 2;                          // we assume that each module is divided in 2 chips along the x direction
-      const int chipsPerModuleZ = 4;                          // we assume that each module is divided in 2 chips along the z direction
+      const int chipsPerModuleZ = 6;                          // we assume that each module is divided in 2 chips along the z direction
       const double chipSizeX = moduleSizeX / chipsPerModuleX; // cm
       const double chipSizeY = moduleSizeY;                   // cm
       const double chipSizeZ = moduleSizeZ / chipsPerModuleZ; // cm
-      TGeoBBox* chip = new TGeoBBox(chipSizeX * 0.5, chipSizeY * 0.5, chipSizeZ * 0.5);
-      TGeoVolume* chipVol = new TGeoVolume(chipName, chip, medSi);
-      setChipStyle(chipVol);
+//      TGeoBBox* chip = new TGeoBBox(chipSizeX * 0.5, chipSizeY * 0.5, chipSizeZ * 0.5);
+      TGeoVolume* chipVol = o2::iotof::TF3Chip::createChip(300.e-4, mSensorThickness, chipName, sensName); // new TGeoVolume(chipName, chip, medSi);
 
       // Finally we create the volume of the sensor, which is the same for all chips
-      const int sensorsPerChipX = 1;                          // we assume that each chip is divided in 2 sensors along the x direction
+/*      const int sensorsPerChipX = 1;                          // we assume that each chip is divided in 2 sensors along the x direction
       const int sensorsPerChipZ = 1;                          // we assume that each chip is divided in 2 sensors along the z direction
       const double sensorSizeX = chipSizeX / sensorsPerChipX; // cm
       const double sensorSizeY = mSensorThickness;            // cm
       const double sensorSizeZ = chipSizeZ / sensorsPerChipZ; // cm
       TGeoBBox* sensor = new TGeoBBox(sensorSizeX * 0.5, sensorSizeY * 0.5, sensorSizeZ * 0.5);
       TGeoVolume* sensVol = new TGeoVolume(sensName, sensor, medSi);
       setSensorStyle(sensVol);
-      ITOFLayer::mRegister.push_back(sensVol->GetName());
+*/      ITOFLayer::mRegister.push_back(sensName);
 
       // Now we build a chip from sensors
-      for (int i = 0; i < sensorsPerChipX; ++i) {
+/*      for (int i = 0; i < sensorsPerChipX; ++i) {
         for (int j = 0; j < sensorsPerChipZ; ++j) {
           LOGP(info, "iTOF: Creating sensor {}/{} for chip {}/{}", i + 1, sensorsPerChipX, j + 1, sensorsPerChipZ);
           auto* translation = new TGeoTranslation((i + 0.5) * sensorSizeX - 0.5 * chipSizeX,
@@ -229,12 +233,14 @@ void ITOFLayer::createLayer(TGeoVolume* motherVolume)
           chipVol->AddNode(sensVol, 1 + i * sensorsPerChipZ + j, translation);
         }
       }
-
+*/
       // Now we build a module from chips
       for (int i = 0; i < chipsPerModuleX; ++i) {
         for (int j = 0; j < chipsPerModuleZ; ++j) {
           LOGP(info, "iTOF: Creating chip {}/{} for module {}/{}", i + 1, chipsPerModuleX, j + 1, chipsPerModuleZ);
-          auto* translation = new TGeoTranslation((i + 0.5) * chipSizeX - 0.5 * moduleSizeX, 0, (j + 0.5) * chipSizeZ - 0.5 * moduleSizeZ);
+          auto* translation = new TGeoTranslation((i - 0.5) * (2.6 + 0.02), 0, (j + 0.5) * 3 + j * 0.02 - 0.5 * moduleSizeZ);
+          auto* rotation = new TGeoRotation(Form("segmentRotChip%d", i + 1), 0., 0. /*i == 0 ? 0. : 180.*/, 0.);
+    //      auto* transformation = new TGeoCombiTrans(*translation, *rotation);
           moduleVol->AddNode(chipVol, 1 + i * chipsPerModuleZ + j, translation);
         }
       }
@@ -243,7 +249,7 @@ void ITOFLayer::createLayer(TGeoVolume* motherVolume)
       for (int i = 0; i < modulesPerStaveX; ++i) {
         for (int j = 0; j < mModulesPerStave; ++j) {
           LOGP(info, "iTOF: Creating module {}/{} for stave {}/{}", i + 1, modulesPerStaveX, j + 1, mModulesPerStave);
-          auto* translation = new TGeoTranslation((i + 0.5) * moduleSizeX - 0.5 * staveSizeX, 0, (j + 0.5) * moduleSizeZ - 0.5 * staveSizeZ);
+          auto* translation = new TGeoTranslation(0., staveSizeY * 0.5, (j + 0.5) * (moduleSizeZ) + j * 0.02  - 0.5 * staveSizeZ);
           staveVol->AddNode(moduleVol, 1 + i * mModulesPerStave + j, translation);
         }
       }
 
@@ -0,0 +1,135 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+#include "IOTOFSimulation/TF3Chip.h"
+
+#include "DetectorsBase/MaterialManager.h"
+#include "DetectorsBase/Detector.h"
+
+#include <TGeoBBox.h>    // for TGeoBBox
+#include <TGeoManager.h> // for gGeoManager, TGeoManager
+#include "TGeoVolume.h"  // for TGeoVolume
+#include "TGeoMatrix.h"  // for TGeoMatrix
+#include <fairlogger/Logger.h> // for LOG
+
+using namespace o2::iotof;
+
+//________________________________________________________________________
+TGeoVolume* TF3Chip::createChip(const Double_t ychip,
+                                   const Double_t ysens,
+                                   const char* chipName,
+                                   const char* sensName,
+                                   const Bool_t dummy,
+                                   const TGeoManager* mgr)
+{
+
+  Double_t xchip, zchip;
+  Double_t ylen, ypos;
+
+  xchip = 0.5 * chipSizeX;
+  zchip = 0.5 * chipSizeZ;
+
+  // First create all needed shapes
+  ylen = ysens;
+  if (ysens > ychip) {
+    LOG(warning) << "Sensor half thickness (" << ysens
+                 << ") greater than chip half thickness (" << ychip
+                 << "), setting equal";
+    ylen = ychip;
+  }
+
+  // The chip
+  TGeoBBox* chip = new TGeoBBox(xchip, 0.5 * ychip, zchip);
+
+  // The sensor
+  TGeoBBox* sensor = new TGeoBBox(xchip, 0.5 * ylen, zchip);
+
+  // We have all shapes: now create the real volumes
+  TGeoMedium* medSi = mgr->GetMedium("TF3CHIP_SI$");
+  if (!medSi) {
+    Int_t fieldType;
+    Float_t maxField;
+    o2::base::Detector::initFieldTrackingParams(fieldType, maxField);
+    createMaterials(0, fieldType, maxField);
+    medSi = mgr->GetMedium("TF3CHIP_SI$");
+  }
+  TGeoMedium* medAir = mgr->GetMedium("TF3CHIP_AIR$");
+
+  TGeoMedium* medChip;
+
+  if (dummy) {
+    medChip = medAir;
+  } else {
+    medChip = medSi;
+  }
+
+  TGeoVolume* chipVol = new TGeoVolume(chipName, chip, medChip);
+  chipVol->SetVisibility(kTRUE);
+  chipVol->SetLineColor(kOrange);
+  chipVol->SetFillColor(kOrange - 9);
+  chipVol->SetLineWidth(3);
+  chipVol->SetFillStyle(15);
+
+  TGeoVolume* sensVol = new TGeoVolume(sensName, sensor, medChip);
+  sensVol->SetVisibility(kTRUE);
+  sensVol->SetLineColor(kRed);
+  sensVol->SetLineWidth(3);
+  sensVol->SetFillColor(kRed - 9);
+  sensVol->SetFillStyle(5); // 0% transparent
+
+  // Now build up the chip
+  ypos = chip->GetDY() - sensor->GetDY();
+  chipVol->AddNode(sensVol, 1, new TGeoTranslation(0., ypos, 0.));
+
+  // Done, return the chip
+  return chipVol;
+}
+
+//________________________________________________________________________
+void TF3Chip::createMaterials(Int_t id, Int_t ifield, Float_t fieldm)
+{
+  auto& mgr = o2::base::MaterialManager::Instance();
+
+  Float_t tmaxfd = 0.1;   // Degree
+  Float_t stemax = 1.0;   // cm
+  Float_t deemax = 0.1;   // Fraction of particle's energy 0<deemax<=1
+  Float_t epsil = 1.0E-4; // cm
+  Float_t stmin = 0.0;    // cm "Default value used"
+
+  Float_t tmaxfdSi = 0.1;    // Degree
+  Float_t stemaxSi = 0.0075; // cm
+  Float_t deemaxSi = 0.1;    // Fraction of particle's energy 0<deemax<=1
+  Float_t epsilSi = 1.0E-4;  // cm
+  Float_t stminSi = 0.0;     // cm "Default value used"
+
+  Float_t tmaxfdAir = 0.1;   // Degree
+  Float_t stemaxAir = 1.0;   // cm
+  Float_t deemaxAir = 0.1;   // Fraction of particle's energy 0<deemax<=1
+  Float_t epsilAir = 1.0E-4; // cm
+  Float_t stminAir = 0.0;    // cm "Default value used"
+
+  // AIR
+  Float_t aAir[4] = {12.0107, 14.0067, 15.9994, 39.948};
+  Float_t zAir[4] = {6., 7., 8., 18.};
+  Float_t wAir[4] = {0.000124, 0.755267, 0.231781, 0.012827};
+  Float_t dAir = 1.20479E-3;
+
+  if (mgr.getMediumID("TF3CHIP", id) < 0) {
+    mgr.Mixture("TF3CHIP", id, "AIR$", aAir, zAir, dAir, 4, wAir);
+    mgr.Medium("TF3CHIP", id, "AIR$", id, 0, ifield, fieldm, tmaxfdAir, stemaxAir, deemaxAir, epsilAir, stminAir);
+    id++;
+  }
+
+  if (mgr.getMediumID("TF3CHIP", id) < 0) {
+    mgr.Material("TF3CHIP", id, "SI$", 0.28086E+02, 0.14000E+02, 0.23300E+01, 0.93600E+01, 0.99900E+03);
+    mgr.Medium("TF3CHIP", id, "SI$", id, 0, ifield, fieldm, tmaxfdSi, stemaxSi, deemaxSi, epsilSi, stminSi);
+  }
+}