| Geant4 Cross Reference |
>> 1 // This code implementation is the intellectual property of
>> 2 // the GEANT4 collaboration.
1 // 3 //
2 // ******************************************* << 4 // By copying, distributing or modifying the Program (or any work
3 // * License and Disclaimer << 5 // based on the Program) you indicate your acceptance of this statement,
4 // * << 6 // and all its terms.
5 // * The Geant4 software is copyright of th <<
6 // * the Geant4 Collaboration. It is provided <<
7 // * conditions of the Geant4 Software License <<
8 // * LICENSE and available at http://cern.ch/ <<
9 // * include a list of copyright holders. <<
10 // * <<
11 // * Neither the authors of this software syst <<
12 // * institutes,nor the agencies providing fin <<
13 // * work make any representation or warran <<
14 // * regarding this software system or assum <<
15 // * use. Please see the license in the file <<
16 // * for the full disclaimer and the limitatio <<
17 // * <<
18 // * This code implementation is the result <<
19 // * technical work of the GEANT4 collaboratio <<
20 // * By using, copying, modifying or distri <<
21 // * any work based on the software) you ag <<
22 // * use in resulting scientific publicati <<
23 // * acceptance of all terms of the Geant4 Sof <<
24 // ******************************************* <<
25 // 7 //
26 // G4LogicalSkinSurface << 8 // $Id: G4LogicalSkinSurface.hh,v 1.2.2.1 1999/12/07 20:48:39 gunter Exp $
>> 9 // GEANT4 tag $Name: geant4-01-00 $
27 // 10 //
28 // Class description: << 11 ////////////////////////////////////////////////////////////////////////
>> 12 // G4LogicalSkinSurface Definition
>> 13 ////////////////////////////////////////////////////////////////////////
29 // 14 //
30 // A Logical Surface class for the surface sur << 15 // File: G4LogicalSkinSurface.hh
31 // volume. << 16 // Description: A Logical Surface class for the surface
>> 17 // surrounding a single logical volume.
>> 18 // Version: 1.0
>> 19 // Created: 1997-06-16
>> 20 // Author: John Apostolakis
>> 21 // mail: John.Apostolakis@cern.ch
>> 22 // Modified: 1997-06-16 John Apostolakis
>> 23 //
>> 24 // Id tag:
>> 25 ////////////////////////////////////////////////////////////////////////
32 26
33 // Author: John Apostolakis, CERN - 16-06-1997 << 27 #ifndef G4LogicalSkinSurface_h
34 // ------------------------------------------- << 28 #define G4LogicalSkinSurface_h 1
35 #ifndef G4LogicalSkinSurface_hh <<
36 #define G4LogicalSkinSurface_hh 1 <<
37 29
38 #include <map> << 30 /////////////
>> 31 // Includes
>> 32 /////////////
39 33
40 #include "G4LogicalSurface.hh" 34 #include "G4LogicalSurface.hh"
>> 35 #include "G4LogicalVolume.hh"
>> 36
>> 37 // G4RWTPtrOrderedVector
>> 38 #include "g4rw/tpordvec.h"
>> 39
41 40
42 class G4LogicalVolume; << 41 /////////////////////
43 class G4LogicalSkinSurface; << 42 // Class Definition
>> 43 /////////////////////
44 44
45 using G4LogicalSkinSurfaceTable <<
46 = std::map<const G4LogicalVolume*, G4Log <<
47 45
48 class G4LogicalSkinSurface : public G4LogicalS 46 class G4LogicalSkinSurface : public G4LogicalSurface
49 { 47 {
50 public: <<
51 48
52 G4LogicalSkinSurface( const G4String& name << 49 public:
53 G4LogicalVolum <<
54 G4SurfacePrope <<
55 ~G4LogicalSkinSurface() override; <<
56 // Constructor and destructor. <<
57 <<
58 G4LogicalSkinSurface(const G4LogicalSkinSu <<
59 G4LogicalSkinSurface& operator=(const G4Lo <<
60 // Assignment and copying not allowed. <<
61 <<
62 G4bool operator==(const G4LogicalSkinSurfa <<
63 G4bool operator!=(const G4LogicalSkinSurfa <<
64 // Operators. <<
65 <<
66 static G4LogicalSkinSurface* GetSurface(co <<
67 inline const G4LogicalVolume* GetLogicalVo <<
68 inline void SetLogicalVolume(G4LogicalVol <<
69 // Accessors. <<
70 <<
71 static void CleanSurfaceTable(); <<
72 static const G4LogicalSkinSurfaceTable* Ge <<
73 static std::size_t GetNumberOfSkinSurfaces <<
74 static void DumpInfo(); // const <<
75 // To handle with the table of surfaces. <<
76 50
77 private: << 51 ////////////////////////////////
>> 52 // Constructors and Destructor
>> 53 ////////////////////////////////
78 54
79 G4LogicalVolume* LogVolume; << 55 // Is the name meaningful for the logical skin surface ?
80 // Logical Volume pointer on side 1. <<
81 56
82 static G4LogicalSkinSurfaceTable *theSkinS << 57 G4LogicalSkinSurface(const G4String& name, G4LogicalVolume* vol,
83 // The static Table of SkinSurfaces. << 58 G4OpticalSurface* opticalSurface);
84 }; << 59
>> 60 ~G4LogicalSkinSurface();
>> 61
>> 62 ////////////
>> 63 // Methods
>> 64 ////////////
>> 65 public:
>> 66 // public methods
>> 67
>> 68 static G4LogicalSkinSurface* GetSurface(const G4LogicalVolume* vol);
>> 69
>> 70 G4LogicalVolume* GetLogicalVolume() const {return LogVolume;};
>> 71 void SetLogicalVolume(G4LogicalVolume* vol)
>> 72 {LogVolume = vol;};
85 73
86 // ******************************************* <<
87 // Inline methods <<
88 // ******************************************* <<
89 74
90 #include "G4LogicalSkinSurface.icc" << 75 // Methods dealing with the table of surfaces.
>> 76 //
>> 77 static size_t GetNumberOfSkinSurfaces()
>> 78 { return theSurfaceTable.length(); };
>> 79 static void DumpInfo(); // const
91 80
>> 81 #if THESE_ARE_NEEDED
>> 82 // static const G4RWTPtrOrderedVector<G4LogicalSkinSurface>*
>> 83 // GetSurfaceTable()
>> 84 // { return &theSurfaceTable; };
>> 85
>> 86 size_t GetIndex() const { return theIndexInTable; };
92 #endif 87 #endif
93 88
>> 89 //////////////
>> 90 // Operators
>> 91 //////////////
>> 92 public:
>> 93 G4int operator==(const G4LogicalSkinSurface &right) const;
>> 94 G4int operator!=(const G4LogicalSkinSurface &right) const;
>> 95
>> 96 private:
>> 97 // Assignment and copying must be denied.
>> 98 G4LogicalSkinSurface(const G4LogicalSkinSurface &right);
>> 99 const G4LogicalSkinSurface & operator=(const G4LogicalSkinSurface &right);
>> 100
>> 101 // ------------------
>> 102 // Basic data members ( To define a 'logical' surface)
>> 103 // ------------------
>> 104 private:
>> 105 G4LogicalVolume* LogVolume; // Logical Volume pointer on side 1
>> 106
>> 107 // The static Table of Surfaces
>> 108 static G4RWTPtrOrderedVector<G4LogicalSkinSurface> theSurfaceTable;
>> 109 // static G4LogicalSkinSurfaceTable theSurfaceTable;
>> 110
>> 111 size_t theIndexInTable; // Index of surface in the surface table
>> 112
>> 113 };
>> 114
>> 115 typedef G4RWTPtrOrderedVector<G4LogicalSkinSurface> G4LogicalSkinSurfaceTable;
>> 116
>> 117 ////////////////////
>> 118 // Inline methods
>> 119 ////////////////////
>> 120
>> 121 #endif /* G4LogicalSkinSurface_h */
94 122