// // ******************************************************************** // * License and Disclaimer * // * * // * The Geant4 software is copyright of the Copyright Holders of * // * the Geant4 Collaboration. It is provided under the terms and * // * conditions of the Geant4 Software License, included in the file * // * LICENSE and available at http://cern.ch/geant4/license . These * // * include a list of copyright holders. * // * * // * Neither the authors of this software system, nor their employing * // * institutes,nor the agencies providing financial support for this * // * work make any representation or warranty, express or implied, * // * regarding this software system or assume any liability for its * // * use. Please see the license in the file LICENSE and URL above * // * for the full disclaimer and the limitation of liability. * // * * // * This code implementation is the result of the scientific and * // * technical work of the GEANT4 collaboration. * // * By using, copying, modifying or distributing the software (or * // * any work based on the software) you agree to acknowledge its * // * use in resulting scientific publications, and indicate your * // * acceptance of all terms of the Geant4 Software license. * // ******************************************************************** // // // $Id: G4LogicalVolume.icc,v 1.25 2008/07/10 09:40:08 gcosmo Exp $ // GEANT4 tag $Name: geant4-09-04-beta-01 $ // // // class G4LogicalVolume Inline Implementation file // // 10.20.97 - P. MoraDeFreitas : Added SetFastSimulation method. // 05.11.98 - M. Verderi: Add Get/Set methods for fBiasWeight // 09.11.98 - J. Apostolakis: Changed MagneticField to FieldManager // 12.02.99 - S.Giani: Added set/get methods for voxelization quality // 18.04.01 - G.Cosmo: Migrated to STL vector // 17.05.02 - G.Cosmo: Added IsToOptimise() method // -------------------------------------------------------------------- // ******************************************************************** // GetName // ******************************************************************** // inline G4String G4LogicalVolume::GetName() const { return fName; } // ******************************************************************** // SetName // ******************************************************************** // inline void G4LogicalVolume::SetName(const G4String& pName) { fName = pName; } // ******************************************************************** // GetFieldManager // ******************************************************************** // inline G4FieldManager* G4LogicalVolume::GetFieldManager() const { return fFieldManager; } // ******************************************************************** // GetNoDaughters // ******************************************************************** // inline G4int G4LogicalVolume::GetNoDaughters() const { return fDaughters.size(); } // ******************************************************************** // GetDaughter // ******************************************************************** // inline G4VPhysicalVolume* G4LogicalVolume::GetDaughter(const G4int i) const { return fDaughters[i]; } // ******************************************************************** // GetFastSimulationManager // ******************************************************************** // inline G4FastSimulationManager* G4LogicalVolume::GetFastSimulationManager () const { G4FastSimulationManager* fFSM = 0; if(fRegion) fFSM = fRegion->GetFastSimulationManager(); return fFSM; } // ******************************************************************** // AddDaughter // ******************************************************************** // inline void G4LogicalVolume::AddDaughter(G4VPhysicalVolume* pNewDaughter) { if( !fDaughters.empty() && fDaughters[0]->IsReplicated() ) { G4cerr << "ERROR - Attempt to place a volume in a mother volume" << G4endl << " already containing a replicated volume." << G4endl << " A volume can either contain several placements" << G4endl << " or a unique replica or parameterised volume !" << G4endl << " Mother logical volume: " << GetName() << G4endl << " Placing volume: " << pNewDaughter->GetName() << G4endl; G4Exception("G4LogicalVolume::AddDaughter()", "InvalidSetup", FatalException, "Replica or parameterised volume must be the only daughter !"); } fMass = 0.; fDaughters.push_back(pNewDaughter); G4LogicalVolume* pDaughterLogical = pNewDaughter->GetLogicalVolume(); // Propagate the Field Manager, if the daughter has no field Manager. // G4FieldManager* pDaughterFieldManager = pDaughterLogical->GetFieldManager(); if( pDaughterFieldManager == 0 ) { pDaughterLogical->SetFieldManager(fFieldManager, true); } if (fRegion) { PropagateRegion(); fRegion->RegionModified(true); } } // ******************************************************************** // IsDaughter // ******************************************************************** // inline G4bool G4LogicalVolume::IsDaughter(const G4VPhysicalVolume* p) const { G4PhysicalVolumeList::const_iterator i; for ( i=fDaughters.begin(); i!=fDaughters.end(); ++i ) { if (**i==*p) return true; } return false; } // ******************************************************************** // RemoveDaughter // ******************************************************************** // inline void G4LogicalVolume::RemoveDaughter(const G4VPhysicalVolume* p) { G4PhysicalVolumeList::iterator i; for ( i=fDaughters.begin(); i!=fDaughters.end(); ++i ) { if (**i==*p) { fDaughters.erase(i); break; } } if (fRegion) { fRegion->RegionModified(true); } fMass = 0.; } // ******************************************************************** // ClearDaughters // ******************************************************************** // inline void G4LogicalVolume::ClearDaughters() { G4PhysicalVolumeList::iterator i; for ( i=fDaughters.begin(); i!=fDaughters.end(); ++i ) { fDaughters.erase(i); } if (fRegion) { fRegion->RegionModified(true); } fMass = 0.; } // ******************************************************************** // GetSolid // ******************************************************************** // inline G4VSolid* G4LogicalVolume::GetSolid() const { return fSolid; } // ******************************************************************** // SetSolid // ******************************************************************** // inline void G4LogicalVolume::SetSolid(G4VSolid *pSolid) { assert(pSolid != 0); fSolid=pSolid; fMass = 0.; } // ******************************************************************** // GetMaterial // ******************************************************************** // inline G4Material* G4LogicalVolume::GetMaterial() const { return fMaterial; } // ******************************************************************** // SetMaterial // ******************************************************************** // inline void G4LogicalVolume::SetMaterial(G4Material *pMaterial) { fMaterial=pMaterial; fMass = 0.; } // ******************************************************************** // UpdateMaterial // ******************************************************************** // inline void G4LogicalVolume::UpdateMaterial(G4Material *pMaterial) { fMaterial=pMaterial; if(fRegion) { fCutsCouple = fRegion->FindCouple(pMaterial); } fMass = 0.; } // ******************************************************************** // GetSensitiveDetector // ******************************************************************** // inline G4VSensitiveDetector* G4LogicalVolume::GetSensitiveDetector() const { return fSensitiveDetector; } // ******************************************************************** // SetSensitiveDetector // ******************************************************************** // inline void G4LogicalVolume::SetSensitiveDetector(G4VSensitiveDetector* pSDetector) { fSensitiveDetector = pSDetector; } // ******************************************************************** // GetUserLimits // ******************************************************************** // inline G4UserLimits* G4LogicalVolume::GetUserLimits() const { if(fUserLimits) return fUserLimits; if(fRegion) return fRegion->GetUserLimits(); return 0; } // ******************************************************************** // SetUserLimits // ******************************************************************** // inline void G4LogicalVolume::SetUserLimits(G4UserLimits* pULimits) { fUserLimits = pULimits; } // ******************************************************************** // GetVoxelHeader // ******************************************************************** // inline G4SmartVoxelHeader* G4LogicalVolume::GetVoxelHeader() const { return fVoxel; } // ******************************************************************** // SetVoxelHeader // ******************************************************************** // inline void G4LogicalVolume::SetVoxelHeader(G4SmartVoxelHeader* pVoxel) { fVoxel = pVoxel; } // ******************************************************************** // GetSmartless // ******************************************************************** // inline G4double G4LogicalVolume::GetSmartless() const { return fSmartless; } // ******************************************************************** // SetSmartless // ******************************************************************** // inline void G4LogicalVolume::SetSmartless(G4double s) { fSmartless = s; } // ******************************************************************** // IsToOptimise // ******************************************************************** // inline G4bool G4LogicalVolume::IsToOptimise() const { return fOptimise; } // ******************************************************************** // SetOptimisation // ******************************************************************** // inline void G4LogicalVolume::SetOptimisation(G4bool optim) { fOptimise = optim; } // ******************************************************************** // IsRootRegion // ******************************************************************** // inline G4bool G4LogicalVolume::IsRootRegion() const { return fRootRegion; } // ******************************************************************** // SetRegionRootFlag // ******************************************************************** // inline void G4LogicalVolume::SetRegionRootFlag(G4bool rreg) { fRootRegion = rreg; } // ******************************************************************** // IsRegion // ******************************************************************** // inline G4bool G4LogicalVolume::IsRegion() const { G4bool reg = false; if (fRegion) reg = true; return reg; } // ******************************************************************** // SetRegion // ******************************************************************** // inline void G4LogicalVolume::SetRegion(G4Region* reg) { fRegion = reg; } // ******************************************************************** // GetRegion // ******************************************************************** // inline G4Region* G4LogicalVolume::GetRegion() const { return fRegion; } // ******************************************************************** // PropagateRegion // ******************************************************************** // inline void G4LogicalVolume::PropagateRegion() { fRegion->ScanVolumeTree(this, true); } // ******************************************************************** // GetMaterialCutsCouple // ******************************************************************** // inline const G4MaterialCutsCouple* G4LogicalVolume::GetMaterialCutsCouple() const { return fCutsCouple; } // ******************************************************************** // SetMaterialCutsCouple // ******************************************************************** // inline void G4LogicalVolume::SetMaterialCutsCouple(G4MaterialCutsCouple* cuts) { fCutsCouple = cuts; } // ******************************************************************** // Lock // ******************************************************************** // inline void G4LogicalVolume::Lock() { fLock = true; } // ******************************************************************** // Operator == // ******************************************************************** // inline G4bool G4LogicalVolume::operator == ( const G4LogicalVolume& lv) const { return (this==&lv) ? true : false; } // ******************************************************************** // GetVisAttributes // ******************************************************************** // inline const G4VisAttributes* G4LogicalVolume::GetVisAttributes () const { return fVisAttributes; } // ******************************************************************** // SetVisAttributes // ******************************************************************** // inline void G4LogicalVolume::SetVisAttributes (const G4VisAttributes* pVA) { fVisAttributes = pVA; } // ******************************************************************** // SetBiasWeight // ******************************************************************** // inline void G4LogicalVolume::SetBiasWeight(G4double w) { fBiasWeight = w; } // ******************************************************************** // GetBiasWeight // ******************************************************************** // inline G4double G4LogicalVolume::GetBiasWeight() const { return fBiasWeight; }