O2FlatCSG.h

Go to the documentation of this file.

// Copyright 2019-2026 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_CADSUPPORT_O2FLATCSG_
#define ALICEO2_CADSUPPORT_O2FLATCSG_
 
#include "TGeoBBox.h"
 
#include <vector>
 
namespace o2
{
namespace cad
{
 
struct FlatCSGHalfspace {
  enum Kind : int { kQuadric = 0,
                    kTorus = 1 };
  int kind = kQuadric;
  double sign = 1.;
  double c[11] = {};
};
 
struct FlatCSGCell {
  int first = 0;
  int count = 0;
  double volume = 0.;
};
 
struct FlatCSGBox {
  double min[3] = {};
  double max[3] = {};
  int cell = -1;
  int firstActive = 0;
  int nActive = 0;
};
 
class O2FlatCSG : public TGeoBBox
{
 public:
  O2FlatCSG();
  explicit O2FlatCSG(const char* name);
  ~O2FlatCSG() override;
 
  // The shape owns a raw `bvh::v2::Bvh` behind `fBVH`, so a compiler-written copy would hand two
  // shapes the same BVH and then free it twice; same treatment as O2BVHAssembly.
  O2FlatCSG(const O2FlatCSG&) = delete;
  O2FlatCSG& operator=(const O2FlatCSG&) = delete;
 
  // ---- building -------------------------------------------------------------------------
  int AddQuadric(double sign, const double coeff[10]);
  int AddTorus(double sign, const double* centre, const double* axis, double major, double minor);
  int AddCell(int first, int count, double volume);
 
  int GetNhalfspaces() const { return static_cast<int>(fHalfspaces.size()); }
  int GetNcells() const { return static_cast<int>(fCells.size()); }
  const FlatCSGHalfspace& GetHalfspace(int index) const { return fHalfspaces[index]; }
  const FlatCSGCell& GetCell(int index) const { return fCells[index]; }
 
  void SetCellBBox(int cell, const double* lo, const double* hi);
  void GetCellBBox(int cell, double* lo, double* hi) const;
 
  void CloseShape();
  bool IsClosed() const { return fClosed; }
 
  size_t GetBVHMemory() const;
 
  int GetNboxes() const { return static_cast<int>(fBoxes.size()); }
  const FlatCSGBox& GetBox(int index) const { return fBoxes[index]; }
  int GetActive(int index) const { return fActive[index]; }
  bool CellContains(int index, const double* point) const;
 
  void SetSplitDepth(int depth) { fSplitDepth = depth; }
  void SetMinBoxFraction(double fraction) { fMinBoxFraction = fraction; }
 
  static double EvalHalfspace(const FlatCSGHalfspace& halfspace, const double* point);
 
  static void HalfspaceRange(const FlatCSGHalfspace& halfspace, const double* lo, const double* hi,
                             double& rangeLo, double& rangeHi);
 
  static int HalfspaceRoots(const FlatCSGHalfspace& halfspace, const double* origin,
                            const double* dir, double* roots);
 
  int CellIntervals(int cell, const int* active, int nActive, const double* origin,
                    const double* dir, double tlo, double thi, double* out, int maxOut) const;
 
  // ---- the TGeoShape contract; the accelerated queries use their `_Loop` twin until CloseShape succeeds ----
  Bool_t Contains(const Double_t* point) const override;
 
  Double_t DistFromOutside(const Double_t* point, const Double_t* dir, Int_t iact = 1,
                           Double_t step = TGeoShape::Big(), Double_t* safe = nullptr) const override;
  Double_t DistFromInside(const Double_t* point, const Double_t* dir, Int_t iact = 1,
                          Double_t step = TGeoShape::Big(), Double_t* safe = nullptr) const override;
 
  Double_t Safety(const Double_t* point, Bool_t in = kTRUE) const override;
 
  static void ResetUnprunedRetryCounter();
  static long long GetUnprunedRetryCount();
 
  void ComputeBBox() override;
 
  Double_t Capacity() const override;
 
  void ComputeNormal(const Double_t* point, const Double_t* dir, Double_t* norm) const override;
  Bool_t GetPointsOnSegments(Int_t npoints, Double_t* array) const override;
 
  // ---- the reference twins ---------------------------------------------------------------
  Bool_t Contains_Loop(const Double_t* point) const;
 
  Double_t DistFromOutside_Loop(const Double_t* point, const Double_t* dir,
                                Double_t step = TGeoShape::Big()) const;
  Double_t DistFromInside_Loop(const Double_t* point, const Double_t* dir,
                               Double_t step = TGeoShape::Big()) const;
  Double_t Safety_Loop(const Double_t* point, Bool_t in = kTRUE) const;
 
 protected:
  void EnsureCellBBoxStorage();
 
  Double_t DistFromOutsideBVH(const Double_t* point, const Double_t* dir, Double_t step) const;
  Double_t DistFromInsideBVH(const Double_t* point, const Double_t* dir, Double_t step) const;
 
  enum class RayBound { kNone,
                        kEntry,
                        kExit };
 
  bool GatherRayPieces(const Double_t* point, const Double_t* dir, Double_t step,
                       std::vector<double>& pairs, std::vector<int>& cells, RayBound bound,
                       double& smallestPruned) const;
 
  void SplitBox(int cell, const double* lo, const double* hi, const std::vector<int>& active,
                int depth, double minSize, int cubifyBudget);
 
  std::vector<FlatCSGHalfspace> fHalfspaces; 
  std::vector<FlatCSGCell> fCells;           
 
  std::vector<FlatCSGBox> fBoxes; 
  std::vector<int> fActive;    
  std::vector<double> fCellLo; 
  std::vector<double> fCellHi; 
  std::vector<bool> fCellBBoxSet;
  bool fClosed = false; 
  int fSplitDepth = 4;
  double fMinBoxFraction = 0.05;
 
  void* fBVH = nullptr; 
 
  // Scratch buffers are thread_local statics in the .cxx, never members: shapes are shared by all navigator threads.
 
  ClassDefOverride(O2FlatCSG, 1) // flat-DNF halfspace shape class
};
 
} // namespace cad
} // namespace o2
 
#endif