lars/geant4
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Import Geant4 6.2.0 source tree

Browse Source
This commit is contained in:
Gabriele Cosmo
2016-06-09 10:56:29 +02:00
parent 1d812b78b1
commit e083ffb441
1415 changed files with 111223 additions and 21207 deletions
Download Patch File Download Diff File Expand all files Collapse all files
source/geometry/solids/Boolean/include/G4ReflectedSolid.hh
-151
View File
@@ -1,151 +0,0 @@
//
// ********************************************************************
// * DISCLAIMER *
// * *
// * The following disclaimer summarizes all the specific disclaimers *
// * of contributors to this software. The specific disclaimers,which *
// * govern, are listed with their locations in: *
// * http://cern.ch/geant4/license *
// * *
// * 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. *
// * *
// * This code implementation is the intellectual property of the *
// * GEANT4 collaboration. *
// * By copying, distributing or modifying the Program (or any work *
// * based on the Program) you indicate your acceptance of this *
// * statement, and all its terms. *
// ********************************************************************
//
//
// $Id: G4ReflectedSolid.hh,v 1.8 2003/11/03 17:48:45 gcosmo Exp $
// GEANT4 tag $Name: geant4-06-00-patch-01 $
//
//
// class G4ReflectedSolid
//
// Class description:
//
// A Reflected solid is a solid that has been shifted from its original
// frame of reference to a new one.
// History:
//
// 23.07.01 V.Grichine: created
// 15.02.02 V.Grichine: get/set methods for fPtr(Direct)Transform3D
//
// --------------------------------------------------------------------
#ifndef G4ReflectedSolid_HH
#define G4ReflectedSolid_HH
#include "G4VSolid.hh"
#include "G4RotationMatrix.hh"
#include "G4ThreeVector.hh"
#include "G4Transform3D.hh"
#include "G4AffineTransform.hh"
class G4ReflectedSolid : public G4VSolid
{
public: // with description
G4ReflectedSolid( const G4String& pName,
G4VSolid* pSolid ,
const G4Transform3D& transform ) ;
// For use in instantiating a transient instance.
virtual ~G4ReflectedSolid() ;
// Virtual destructor.
public: // without description
// Includes all the methods that a solid requires.
EInside Inside( const G4ThreeVector& p ) const ;
G4bool CalculateExtent( const EAxis pAxis,
const G4VoxelLimits& pVoxelLimit,
const G4AffineTransform& pTransform,
G4double& pMin, G4double& pMax) const ;
G4ThreeVector SurfaceNormal( const G4ThreeVector& p ) const ;
G4double DistanceToIn( const G4ThreeVector& p,
const G4ThreeVector& v ) const ;
G4double DistanceToIn( const G4ThreeVector& p) const ;
G4double DistanceToOut( const G4ThreeVector& p,
const G4ThreeVector& v,
const G4bool calcNorm=false,
G4bool *validNorm=0,
G4ThreeVector *n=0 ) const ;
G4double DistanceToOut( const G4ThreeVector& p ) const ;
void ComputeDimensions( G4VPVParameterisation* p,
const G4int n,
const G4VPhysicalVolume* pRep ) ;
public: // with description
virtual G4GeometryType GetEntityType() const;
virtual const G4ReflectedSolid* GetReflectedSolidPtr() const;
virtual G4ReflectedSolid* GetReflectedSolidPtr();
// If the Solid is a "G4ReflectedSolid",
// return a self pointer else return 0.
G4VSolid* GetConstituentMovedSolid() const;
G4Transform3D GetTransform3D() const;
void SetTransform3D(G4Transform3D&);
G4Transform3D GetDirectTransform3D() const;
void SetDirectTransform3D(G4Transform3D&);
// Accessors methods.
std::ostream& StreamInfo(std::ostream& os) const;
public: // without description
void DescribeYourselfTo ( G4VGraphicsScene& scene ) const ;
G4Polyhedron* CreatePolyhedron () const ;
G4NURBS* CreateNURBS () const ;
// For creating graphical representations (ie for visualisation).
protected:
G4AffineTransform GetTransform() const;
void SetTransform(G4AffineTransform&);
G4AffineTransform GetDirectTransform() const;
void SetDirectTransform(G4AffineTransform&);
G4RotationMatrix GetFrameRotation() const;
void SetFrameRotation(const G4RotationMatrix&);
G4ThreeVector GetFrameTranslation() const;
void SetFrameTranslation(const G4ThreeVector&);
// Get/Set the rotation/translation, as applied to the
// frame of reference.
G4RotationMatrix GetObjectRotation() const;
void SetObjectRotation(const G4RotationMatrix&);
G4ThreeVector GetObjectTranslation() const;
void SetObjectTranslation(const G4ThreeVector&);
// Get/Set the rotation/translation, as applied to the object.
G4VSolid* fPtrSolid ;
G4AffineTransform* fPtrTransform ;
G4AffineTransform* fDirectTransform ;
G4Transform3D* fPtrTransform3D ;
G4Transform3D* fDirectTransform3D ;
private:
G4ReflectedSolid(const G4ReflectedSolid&);
G4ReflectedSolid& operator=(const G4ReflectedSolid&);
// Private copy constructor and assignment operator.
} ;
#endif
source/geometry/solids/Boolean/include/G4ReflectionFactory.hh
-211
View File
@@ -1,211 +0,0 @@
//
// ********************************************************************
// * DISCLAIMER *
// * *
// * The following disclaimer summarizes all the specific disclaimers *
// * of contributors to this software. The specific disclaimers,which *
// * govern, are listed with their locations in: *
// * http://cern.ch/geant4/license *
// * *
// * 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. *
// * *
// * This code implementation is the intellectual property of the *
// * GEANT4 collaboration. *
// * By copying, distributing or modifying the Program (or any work *
// * based on the Program) you indicate your acceptance of this *
// * statement, and all its terms. *
// ********************************************************************
//
//
// $Id: G4ReflectionFactory.hh,v 1.6 2003/11/03 17:48:45 gcosmo Exp $
// GEANT4 tag $Name: geant4-06-00-patch-01 $
//
//
// class G4Reflection
//
// Class description:
//
// Class providing functions for volumes placements with a general
// transfomation that can contain reflection.
// Reflection is then applied to a solid: a new G4ReflectedSolid
// instance is created and is placed with a transformation containing
// pure rotation and translation only.
// The pair of constituent and reflected logical volumes is
// considered as a generalized logical volume that is addressed
// by user specifying the constituent logical volume.
//
// Decomposition of a general transformation that can include reflection
// in a "reflection-free" transformation:
//
// x(inM') = TG*x(inM) TG - general transformation
// = T*(R*x(inM)) T - "reflection-free" transformation
// = T* x(inReflM)
//
// Daughters transformation:
// When a volume V containing daughter D with transformation TD
// is placed in mother M with a general tranformation TGV,
// the TGV is decomposed. New reflected volume ReflV containing
// a new daughter ReflD with reflected transformation ReflTD is created:
//
// x(inV) = TD * x(inD);
// x(inM) = TGV * x(inV)
// = TV * R * x(inV)
// = TV * R * TD * x(inD)
// = TV * R*TD*R-1 * R*x(inD)
// = TV * ReflTD * x(inReflD)
// Author: Ivana Hrivnacova, 16.10.2001 (Ivana.Hrivnacova@cern.ch)
// --------------------------------------------------------------------
#ifndef G4_REFLECTION_FACTORY_HH
#define G4_REFLECTION_FACTORY_HH
#include "G4Types.hh"
#include "G4Transform3D.hh"
#include "geomdefs.hh"
#include <map>
class G4VPhysicalVolume;
class G4LogicalVolume;
class G4VSolid;
typedef std::pair<G4VPhysicalVolume*,
G4VPhysicalVolume*> G4PhysicalVolumesPair;
typedef std::map<G4LogicalVolume*, G4LogicalVolume*,
std::less<G4LogicalVolume*> > G4ReflectedVolumesMap;
class G4ReflectionFactory
{
typedef G4ReflectedVolumesMap::const_iterator LogicalVolumesMapIterator;
public: // with description
virtual ~G4ReflectionFactory();
// Virtual destructor.
static G4ReflectionFactory* Instance();
// Gets pointer to the instance of the singleton.
G4PhysicalVolumesPair Place(const G4Transform3D& transform3D,
const G4String& name,
G4LogicalVolume* LV,
G4LogicalVolume* motherLV,
G4bool isMany,
G4int copyNo);
// Evaluates the passed transformation; if it contains reflection
// it performs its decomposition, creates new reflected solid and
// logical volume (or retrieves them from a map if the reflected
// objects were already created), transforms the daughters (if present)
// and place it in the given mother.
// The result is a pair of physical volumes;
// the second physical volume is a placement in a reflected mother
// or 0 if mother LV was not reflected.
G4PhysicalVolumesPair Replicate(const G4String& name,
G4LogicalVolume* LV,
G4LogicalVolume* motherLV,
EAxis axis,
G4int nofReplicas,
G4double width,
G4double offset=0);
// Creates replica in the given mother.
// The result is a pair of physical volumes;
// the second physical volume is a replica in a reflected mother
// or 0 if mother LV was not reflected.
void SetVerboseLevel(G4int verboseLevel);
G4int GetVerboseLevel() const;
// Sets/gets verbosity level.
void SetVolumesNameExtension(const G4String& nameExtension);
G4String GetVolumesNameExtension() const;
// Returns the name extension for the reflected solids
// and logical volumes.
void SetScalePrecision(G4double scaleValue);
G4double GetScalePrecision() const;
// Sets/gets precision factor for the scale consistency check
// The default value is set to 10*kCarTolerance.
G4LogicalVolume* GetConstituentLV(G4LogicalVolume* reflLV) const;
// Returns the consituent volume of the given reflected volume,
// 0 if the given reflected volume was not found.
G4LogicalVolume* GetReflectedLV(G4LogicalVolume* lv) const;
// Returns the reflected volume of the given consituent volume,
// 0 if the given volume was not reflected.
G4bool IsConstituent(G4LogicalVolume* lv) const;
// Returns true if the given volume has been already reflected
// (is in the map of constituent volumes).
G4bool IsReflected(G4LogicalVolume* lv) const;
// Returns true if the given volume is a reflected volume
// (is in the map reflected volumes).
const G4ReflectedVolumesMap& GetReflectedVolumesMap() const;
// Returns a handle to the internal map of volumes which have
// been reflected, after that placement or replication is performed.
protected:
G4ReflectionFactory();
// Protected singleton constructor.
G4ReflectionFactory(const G4ReflectionFactory&);
G4ReflectionFactory& operator=(const G4ReflectionFactory&);
// Disabled copy constructor and assignment operator.
private:
G4LogicalVolume* ReflectLV(G4LogicalVolume* LV);
// Gets/creates the reflected solid and logical volume
// and copies + transforms LV daughters.
G4LogicalVolume* CreateReflectedLV(G4LogicalVolume* LV);
// Creates the reflected solid and logical volume
// and add the logical volumes pair in the maps.
void ReflectDaughters(G4LogicalVolume* LV, G4LogicalVolume* refLV);
// Reflects daughters recursively.
void ReflectPVPlacement(G4VPhysicalVolume* PV, G4LogicalVolume* refLV);
// Copies and transforms daughter of PVPlacement type of
// a constituent volume into a reflected volume.
void ReflectPVReplica(G4VPhysicalVolume* PV, G4LogicalVolume* refLV);
// Copies and transforms daughter of PVReplica type of
// a constituent volume into a reflected volume.
void ReflectPVParameterised(G4VPhysicalVolume* PV, G4LogicalVolume* refLV);
// Not implemented yet.
// Should copy and transform daughter of PVReplica type of
// a constituent volume into a reflected volume.
G4bool IsReflection(const G4Scale3D& scale) const;
// Returns true if the scale is negative, false otherwise.
void CheckScale(const G4Scale3D& scale) const;
// Checks if scale correspond to fScale, if not gives exception.
void PrintConstituentLVMap();
// Temporary - for debugging purpose.
private:
static G4ReflectionFactory* fInstance;
static const G4String fDefaultNameExtension;
static const G4Scale3D fScale;
G4double fScalePrecision;
G4int fVerboseLevel;
G4String fNameExtension;
G4ReflectedVolumesMap fConstituentLVMap;
G4ReflectedVolumesMap fReflectedLVMap;
};
#endif