Geant4 Cross Reference |
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 // ******************************************************************** >> 22 // >> 23 // >> 24 // $Id: G4PVPlacement.hh,v 1.2 2003/11/02 16:06:05 gcosmo Exp $ >> 25 // GEANT4 tag $Name: geant4-06-00-patch-01 $ >> 26 // 25 // 27 // 26 // G4PVPlacement << 28 // class G4PVPlacement 27 // 29 // 28 // Class description: 30 // Class description: 29 // 31 // 30 // Class representing a single volume position 32 // Class representing a single volume positioned within and relative 31 // to a mother volume. 33 // to a mother volume. 32 34 33 // 24.07.95 P.Kent, First non-stub version. << 35 // History: >> 36 // 24.07.95 P.Kent First non-stub version >> 37 // 25.07.96 P.Kent Modified interface for new `Replica' capable geometry >> 38 // 28.08.96 P.Kent Tidied + transform replaced by rotmat+vector >> 39 // 28.02.97 J.Apostolakis Added 2nd constructor with G4Transform3D of solid. >> 40 // 11.07.97 J.Apostolakis Added 3rd constructor with pMotherLogical >> 41 // 11.05.98 J.Apostolakis Added 4th constructor with G4Transform3D & pMotherLV 34 // ------------------------------------------- 42 // ---------------------------------------------------------------------- 35 #ifndef G4PVPLACEMENT_HH 43 #ifndef G4PVPLACEMENT_HH 36 #define G4PVPLACEMENT_HH 1 << 44 #define G4PVPLACEMENT_HH 37 45 38 #include "G4VPhysicalVolume.hh" 46 #include "G4VPhysicalVolume.hh" 39 #include "G4Transform3D.hh" 47 #include "G4Transform3D.hh" 40 48 41 class G4PVPlacement : public G4VPhysicalVolume 49 class G4PVPlacement : public G4VPhysicalVolume 42 { 50 { 43 public: << 51 public: // with description 44 52 45 G4PVPlacement(G4RotationMatrix* pRot, << 53 G4PVPlacement(G4RotationMatrix *pRot, 46 const G4ThreeVector& tlate, << 54 const G4ThreeVector &tlate, 47 G4LogicalVolume* pCurrentLog << 55 G4LogicalVolume *pCurrentLogical, 48 const G4String& pName, 56 const G4String& pName, 49 G4LogicalVolume* pMotherLogi << 57 G4LogicalVolume *pMotherLogical, 50 G4bool pMany, 58 G4bool pMany, 51 G4int pCopyNo, << 59 G4int pCopyNo); 52 G4bool pSurfChk = false); << 53 // Initialise a single volume, positione 60 // Initialise a single volume, positioned in a frame which is rotated by 54 // *pRot and traslated by tlate, relativ 61 // *pRot and traslated by tlate, relative to the coordinate system of the 55 // mother volume pMotherLogical. 62 // mother volume pMotherLogical. 56 // If pRot=nullptr the volume is unrotat << 63 // If pRot=0 the volume is unrotated with respect to its mother. 57 // The physical volume is added to the m 64 // The physical volume is added to the mother's logical volume. 58 // Arguments particular to G4PVPlacement 65 // Arguments particular to G4PVPlacement: 59 // pMany Currently NOT used. For futur 66 // pMany Currently NOT used. For future use to identify if the volume 60 // is meant to be considered an 67 // is meant to be considered an overlapping structure, or not. 61 // pCopyNo should be set to 0 for the 68 // pCopyNo should be set to 0 for the first volume of a given type. 62 // pSurfChk if true activates check fo << 63 // This is a very natural way of definin 69 // This is a very natural way of defining a physical volume, and is 64 // especially useful when creating subde 70 // especially useful when creating subdetectors: the mother volumes are 65 // not placed until a later stage of the 71 // not placed until a later stage of the assembly program. 66 72 67 G4PVPlacement(const G4Transform3D& Transfo << 73 G4PVPlacement(const G4Transform3D &Transform3D, 68 G4LogicalVolume* pCurr << 74 G4LogicalVolume *pCurrentLogical, 69 const G4String& pName, 75 const G4String& pName, 70 G4LogicalVolume* pMoth << 76 G4LogicalVolume *pMotherLogical, 71 G4bool pMany, 77 G4bool pMany, 72 G4int pCopyNo, << 78 G4int pCopyNo); 73 G4bool pSurfChk = fals << 74 // Additional constructor, which expects 79 // Additional constructor, which expects a G4Transform3D that represents 75 // the direct rotation and translation o 80 // the direct rotation and translation of the solid (NOT of the frame). 76 // The G4Transform3D argument should be 81 // The G4Transform3D argument should be constructed by: 77 // i) First rotating it to align the so 82 // i) First rotating it to align the solid to the system of 78 // reference of its mother volume *p 83 // reference of its mother volume *pMotherLogical, and 79 // ii) Then placing the solid at the loc 84 // ii) Then placing the solid at the location Transform3D.getTranslation(), 80 // with respect to the origin of the 85 // with respect to the origin of the system of coordinates of the 81 // mother volume. 86 // mother volume. 82 // [ This is useful for the people who p 87 // [ This is useful for the people who prefer to think in terms 83 // of moving objects in a given refere 88 // of moving objects in a given reference frame. ] 84 // All other arguments are the same as f 89 // All other arguments are the same as for the previous constructor. 85 90 86 G4PVPlacement(G4RotationMatrix* pRot, << 91 public: // without description 87 const G4ThreeVector& tlate, << 92 88 const G4String& pName, << 93 G4PVPlacement(G4RotationMatrix *pRot, 89 G4LogicalVolume* pLogical, << 94 const G4ThreeVector &tlate, 90 G4VPhysicalVolume* pMother, << 95 const G4String &pName, >> 96 G4LogicalVolume *pLogical, >> 97 G4VPhysicalVolume *pMother, 91 G4bool pMany, 98 G4bool pMany, 92 G4int pCopyNo, << 99 G4int pCopyNo); 93 G4bool pSurfChk = false); << 94 // A simple variation of the 1st constru 100 // A simple variation of the 1st constructor, only specifying the 95 // mother volume as a pointer to its phy 101 // mother volume as a pointer to its physical volume instead of its 96 // logical volume. The effect is exactly 102 // logical volume. The effect is exactly the same. 97 103 98 G4PVPlacement(const G4Transform3D& Transfo << 104 G4PVPlacement(const G4Transform3D &Transform3D, 99 const G4String& pName, << 105 const G4String &pName, 100 G4LogicalVolume* pLogi << 106 G4LogicalVolume *pLogical, 101 G4VPhysicalVolume* pMo << 107 G4VPhysicalVolume *pMother, 102 G4bool pMany, 108 G4bool pMany, 103 G4int pCopyNo, << 109 G4int pCopyNo); 104 G4bool pSurfChk = fals << 105 // Utilises both variations above (from 110 // Utilises both variations above (from 2nd and 3rd constructor). 106 // The effect is the same as for the 2nd 111 // The effect is the same as for the 2nd constructor. 107 112 108 ~G4PVPlacement() override; << 113 public: // with description 109 // Default destructor. << 110 114 111 inline G4int GetCopyNo() const override { << 115 virtual ~G4PVPlacement(); >> 116 // Default destructor. 112 117 113 void SetCopyNo(G4int CopyNo) override; << 118 G4int GetCopyNo() const; >> 119 void SetCopyNo(G4int CopyNo); 114 // Gets and sets the copy number of the 120 // Gets and sets the copy number of the volume. 115 121 116 G4bool CheckOverlaps(G4int res = 1000, G4d << 122 public: // without description 117 G4bool verbose = true << 123 118 // Verifies if the placed volume is over << 124 G4bool IsMany() const; 119 // daughters or with the mother volume. << 125 G4bool IsReplicated() const; 120 // for the number of points to be genera << 126 G4bool IsParameterised() const; 121 // A tolerance for the precision of the << 127 G4VPVParameterisation* GetParameterisation() const; 122 // by default it is set to maximum preci << 123 // Reports a maximum of overlaps errors << 124 // Returns true if the volume is overlap << 125 << 126 G4PVPlacement(__void__&); << 127 // Fake default constructor for usage re << 128 // persistency for clients requiring pre << 129 // persistifiable objects. << 130 << 131 G4PVPlacement(const G4PVPlacement&) = dele << 132 G4PVPlacement& operator=(const G4PVPlaceme << 133 // Copy constructor and assignment opera << 134 << 135 G4bool IsMany() const override; << 136 G4bool IsReplicated() const override; << 137 G4bool IsParameterised() const override; << 138 G4VPVParameterisation* GetParameterisation << 139 void GetReplicationData(EAxis& axis, 128 void GetReplicationData(EAxis& axis, 140 G4int& nReplicas, 129 G4int& nReplicas, 141 G4double& width, 130 G4double& width, 142 G4double& offset, 131 G4double& offset, 143 G4bool& consuming) << 132 G4bool& consuming) const; 144 G4bool IsRegularStructure() const override << 145 G4int GetRegularStructureId() const overri << 146 133 147 EVolume VolumeType() const override; << 148 << 149 private: 134 private: 150 135 151 static G4RotationMatrix* NewPtrRotMatrix(c << 136 static G4RotationMatrix* NewPtrRotMatrix(const G4RotationMatrix &RotMat); 152 // Auxiliary function for 2nd constructo 137 // Auxiliary function for 2nd constructor (one with G4Transform3D). 153 // Creates a new RotMatrix on the heap ( 138 // Creates a new RotMatrix on the heap (using "new") and copies 154 // its argument into it. 139 // its argument into it. 155 140 >> 141 G4PVPlacement(const G4PVPlacement&); >> 142 G4PVPlacement& operator=(const G4PVPlacement&); >> 143 // Private copy constructor and assignment operator. >> 144 156 private: 145 private: 157 146 158 G4bool fmany = false; // flag for overla << 147 G4bool fmany; // flag for overlapping structure - not used 159 G4bool fallocatedRotM = false; // flag fo << 148 G4bool fallocatedRotM; // flag for allocation of Rotation Matrix 160 G4int fcopyNo = 0; // for identificat << 149 G4int fcopyNo; // for identification >> 150 161 }; 151 }; 162 152 163 #endif 153 #endif >> 154 164 155