Geant4 Cross Reference

Cross-Referencing   Geant4
Geant4/geometry/volumes/include/G4LogicalBorderSurface.hh

Version: [ ReleaseNotes ] [ 1.0 ] [ 1.1 ] [ 2.0 ] [ 3.0 ] [ 3.1 ] [ 3.2 ] [ 4.0 ] [ 4.0.p1 ] [ 4.0.p2 ] [ 4.1 ] [ 4.1.p1 ] [ 5.0 ] [ 5.0.p1 ] [ 5.1 ] [ 5.1.p1 ] [ 5.2 ] [ 5.2.p1 ] [ 5.2.p2 ] [ 6.0 ] [ 6.0.p1 ] [ 6.1 ] [ 6.2 ] [ 6.2.p1 ] [ 6.2.p2 ] [ 7.0 ] [ 7.0.p1 ] [ 7.1 ] [ 7.1.p1 ] [ 8.0 ] [ 8.0.p1 ] [ 8.1 ] [ 8.1.p1 ] [ 8.1.p2 ] [ 8.2 ] [ 8.2.p1 ] [ 8.3 ] [ 8.3.p1 ] [ 8.3.p2 ] [ 9.0 ] [ 9.0.p1 ] [ 9.0.p2 ] [ 9.1 ] [ 9.1.p1 ] [ 9.1.p2 ] [ 9.1.p3 ] [ 9.2 ] [ 9.2.p1 ] [ 9.2.p2 ] [ 9.2.p3 ] [ 9.2.p4 ] [ 9.3 ] [ 9.3.p1 ] [ 9.3.p2 ] [ 9.4 ] [ 9.4.p1 ] [ 9.4.p2 ] [ 9.4.p3 ] [ 9.4.p4 ] [ 9.5 ] [ 9.5.p1 ] [ 9.5.p2 ] [ 9.6 ] [ 9.6.p1 ] [ 9.6.p2 ] [ 9.6.p3 ] [ 9.6.p4 ] [ 10.0 ] [ 10.0.p1 ] [ 10.0.p2 ] [ 10.0.p3 ] [ 10.0.p4 ] [ 10.1 ] [ 10.1.p1 ] [ 10.1.p2 ] [ 10.1.p3 ] [ 10.2 ] [ 10.2.p1 ] [ 10.2.p2 ] [ 10.2.p3 ] [ 10.3 ] [ 10.3.p1 ] [ 10.3.p2 ] [ 10.3.p3 ] [ 10.4 ] [ 10.4.p1 ] [ 10.4.p2 ] [ 10.4.p3 ] [ 10.5 ] [ 10.5.p1 ] [ 10.6 ] [ 10.6.p1 ] [ 10.6.p2 ] [ 10.6.p3 ] [ 10.7 ] [ 10.7.p1 ] [ 10.7.p2 ] [ 10.7.p3 ] [ 10.7.p4 ] [ 11.0 ] [ 11.0.p1 ] [ 11.0.p2 ] [ 11.0.p3, ] [ 11.0.p4 ] [ 11.1 ] [ 11.1.1 ] [ 11.1.2 ] [ 11.1.3 ] [ 11.2 ] [ 11.2.1 ] [ 11.2.2 ] [ 11.3.0 ]

Diff markup

Differences between /geometry/volumes/include/G4LogicalBorderSurface.hh (Version 11.3.0) and /geometry/volumes/include/G4LogicalBorderSurface.hh (Version 3.2)


  1 //                                                  1 //
  2 // *******************************************      2 // ********************************************************************
  3 // * License and Disclaimer                    <<   3 // * DISCLAIMER                                                       *
  4 // *                                                4 // *                                                                  *
  5 // * The  Geant4 software  is  copyright of th <<   5 // * The following disclaimer summarizes all the specific disclaimers *
  6 // * the Geant4 Collaboration.  It is provided <<   6 // * of contributors to this software. The specific disclaimers,which *
  7 // * conditions of the Geant4 Software License <<   7 // * govern, are listed with their locations in:                      *
  8 // * LICENSE and available at  http://cern.ch/ <<   8 // *   http://cern.ch/geant4/license                                  *
  9 // * include a list of copyright holders.      << 
 10 // *                                                9 // *                                                                  *
 11 // * Neither the authors of this software syst     10 // * Neither the authors of this software system, nor their employing *
 12 // * institutes,nor the agencies providing fin     11 // * institutes,nor the agencies providing financial support for this *
 13 // * work  make  any representation or  warran     12 // * work  make  any representation or  warranty, express or implied, *
 14 // * regarding  this  software system or assum     13 // * regarding  this  software system or assume any liability for its *
 15 // * use.  Please see the license in the file  <<  14 // * use.                                                             *
 16 // * for the full disclaimer and the limitatio << 
 17 // *                                               15 // *                                                                  *
 18 // * This  code  implementation is the result  <<  16 // * This  code  implementation is the  intellectual property  of the *
 19 // * technical work of the GEANT4 collaboratio <<  17 // * GEANT4 collaboration.                                            *
 20 // * By using,  copying,  modifying or  distri <<  18 // * By copying,  distributing  or modifying the Program (or any work *
 21 // * any work based  on the software)  you  ag <<  19 // * based  on  the Program)  you indicate  your  acceptance of  this *
 22 // * use  in  resulting  scientific  publicati <<  20 // * statement, and all its terms.                                    *
 23 // * acceptance of all terms of the Geant4 Sof << 
 24 // *******************************************     21 // ********************************************************************
 25 //                                                 22 //
 26 // G4LogicalBorderSurface                      <<  23 //
                                                   >>  24 // $Id: G4LogicalBorderSurface.hh,v 1.6.2.1 2001/06/28 19:09:38 gunter Exp $
                                                   >>  25 // GEANT4 tag $Name:  $
                                                   >>  26 //
                                                   >>  27 ////////////////////////////////////////////////////////////////////////
                                                   >>  28 // class G4LogicalBorderSurface
                                                   >>  29 ////////////////////////////////////////////////////////////////////////
 27 //                                                 30 //
 28 // Class description:                              31 // Class description:
 29 //                                                 32 //
 30 // A Logical Surface class for surfaces define     33 // A Logical Surface class for surfaces defined by the boundary
 31 // of two physical volumes.                        34 // of two physical volumes.
 32                                                    35 
 33 // Author: John Apostolakis, CERN - 17-06-1997 <<  36 // History:
 34 // ------------------------------------------- <<  37 // -------
 35 #ifndef G4LogicalBorderSurface_hh              <<  38 // Created:     1997-06-17
 36 #define G4LogicalBorderSurface_hh 1            <<  39 // Author:      John Apostolakis
                                                   >>  40 // mail:        John.Apostolakis@cern.ch
                                                   >>  41 // Modified:    1997-06-16  John Apostolakis
                                                   >>  42 //
                                                   >>  43 ////////////////////////////////////////////////////////////////////////
 37                                                    44 
 38 #include <map>                                 <<  45 #ifndef G4LogicalBorderSurface_h
                                                   >>  46 #define G4LogicalBorderSurface_h 1
 39                                                    47 
 40 #include "G4LogicalSurface.hh"                 <<  48 /////////////
                                                   >>  49 // Includes
                                                   >>  50 /////////////
                                                   >>  51 
                                                   >>  52 #include  "G4LogicalSurface.hh"
 41 #include "G4VPhysicalVolume.hh"                    53 #include "G4VPhysicalVolume.hh"
 42                                                    54 
                                                   >>  55 #include "g4std/vector"
                                                   >>  56 
                                                   >>  57 class G4Event;
                                                   >>  58 
 43 class G4VPhysicalVolume;                           59 class G4VPhysicalVolume;
 44 class G4LogicalBorderSurface;                  << 
 45                                                    60 
 46 using G4LogicalBorderSurfaceTable              <<  61 /////////////////////
 47       = std::map<std::pair<const G4VPhysicalVo <<  62 // Class Definition
 48                            const G4VPhysicalVo <<  63 /////////////////////
 49                                                    64 
 50 class G4LogicalBorderSurface : public G4Logica <<  65 class G4LogicalBorderSurface: public G4LogicalSurface
 51 {                                                  66 {
                                                   >>  67         ////////////////////////////////
                                                   >>  68         // Constructors and Destructor
                                                   >>  69         ////////////////////////////////
 52   public:                                          70   public:
 53                                                    71 
 54     G4LogicalBorderSurface( const G4String& na <<  72   G4LogicalBorderSurface(const G4String& name,
 55                                   G4VPhysicalV <<  73              G4VPhysicalVolume* vol1, 
 56                                   G4VPhysicalV <<  74              G4VPhysicalVolume* vol2,
 57                                   G4SurfacePro <<  75              G4OpticalSurface* opticsSurface);
 58     ~G4LogicalBorderSurface() override;        <<  76 
 59       // Constructor and destructor            <<  77   ~G4LogicalBorderSurface();
 60                                                <<  78 
 61     G4LogicalBorderSurface(const G4LogicalBord <<  79   ////////////
 62     G4LogicalBorderSurface& operator=(const G4 <<  80   // Methods
 63       // Copy constructor and assignment opera <<  81         ////////////
 64                                                <<  82 
 65     G4bool operator==( const G4LogicalBorderSu <<  83   public:
 66     G4bool operator!=( const G4LogicalBorderSu <<  84 
 67       // Operators                             <<  85   static G4LogicalBorderSurface* GetSurface(const G4VPhysicalVolume* vol1,
 68                                                <<  86                     const G4VPhysicalVolume* vol2);
 69     static G4LogicalBorderSurface* GetSurface( <<  87 
 70                                                <<  88   inline void  SetPhysicalVolumes(G4VPhysicalVolume* vol1,
 71     inline void SetPhysicalVolumes( G4VPhysica <<  89               G4VPhysicalVolume* vol2);
 72                                     G4VPhysica <<  90 
 73     inline const G4VPhysicalVolume* GetVolume1 <<  91   inline const G4VPhysicalVolume* GetVolume1() const;
 74     inline const G4VPhysicalVolume* GetVolume2 <<  92   inline const G4VPhysicalVolume* GetVolume2() const;
 75     inline std::size_t GetIndex() const;       <<  93 
 76       // Generic accessors                     <<  94   inline void SetVolume1(G4VPhysicalVolume* vol1);
 77                                                <<  95   inline void SetVolume2(G4VPhysicalVolume* vol2);
 78     inline void SetVolume1( G4VPhysicalVolume* <<  96           // These are potentially dangerous.
 79     inline void SetVolume2( G4VPhysicalVolume* <<  97 
 80       // To use with care!                     <<  98         static const G4std::vector<G4LogicalBorderSurface*> *GetSurfaceTable();
 81                                                <<  99         static size_t GetNumberOfBorderSurfaces();
 82     static void CleanSurfaceTable();           << 100   static void DumpInfo(); 
 83     static const G4LogicalBorderSurfaceTable*  << 101     //   Methods dealing with the table of surfaces.
 84     static std::size_t GetNumberOfBorderSurfac << 102 
 85     static void DumpInfo();                    << 103         //////////////
 86       // To handle the table of surfaces       << 104         // Operators
                                                   >> 105         //////////////
                                                   >> 106 
                                                   >> 107   G4int operator==(const G4LogicalBorderSurface &right) const;
                                                   >> 108   G4int operator!=(const G4LogicalBorderSurface &right) const;
 87                                                   109 
 88   private:                                        110   private:
 89                                                   111 
 90     G4VPhysicalVolume* Volume1;  // Physical V << 112         G4LogicalBorderSurface(const G4LogicalBorderSurface &right);
 91     G4VPhysicalVolume* Volume2;  // Physical V << 113   const G4LogicalBorderSurface & operator=(const G4LogicalBorderSurface &right);
 92                                                   114 
 93     std::size_t Index;           // Creation o << 115   // ------------------
                                                   >> 116   // Basic data members ( To define a 'logical' surface)
                                                   >> 117   // ------------------
                                                   >> 118 
                                                   >> 119   private:
 94                                                   120 
 95     static G4LogicalBorderSurfaceTable *theBor << 121   G4VPhysicalVolume* Volume1; // Physical Volume pointer on side 1
 96       // The static Table of BorderSurfaces    << 122   G4VPhysicalVolume* Volume2; // Physical Volume pointer on side 2
                                                   >> 123 
                                                   >> 124   static G4std::vector<G4LogicalBorderSurface*> theBorderSurfaceTable;
                                                   >> 125           // The static Table of Surfaces
 97 };                                                126 };
 98                                                   127 
 99 // ******************************************* << 128 typedef G4std::vector<G4LogicalBorderSurface*> G4LogicalBorderSurfaceTable;
                                                   >> 129 
                                                   >> 130 ////////////////////
100 // Inline methods                                 131 // Inline methods
101 // ******************************************* << 132 ////////////////////
102                                                   133 
103 #include "G4LogicalBorderSurface.icc"             134 #include "G4LogicalBorderSurface.icc"
104                                                   135 
105 #endif                                         << 136 #endif /* G4LogicalBorderSurface_h */
106                                                   137