[geom] fix off-by-one docu mistakes

geom/gdml/inc/TGDMLParse.h

@@ -43,9 +43,9 @@ class TGDMLRefl : public TObject {
    TGeoMatrix *GetMatrix();
 
 private:
-   const char *fNameS;  //! reflected solid name
-   const char *fSolid;  //! solid name being reflected
-   TGeoMatrix *fMatrix; //! matrix of reflected solid
+   const char *fNameS;  ///<! reflected solid name
+   const char *fSolid;  ///<! solid name being reflected
+   TGeoMatrix *fMatrix; ///<! matrix of reflected solid
 
    ClassDefOverride(TGDMLRefl, 0) // helper class used for the storage of reflected solids
 };
@@ -205,23 +205,23 @@ class TGDMLParse : public TObject {
    typedef std::map<std::string, double> FracMap;
    typedef std::map<std::string, double> ConstMap;
 
-   PosMap fposmap;             //! Map containing position names and the TGeoTranslation for it
-   RotMap frotmap;             //! Map containing rotation names and the TGeoRotation for it
-   SclMap fsclmap;             //! Map containing scale names and the TGeoScale for it
-   IsoMap fisomap;             //! Map containing isotope names and the TGeoIsotope for it
-   EleMap felemap;             //! Map containing element names and the TGeoElement for it
-   MatMap fmatmap;             //! Map containing material names and the TGeoMaterial for it
-   MedMap fmedmap;             //! Map containing medium names and the TGeoMedium for it
-   MixMap fmixmap;             //! Map containing mixture names and the TGeoMixture for it
-   SolMap fsolmap;             //! Map containing solid names and the TGeoShape for it
-   VolMap fvolmap;             //! Map containing volume names and the TGeoVolume for it
-   PvolMap fpvolmap;           //! Map containing placed volume names and the TGeoNode for it
-   ReflectionsMap freflectmap; //! Map containing reflection names and the Solid name ir references to
-   ReflSolidMap freflsolidmap; //! Map containing reflection names and the TGDMLRefl for it - containing refl matrix
-   ReflVolMap freflvolmap;     //! Map containing reflected volume names and the solid ref for it
-   FileMap ffilemap;           //! Map containing files parsed during entire parsing, with their world volume name
-   ConstMap fconsts;           //! Map containing values of constants declared in the file
-   MatrixMap fmatrices;        //! Map containing matrices defined in the GDML file
+   PosMap fposmap;             ///<! Map containing position names and the TGeoTranslation for it
+   RotMap frotmap;             ///<! Map containing rotation names and the TGeoRotation for it
+   SclMap fsclmap;             ///<! Map containing scale names and the TGeoScale for it
+   IsoMap fisomap;             ///<! Map containing isotope names and the TGeoIsotope for it
+   EleMap felemap;             ///<! Map containing element names and the TGeoElement for it
+   MatMap fmatmap;             ///<! Map containing material names and the TGeoMaterial for it
+   MedMap fmedmap;             ///<! Map containing medium names and the TGeoMedium for it
+   MixMap fmixmap;             ///<! Map containing mixture names and the TGeoMixture for it
+   SolMap fsolmap;             ///<! Map containing solid names and the TGeoShape for it
+   VolMap fvolmap;             ///<! Map containing volume names and the TGeoVolume for it
+   PvolMap fpvolmap;           ///<! Map containing placed volume names and the TGeoNode for it
+   ReflectionsMap freflectmap; ///<! Map containing reflection names and the Solid name ir references to
+   ReflSolidMap freflsolidmap; ///<! Map containing reflection names and the TGDMLRefl for it - containing refl matrix
+   ReflVolMap freflvolmap;     ///<! Map containing reflected volume names and the solid ref for it
+   FileMap ffilemap;           ///<! Map containing files parsed during entire parsing, with their world volume name
+   ConstMap fconsts;           ///<! Map containing values of constants declared in the file
+   MatrixMap fmatrices;        ///<! Map containing matrices defined in the GDML file
 
    ClassDefOverride(TGDMLParse, 0) // imports GDML using DOM and binds it to ROOT
 };

geom/gdml/inc/TGDMLWrite.h

@@ -135,7 +135,7 @@ class TGDMLWrite : public TObject {
    Int_t fPhysVolCnt;               // count of physical volumes
    UInt_t fActNameErr;              // count of name errors
    UInt_t fSolCnt;                  // count of name solids
-   UInt_t fFltPrecision;            //! floating point precision when writing
+   UInt_t fFltPrecision;            ///<! floating point precision when writing
 
    static const UInt_t fgkProcBit = BIT(14);    // 14th bit is set when solid is processed
    static const UInt_t fgkProcBitVol = BIT(19); // 19th bit is set when volume is processed

geom/gdml/src/TGDMLParse.cxx

@@ -1290,7 +1290,7 @@ XMLNodePointer_t TGDMLParse::EleProcess(TXMLEngine *gdml, XMLNodePointer_t node,
 
 XMLNodePointer_t TGDMLParse::MatProcess(TXMLEngine *gdml, XMLNodePointer_t node, XMLAttrPointer_t attr, int z)
 {
-   //! Map to hold fractions while being processed
+   ///<! Map to hold fractions while being processed
    typedef FracMap::iterator fractions;
    //  typedef FracMap::iterator i;
    FracMap fracmap;

geom/geom/inc/TGeoArb8.h

@@ -26,7 +26,7 @@ class TGeoArb8 : public TGeoBBox {
    };
    // data members
    Double_t fDz{0};           // half length in Z
-   Double_t *fTwist{nullptr}; //! [4] tangents of twist angles
+   Double_t *fTwist{nullptr}; ///<! [4] tangents of twist angles
    Double_t fXY[8][2];        // list of vertices
 
    TGeoArb8(const TGeoArb8 &) = delete;

geom/geom/inc/TGeoBoolNode.h

@@ -48,13 +48,13 @@ class TGeoBoolNode : public TObject {
    TGeoShape *fRight{nullptr};         // shape on the right branch
    TGeoMatrix *fLeftMat{nullptr};      // transformation that applies to the left branch
    TGeoMatrix *fRightMat{nullptr};     // transformation that applies to the right branch
-   mutable Int_t fNpoints{0};          //! number of points on the mesh
-   mutable Double_t *fPoints{nullptr}; //! array of mesh points
+   mutable Int_t fNpoints{0};          ///<! number of points on the mesh
+   mutable Double_t *fPoints{nullptr}; ///<! array of mesh points
 
-   mutable std::vector<ThreadData_t *> fThreadData; //! Navigation data per thread
-   mutable Int_t fThreadSize{0};                    //! Size for the navigation data array
-   mutable std::mutex fMutex;                       //! Mutex for thread data access
-   mutable Bool_t fMeshValid{kFALSE};               //! Flag for mesh cache validity
+   mutable std::vector<ThreadData_t *> fThreadData; ///<! Navigation data per thread
+   mutable Int_t fThreadSize{0};                    ///<! Size for the navigation data array
+   mutable std::mutex fMutex;                       ///<! Mutex for thread data access
+   mutable Bool_t fMeshValid{kFALSE};               ///<! Flag for mesh cache validity
                                                     // methods
    Bool_t MakeBranch(const char *expr, Bool_t left);
    void AssignPoints(Int_t npoints, Double_t *points);

geom/geom/inc/TGeoBranchArray.h

@@ -24,7 +24,7 @@ class TGeoBranchArray : public TObject {
    Int_t fLevel;            // Branch depth
    Int_t fMaxLevel;         // Array length
    TGeoHMatrix fMatrix;     // Global matrix (owned)
-   TGeoNode **fArray;       //![fMaxLevel+1] Array of nodes
+   TGeoNode **fArray;       ///<![fMaxLevel+1] Array of nodes
    TGeoNode *fRealArray[1]; // Beginning address of the array of nodes
 
 private:

geom/geom/inc/TGeoBuilder.h

@@ -25,14 +25,14 @@ class TGeoManager;
 
 class TGeoBuilder : public TObject {
 protected:
-   static TGeoBuilder *fgInstance; //! static pointer to singleton
+   static TGeoBuilder *fgInstance; ///<! static pointer to singleton
 
    TGeoBuilder();
    TGeoBuilder(const TGeoBuilder &) = delete;
    TGeoBuilder &operator=(const TGeoBuilder &) = delete;
 
 private:
-   TGeoManager *fGeometry; //! current geometry
+   TGeoManager *fGeometry; ///<! current geometry
 
    void SetGeometry(TGeoManager *geom) { fGeometry = geom; }
 

geom/geom/inc/TGeoCache.h

@@ -66,15 +66,15 @@ class TGeoNodeCache : public TObject {
    Int_t fIdBranch[100];        // current branch of indices
    TString fPath;               // path for current branch
    TGeoNode *fTop;              // top node
-   TGeoNode *fNode;             //! current node
-   TGeoHMatrix *fMatrix;        //! current matrix
+   TGeoNode *fNode;             ///<! current node
+   TGeoHMatrix *fMatrix;        ///<! current matrix
    TObjArray *fStack;           // stack of cache states
    TGeoHMatrix **fMatrixBranch; // current branch of global matrices
    TGeoHMatrix **fMPB;          // pre-built matrices
    TGeoNode **fNodeBranch;      // current branch of nodes
    TGeoStateInfo **fInfoBranch; // current branch of nodes
-   TGeoStateInfo *fPWInfo;      //! State info for the parallel world
-   Int_t *fNodeIdArray;         //! array of node id's
+   TGeoStateInfo *fPWInfo;      ///<! State info for the parallel world
+   Int_t *fNodeIdArray;         ///<! array of node id's
 
    TGeoNodeCache(const TGeoNodeCache &) = delete;
    TGeoNodeCache &operator=(const TGeoNodeCache &) = delete;

geom/geom/inc/TGeoElement.h

@@ -371,7 +371,7 @@ class TGeoElementTable : public TObject {
    // Map of radionuclides
    typedef std::map<Int_t, TGeoElementRN *> ElementRNMap_t;
    typedef ElementRNMap_t::iterator ElementRNMapIt_t;
-   ElementRNMap_t fElementsRN; //! map of RN elements with ENDF key
+   ElementRNMap_t fElementsRN; ///<! map of RN elements with ENDF key
 
 protected:
    TGeoElementTable(const TGeoElementTable &);

geom/geom/inc/TGeoManager.h

@@ -51,57 +51,57 @@ class TGeoManager : public TNamed {
    };
 
 protected:
-   static std::mutex fgMutex;           //! mutex for navigator booking in MT mode
-   static Bool_t fgLock;                //! Lock preventing a second geometry to be loaded
-   static Int_t fgVerboseLevel;         //! Verbosity level for Info messages (no IO).
-   static Int_t fgMaxLevel;             //! Maximum level in geometry
-   static Int_t fgMaxDaughters;         //! Maximum number of daughters
-   static Int_t fgMaxXtruVert;          //! Maximum number of Xtru vertices
-   static UInt_t fgExportPrecision;     //! Precision to be used in ASCII exports
-   static EDefaultUnits fgDefaultUnits; //! Default units in GDML if not explicit in some tags
+   static std::mutex fgMutex;           ///<! mutex for navigator booking in MT mode
+   static Bool_t fgLock;                ///<! Lock preventing a second geometry to be loaded
+   static Int_t fgVerboseLevel;         ///<! Verbosity level for Info messages (no IO).
+   static Int_t fgMaxLevel;             ///<! Maximum level in geometry
+   static Int_t fgMaxDaughters;         ///<! Maximum number of daughters
+   static Int_t fgMaxXtruVert;          ///<! Maximum number of Xtru vertices
+   static UInt_t fgExportPrecision;     ///<! Precision to be used in ASCII exports
+   static EDefaultUnits fgDefaultUnits; ///<! Default units in GDML if not explicit in some tags
 
    TGeoManager(const TGeoManager &) = delete;
    TGeoManager &operator=(const TGeoManager &) = delete;
 
 private:
-   Double_t fPhimin;                //! lowest range for phi cut
-   Double_t fPhimax;                //! highest range for phi cut
-   Double_t fTmin;                  //! lower time limit for tracks drawing
-   Double_t fTmax;                  //! upper time limit for tracks drawing
+   Double_t fPhimin;                ///<! lowest range for phi cut
+   Double_t fPhimax;                ///<! highest range for phi cut
+   Double_t fTmin;                  ///<! lower time limit for tracks drawing
+   Double_t fTmax;                  ///<! upper time limit for tracks drawing
    Int_t fNNodes;                   // total number of physical nodes
-   TString fPath;                   //! path to current node
-   TString fParticleName;           //! particles to be drawn
+   TString fPath;                   ///<! path to current node
+   TString fParticleName;           ///<! particles to be drawn
    Double_t fVisDensity;            // transparency threshold by density
    Int_t fExplodedView;             // exploded view mode
    Int_t fVisOption;                // global visualization option
    Int_t fVisLevel;                 // maximum visualization depth
    Int_t fNsegments;                // number of segments to approximate circles
    Int_t fNtracks;                  // number of tracks
    Int_t fMaxVisNodes;              // maximum number of visible nodes
-   TVirtualGeoTrack *fCurrentTrack; //! current track
+   TVirtualGeoTrack *fCurrentTrack; ///<! current track
    Int_t fNpdg;                     // number of different pdg's stored
    Int_t fPdgId[1024];              // pdg conversion table
-   Bool_t fClosed;                  //! flag that geometry is closed
-   Bool_t fLoopVolumes;             //! flag volume lists loop
+   Bool_t fClosed;                  ///<! flag that geometry is closed
+   Bool_t fLoopVolumes;             ///<! flag volume lists loop
    Bool_t fStreamVoxels;            // flag to allow voxelization I/O
-   Bool_t fIsGeomReading;           //! flag set when reading geometry
-   Bool_t fIsGeomCleaning;          //! flag to notify that the manager is being destructed
+   Bool_t fIsGeomReading;           ///<! flag set when reading geometry
+   Bool_t fIsGeomCleaning;          ///<! flag to notify that the manager is being destructed
    Bool_t fPhiCut;                  // flag for phi cuts
    Bool_t fTimeCut;                 // time cut for tracks
-   Bool_t fDrawExtra;               //! flag that the list of physical nodes has to be drawn
-   Bool_t fMatrixTransform;         //! flag for using GL matrix
-   Bool_t fMatrixReflection;        //! flag for GL reflections
-   Bool_t fActivity;                //! switch ON/OFF volume activity (default OFF - all volumes active))
-   Bool_t fIsNodeSelectable;        //! flag that nodes are the selected objects in pad rather than volumes
-   TVirtualGeoPainter *fPainter;    //! current painter
-   TVirtualGeoChecker *fChecker;    //! current checker
+   Bool_t fDrawExtra;               ///<! flag that the list of physical nodes has to be drawn
+   Bool_t fMatrixTransform;         ///<! flag for using GL matrix
+   Bool_t fMatrixReflection;        ///<! flag for GL reflections
+   Bool_t fActivity;                ///<! switch ON/OFF volume activity (default OFF - all volumes active))
+   Bool_t fIsNodeSelectable;        ///<! flag that nodes are the selected objects in pad rather than volumes
+   TVirtualGeoPainter *fPainter;    ///<! current painter
+   TVirtualGeoChecker *fChecker;    ///<! current checker
 
    TObjArray *fMatrices;        //-> list of local transformations
    TObjArray *fShapes;          //-> list of shapes
    TObjArray *fVolumes;         //-> list of volumes
    TObjArray *fPhysicalNodes;   //-> list of physical nodes
-   TObjArray *fGShapes;         //! list of runtime shapes
-   TObjArray *fGVolumes;        //! list of runtime volumes
+   TObjArray *fGShapes;         ///<! list of runtime shapes
+   TObjArray *fGVolumes;        ///<! list of runtime volumes
    TObjArray *fTracks;          //-> list of tracks attached to geometry
    TObjArray *fPdgNames;        //-> list of pdg names for tracks
    TObjArray *fGDMLMatrices;    //-> list of matrices read from GDML
@@ -113,7 +113,7 @@ class TGeoManager : public TNamed {
    TObjArray *fNodes;           //-> current branch of nodes
    TObjArray *fOverlaps;        //-> list of geometrical overlaps
    TObjArray *fRegions;         //-> list of regions
-   UChar_t *fBits;              //! bits used for voxelization
+   UChar_t *fBits;              ///<! bits used for voxelization
    // Map of navigator arrays per thread
    typedef std::map<std::thread::id, TGeoNavigatorArray *> NavigatorsMap_t;
    typedef NavigatorsMap_t::iterator NavigatorsMapIt_t;
@@ -122,34 +122,34 @@ class TGeoManager : public TNamed {
    // Map of constant properties
    typedef std::map<std::string, Double_t> ConstPropMap_t;
 
-   NavigatorsMap_t fNavigators;      //! Map between thread id's and navigator arrays
-   static ThreadsMap_t *fgThreadId;  //! Thread id's map
-   static Int_t fgNumThreads;        //! Number of registered threads
-   static Bool_t fgLockNavigators;   //! Lock existing navigators
-   TGeoNavigator *fCurrentNavigator; //! current navigator
-   TGeoVolume *fCurrentVolume;       //! current volume
-   TGeoVolume *fTopVolume;           //! top level volume in geometry
-   TGeoNode *fTopNode;               //! top physical node
+   NavigatorsMap_t fNavigators;      ///<! Map between thread id's and navigator arrays
+   static ThreadsMap_t *fgThreadId;  ///<! Thread id's map
+   static Int_t fgNumThreads;        ///<! Number of registered threads
+   static Bool_t fgLockNavigators;   ///<! Lock existing navigators
+   TGeoNavigator *fCurrentNavigator; ///<! current navigator
+   TGeoVolume *fCurrentVolume;       ///<! current volume
+   TGeoVolume *fTopVolume;           ///<! top level volume in geometry
+   TGeoNode *fTopNode;               ///<! top physical node
    TGeoVolume *fMasterVolume;        // master volume
    TGeoHMatrix *fGLMatrix;           // matrix to be used for view transformations
    TObjArray *fUniqueVolumes;        //-> list of unique volumes
-   TGeoShape *fClippingShape;        //! clipping shape for raytracing
-   TGeoElementTable *fElementTable;  //! table of elements
+   TGeoShape *fClippingShape;        ///<! clipping shape for raytracing
+   TGeoElementTable *fElementTable;  ///<! table of elements
 
    Int_t fNLevel;                     // maximum accepted level in geometry
-   TGeoVolume *fPaintVolume;          //! volume currently painted
-   TGeoVolume *fUserPaintVolume;      //!
-   THashList *fHashVolumes;           //! hash list of volumes providing fast search
-   THashList *fHashGVolumes;          //! hash list of group volumes providing fast search
+   TGeoVolume *fPaintVolume;          ///<! volume currently painted
+   TGeoVolume *fUserPaintVolume;      ///<!
+   THashList *fHashVolumes;           ///<! hash list of volumes providing fast search
+   THashList *fHashGVolumes;          ///<! hash list of group volumes providing fast search
    THashList *fHashPNE;               //-> hash list of physical node entries
-   mutable TObjArray *fArrayPNE;      //! array of physical node entries
+   mutable TObjArray *fArrayPNE;      ///<! array of physical node entries
    Int_t fSizePNEId;                  // size of the array of unique ID's for PN entries
    Int_t fNPNEId;                     // number of PN entries having a unique ID
    Int_t *fKeyPNEId;                  //[fSizePNEId] array of uid values for PN entries
    Int_t *fValuePNEId;                //[fSizePNEId] array of pointers to PN entries with ID's
-   Int_t fMaxThreads;                 //! Max number of threads
-   Bool_t fMultiThread;               //! Flag for multi-threading
-   Int_t fRaytraceMode;               //! Raytrace mode: 0=normal, 1=pass through, 2=transparent
+   Int_t fMaxThreads;                 ///<! Max number of threads
+   Bool_t fMultiThread;               ///<! Flag for multi-threading
+   Int_t fRaytraceMode;               ///<! Raytrace mode: 0=normal, 1=pass through, 2=transparent
    Bool_t fUsePWNav;                  // Activate usage of parallel world in navigation
    TGeoParallelWorld *fParallelWorld; // Parallel world
    ConstPropMap_t fProperties;        // Map of user-defined constant properties

geom/geom/inc/TGeoMaterial.h

@@ -51,8 +51,8 @@ class TGeoMaterial : public TNamed, public TAttFill {
    TGeoElement *fElement;         // pointer to element composing the material
    TList fProperties;             // user-defined properties
    TList fConstProperties;        // user-defined constant properties
-   TGeoExtension *fUserExtension; //! Transient user-defined extension to materials
-   TGeoExtension *fFWExtension;   //! Transient framework-defined extension to materials
+   TGeoExtension *fUserExtension; ///<! Transient user-defined extension to materials
+   TGeoExtension *fFWExtension;   ///<! Transient framework-defined extension to materials
 
    // methods
    TGeoMaterial(const TGeoMaterial &);