WIP

Author: andreasmolander

Detectors/FIT/FV0/base/include/FV0Base/Geometry.h

@@ -67,6 +67,7 @@ class Geometry
   enum EGeoComponent {
     eScintillator,
     ePlastics,
+    ePhotonFilter,
     ePmts,
     eFibers,
     eScrews,
@@ -278,12 +279,15 @@ class Geometry
   // Strings for volume names, etc.
   inline static const std::string sScintillatorName = "SCINT";
   inline static const std::string sPlasticName = "PLAST";
+  inline static const std::string sPhotonFilterName = "PHOTONFILTER";
   inline static const std::string sSectorName = "SECTOR";
   inline static const std::string sCellName = "CELL";
   inline static const std::string sScintillatorSectorName = sScintillatorName + sSectorName;
   inline static const std::string sScintillatorCellName = sScintillatorName + sCellName;
   inline static const std::string sPlasticSectorName = sPlasticName + sSectorName;
   inline static const std::string sPlasticCellName = sPlasticName + sCellName;
+  inline static const std::string sPhotonFilterSectorName = sPhotonFilterName + sSectorName;
+  inline static const std::string sPhotonFilterCellName = sPhotonFilterName + sCellName;
   inline static const std::string sPmtName = "PMT";
   inline static const std::string sFiberName = "FIBER";
   inline static const std::string sScrewName = "SCREW";
@@ -353,7 +357,14 @@ class Geometry
   /// from all volumes that the rods are passing through to avoid overlaps.
   void initializeRodHoles();
 
+  /// Create cell shape expressions to be used in TGeoCompositeShape.
+  /// This will also create and register the needed volumes and transformation used in the TGeoCompositeShape.
+  /// \param  cellType    The type of the cells.
+  /// \param  zThickness  The thickness of the cells.
+  std::string createCellShapeExpressions(const std::string& cellType, const int ring, const float zThickness);
+
   /// Initialize cell volumes with a specified thickness and medium.
+  /// The celltype ('a' or 'b') can be understood fromt the CAD drawings of the detector
   /// \param  cellType    The type of the cells.
   /// \param  zThicknes   The thickness of the cells.
   /// \param  medium      The medium of the cells.
@@ -366,6 +377,9 @@ class Geometry
   /// Initialize plastic cell volumes for optical fiber support.
   void initializePlasticCells();
 
+  /// Initialize the photon filter between the cells. (I.e. the paint + tape.)
+  void initializePhotonFilter();
+
   /// Initialize PMTs.
   void initializePmts();
 
@@ -401,6 +415,11 @@ class Geometry
   /// \param vFV0Left  The left FV0 volume.
   void assemblePlasticSectors(TGeoVolume* vFV0Right, TGeoVolume* vFV0Left) const;
 
+  /// Assemble the photon filters.
+  /// \param vFV0Right The right FV0 volume.
+  /// \param vFV0Left  The left FV0 volume.
+  void assemblePhotonFilters(TGeoVolume* vFV0RIght, TGeoVolume* vFV0Left) const;
+
   /// Assemble the PMTs.
   /// \param vFV0Right The right FV0 volume.
   /// \param vFV0Left  The left FV0 volume.
@@ -523,6 +542,9 @@ class Geometry
   std::vector<TGeoMedium*> mMediumScrewTypes; ///< Medium of the screw types
   std::vector<TGeoMedium*> mMediumRodTypes;   ///< Medium of the rod types
 
+  std::vector<std::string> mACellShapeExpressions; ///< Shape expressions for the A cells
+  std::vector<std::string> mBCellShapeExpressions; ///< Shape expressions for the B cells
+
   const int mGeometryType;                          ///< The type of the geometry.
   std::map<EGeoComponent, bool> mEnabledComponents; ///< Map of the enabled state of all geometry components
   TGeoMatrix* mLeftTransformation;                  ///< Transformation for the left part of the detector

Detectors/FIT/FV0/base/src/Geometry.cxx

@@ -13,7 +13,7 @@
 /// \brief  Implementation of FV0 geometry.
 ///
 /// \author Maciej Slupecki, University of Jyvaskyla, Finland
-/// \author Andreas Molander, University of Helsinki, Finland
+/// \author Andreas Molander ([email protected])
 
 #include "FV0Base/Geometry.h"
 
@@ -94,6 +94,9 @@ bool Geometry::enableComponent(const EGeoComponent component, const bool enable)
 
 void Geometry::buildGeometry() const
 {
+  if (!gGeoManager) {
+    LOG(fatal) << "FV0: No TGeoManager found!";
+  }
   TGeoVolume* vALIC = gGeoManager->GetVolume("barrel");
   if (!vALIC) {
     LOG(fatal) << "FV0: Could not find the top volume";
@@ -370,6 +373,7 @@ void Geometry::initializeNonSensVols()
   initializeScrewHoles();
   initializeRodHoles();
   initializePlasticCells();
+  initializePhotonFilter();
   initializePmts();
   initializeFibers();
   initializeScrews();
@@ -411,6 +415,118 @@ void Geometry::initializeRodHoles()
   new TGeoCompositeShape(sRodHolesCSName.c_str(), boolFormula.c_str());
 }
 
+void Geometry::createCellShapeExpression(const std::string& cellType, const int ring, const float zThickness)
+{
+  const float dxHoleCut = sDxHoleExtensionScintillator; // width of extension of hole 1, 2 and 7 in the "a" cell
+  const float xHole = sDrSeparationScint + dxHoleCut;   // x-placement of holes 1, 2 and 7 in the "a" cell
+
+  // Sector separation gap shape
+  const std::string secSepShapeName = sDetectorName + cellType + "SectorSeparation";
+  if (!gGeoManager->GetListOfShapes()->Contains((secSepShapeName.c_str()))) {
+    new TGeoBBox(secSepShapeName.c_str(), mRMaxScintillator.back() + sEpsilon, sDrSeparationScint, zThickness / 2);
+  }
+
+  // Sector separation gap rotations
+  const std::string secSepRot45Name = sDetectorName + cellType + "SecSepRot45";
+  const std::string secSepRot90Name = sDetectorName + cellType + "SecSepRot90";
+
+  if (!gGeoManager->GetListOfMatrices()->Contains((secSepRot45Name.c_str()))) {
+    createAndRegisterRot(secSepRot45Name, 45, 0, 0);
+  }
+
+  if (!gGeoManager->GetListOfMatrices()->Contains((secSepRot90Name.c_str()))) {
+    createAndRegisterRot(secSepRot90Name, 90, 0, 0);
+  }
+
+  // Hole shapes
+  const std::string holeSmallName = sDetectorName + cellType + "HoleSmall";
+  const std::string holeLargeName = sDetectorName + cellType + "HoleLarge";
+  const std::string holeSmallCutName = sDetectorName + cellType + "HoleSmallCut";
+  const std::string holeLargeCutName = sDetectorName + cellType + "HoleLargeCut";
+
+  if (!gGeoManager->GetListOfShapes()->Contains((holeSmallName.c_str()))) {
+    new TGeoTube(holeSmallName.c_str(), 0, sDrHoleSmallScintillator, zThickness / 2);
+  }
+
+  if (!gGeoManager->GetListOfShapes()->Contains((holeLargeName.c_str()))) {
+    new TGeoTube(holeLargeName.c_str(), 0, sDrHoleLargeScintillator, zThickness / 2);
+  }
+
+  if (!gGeoManager->GetListOfShapes()->Contains((holeSmallCutName.c_str()))) {
+    new TGeoBBox(holeSmallCutName.c_str(), dxHoleCut, sDrHoleSmallScintillator, zThickness / 2);
+  }
+
+  if (!gGeoManager->GetListOfShapes()->Contains((holeLargeCutName.c_str()))) {
+    new TGeoBBox(holeLargeCutName.c_str(), dxHoleCut, sDrHoleLargeScintillator, zThickness / 2);
+  }
+
+  const float rMin = mRAvgRing[ring];
+  const float rMax = mRAvgRing[ring + 1];
+  const float rMid = rMin + (rMax - rMin) / 2;
+
+  if (cellType == "a") {
+    // "a"-type cell
+    //
+    // Initial placement:
+    //
+    // y
+    // ^
+    // |  1******
+    // |  ************5
+    // |  7*****************
+    // |  *********************3
+    // |  *******************
+    // |  2**************8
+    // |      6********
+    // |        **4
+    // |
+    // |
+    // |  O
+    // ------------------------> x
+    //
+    // * = cell volume
+    // numbers = hole numbers (as numbered in the code below)
+    // O = beam pipe
+
+    const std::string aCellName = createVolumeName(cellType + sCellName + "a", ring);
+
+    // Base shape
+    const std::string aCellShapeName = aCellName + "Shape";
+
+    // The cells in the innermost ring have a slightly shifted inner radius origin.
+    if (ring == 0) {
+      // The innermost "a"-type cell
+      const std::string a1CellShapeFullName = aCellShapeName + "Full";
+      const std::string a1CellShapeHoleCutName = aCellShapeName + "HoleCut";
+      const std::string a1CellShapeHoleCutTransName = a1CellShapeHoleCutName + "Trans";
+
+      if (!gGeoManager->GetListOfShapes()->Contains((a1CellShapeFullName.c_str()))) {
+        new TGeoTubeSeg(a1CellShapeFullName.c_str(), 0, mRMaxScintillator[ring], zThickness / 2 - sEpsilon, 45, 90);
+      }
+
+      if (!gGeoManager->GetListOfShapes()->Contains((a1CellShapeHoleCutName.c_str()))) {
+        new TGeoTube(a1CellShapeHoleCutName.c_str(), 0, mRMinScintillator[ring], zThickness);
+      }
+
+      if (!gGeoManager->GetListOfMatrices()->Contains((a1CellShapeHoleCutTransName.c_str()))) {
+        createAndRegisterTrans(a1CellShapeHoleCutTransName, sXShiftInnerRadiusScintillator, 0, 0);
+      }
+
+      const std::string a1BoolFormula = a1CellShapeFullName + "-" + a1CellShapeHoleCutName + ":" + a1CellShapeHoleCutTransName;
+
+      if (!gGeoManager->GetListOfShapes()->Contains((aCellShapeName.c_str()))) {
+        new TGeoCompositeShape(aCellShapeName.c_str(), a1BoolFormula.c_str());
+      }
+    } else {
+      // The rest of the "a"-type cells
+      if (!gGeoManager->GetListOfShapes()->Contains((aCellShapeName.c_str()))) {
+        new TGeoTubeSeg(aCellShapeName.c_str(), mRMinScintillator[ring], mRMaxScintillator[ring], zThickness / 2, 45, 90);
+      }
+    }
+    
+  }
+} 
+
 void Geometry::initializeCells(const std::string& cellType, const float zThickness, const TGeoMedium* medium,
                                const bool isSensitive)
 {
@@ -699,7 +815,7 @@ void Geometry::initializeCells(const std::string& cellType, const float zThickne
       mSensitiveVolumeNames.push_back(aCell->GetName());
       mSensitiveVolumeNames.push_back(bCell->GetName());
     }
-  }
+  } // for each ring
 }
 
 void Geometry::initializeScintCells()
@@ -714,6 +830,12 @@ void Geometry::initializePlasticCells()
   initializeCells(sPlasticName, sDzPlastic, medium, false);
 }
 
+void Geometry::initializePhotonFilter()
+{
+  const TGeoMedium* medium = gGeoManager->GetMedium("FV0_PhotonFilter$");
+  initializeCells(sPhotonFilterName, sDzPhotonFilter, medium, false);
+}
+
 void Geometry::initializePmts()
 {
   const TGeoMedium* medium = gGeoManager->GetMedium("FV0_PMT$");
@@ -1048,6 +1170,9 @@ void Geometry::assembleNonSensVols(TGeoVolume* vFV0Right, TGeoVolume* vFV0Left)
   if (mEnabledComponents.at(ePlastics)) {
     assemblePlasticSectors(vFV0Right, vFV0Left);
   }
+  if (mEnabledComponents.at(ePhotonFilter)) {
+    assemblePhotonFilters(vFV0Right, vFV0Left);
+  }
   if (mEnabledComponents.at(ePmts)) {
     assemblePmts(vFV0Right, vFV0Left);
   }
@@ -1085,6 +1210,14 @@ void Geometry::assemblePlasticSectors(TGeoVolume* vFV0Right, TGeoVolume* vFV0Lef
   vFV0Left->AddNode(sectors, 1, trans);
 }
 
+void Geometry::assemblePhotonFilters(TGeoVolume* vFV0Right, TGeoVolume* vFV0Left) const
+{
+  TGeoVolumeAssembly* sectors = buildSectorAssembly(sPhotonFilterName);
+
+  vFV0Right->AddNode(sectors, 0);
+  vFV0Left->AddNode(sectors, 1);
+}
+
 void Geometry::assemblePmts(TGeoVolume* vFV0Right, TGeoVolume* vFV0Left) const
 {
   TGeoVolumeAssembly* pmts = new TGeoVolumeAssembly(createVolumeName("PMTS").c_str());

Detectors/FIT/FV0/simulation/include/FV0Simulation/Detector.h

@@ -84,6 +84,7 @@ class Detector : public o2::base::DetImpl<Detector>
     Zero,
     Air,
     Scintillator,
+    PhotonFilter,
     Plastic,
     FiberRing1,
     FiberRing2,

Detectors/FIT/FV0/simulation/src/Detector.cxx

@@ -175,6 +175,13 @@ void Detector::createMaterials()
   Float_t wScint[nScint] = {0.07085, 0.92915}; // based on EJ-204 datasheet: n_atoms/cm3
   const Float_t dScint = 1.023;
 
+  // Teflon (PTFE) - C2F4, for the photon filter, i.e. the tape/paint between scintillators
+  const Int_t nTeflon = 2;
+  Float_t aTeflon[nTeflon] = {12.0107, 19.0};
+  Float_t zTeflon[nTeflon] = {6, 9};
+  Float_t wTeflon[nTeflon] = {0.33333, 0.66667};
+  const Float_t dTeflon = 2.2;
+
   // PMMA plastic mixture: (C5O2H8)n, same for plastic fiber support and for the fiber core
   //   Fiber cladding is different, but it comprises only 3% of the fiber volume, so it is not included
   const Int_t nPlast = 3;
@@ -236,6 +243,10 @@ void Detector::createMaterials()
   o2::base::Detector::Medium(Scintillator, "Scintillator$", matId, unsens, fieldType, maxField,
                              tmaxfd, stemax, deemax, epsil, stmin);
 
+  o2::base::Detector::Mixture(++matId, "PhotonFilter$", aTeflon, aTeflon, dTeflon, nTeflon, wTeflon);
+  o2::base::Detector::Medium(PhotonFilter, "PhotonFilter$", matId, unsens, fieldType, maxField,
+                             tmaxfd, stemax, deemax, epsil, stmin);
+
   o2::base::Detector::Mixture(++matId, "Plastic$", aPlast, zPlast, dPlast, nPlast, wPlast);
   o2::base::Detector::Medium(Plastic, "Plastic$", matId, unsens, fieldType, maxField,
                              tmaxfd, stemax, deemax, epsil, stmin);

Detectors/FIT/common/dcsmonitoring/README.md

@@ -9,10 +9,10 @@
 // granted to it by virtue of its status as an Intergovernmental Organization
 // or submit itself to any jurisdiction.
 
-/// \file readFITDCSdata.C
-/// \brief ROOT macro for reading the FIT DCS data from CCDB
+/// \file  readFITDCSdata.C
+/// \brief ROOT macro for reading the FIT DCS datapoint data from CCDB
 ///
-/// \author Andreas Molander <[email protected]>, University of Jyvaskyla, Finland
+/// \author Andreas Molander <[email protected]>
 
 #if !defined(__CLING__) || defined(__ROOTCLING__)
 
@@ -47,11 +47,12 @@
 
 // Helper functions
 
+///
 const std::string epochToReadable(const long timestamp);
 std::vector<std::string> getAliases(const std::string& input, const o2::ccdb::CcdbApi& ccdbApi, const std::string& detectorName, const long timestamp);
 void plotFITDCSmultigraph(const TMultiGraph& multiGraph);
 
-/// ROOT macro for reading FIT DCS data from CCDB.
+/// ROOT macro for reading FIT DCS datapoint data from CCDB.
 ///
 /// The macro can:
 /// - Plot the trends (default ON)
@@ -181,7 +182,7 @@ void readFITDCSdata(std::string detectorName = "FT0",
     }
 
     // The CCDB object should always contain values for all datapoints. This is just to check that.
-    if (verbose && ((detectorName == "FT0" && ccdbMap->size() != 501) || (detectorName == "FV0" && ccdbMap->size() != 147) || (detectorName == "FDD" && ccdbMap->size() != 76))) {
+    if (verbose && ((detectorName == "FT0" && ccdbMap->size() != 500) || (detectorName == "FV0" && ccdbMap->size() != 147) || (detectorName == "FDD" && ccdbMap->size() != 99))) {
       LOGP(error,
            "Wrong number of DCS datapoints fetched for {}, got {}. There is a bug, please send output of this script, with input parameters, to [email protected].",
            detectorName, ccdbMap->size());
@@ -353,8 +354,12 @@ void printCCDBObject(const std::string detectorName = "FT0",
     }
     std::stringstream tmp;
     tmp << it.first;
-    LOGP(info, "DPID = {}", tmp.str());
-    it.second.print();
+    // LOGP(info, "DPID = {}", tmp.str());
+    // LOGP(info, "{}", tmp.str());
+    // it.second.print();
+    if (!it.second.empty()) {
+      LOGP(info, "{}    {}", tmp.str(), epochToReadable(it.second.values.back().first));
+    }
   }
 
   LOGP(info, "Size of map = {}", map->size());
@@ -374,6 +379,9 @@ void plotFITDCSmultigraph(const TMultiGraph& multiGraph)
   canvas->BuildLegend();
 }
 
+/// Convert UNIX timestamp (in ms) to a human readable string.
+/// \param timestamp UNIX timestamp in ms.
+/// \return Human readable string.
 const std::string epochToReadable(const long timestamp)
 {
   std::string readableTime;
@@ -383,6 +391,10 @@ const std::string epochToReadable(const long timestamp)
   return readableTime;
 }
 
+/// Parse the input string and return a vector of aliases.
+/// If the input string is a file name, the aliases are assumed to be stored in the file, one on each line.
+/// If the input string is not a file name, it is assumed to be a semicolon separated list of aliases.
+/// If the input string is empty, all data points defined in [ccdbUrl]/[detectorName]/Config/DCSDPconfig are queried.
 std::vector<std::string> getAliases(const std::string& input, const o2::ccdb::CcdbApi& ccdbApi, const std::string& detectorName, const long timestamp)
 {
   std::vector<std::string> aliases;