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

Import Geant4 1.0.0 source tree

Browse Source
This commit is contained in:
Gabriele Cosmo
2016-06-08 15:28:20 +02:00
parent aaa409b6ee
commit ca1c8cb059
2995 changed files with 106830 additions and 299600 deletions
Download Patch File Download Diff File Expand all files Collapse all files
source/persistency/geometry/management/include/G4PGeometryObjectMap.ddl
+152
View File
@@ -0,0 +1,152 @@
// 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: G4PGeometryObjectMap.ddl,v 1.3.2.1 1999/12/07 20:50:06 gunter Exp $
// GEANT4 tag $Name: geant4-01-00 $
//
// class G4PGeometryObjectMap
//
// A Class responsible for keeping track of the geometry object map.
//
// This class is persistent-capable.
//
// Member functions:
// =================
// G4PGeometryObjectMap( G4PString theGeometryName );
// ~G4PGeometryObjectMap();
//
// protected:
// G4PVPhysicalVolume* LookUp( G4VPhysicalVolume* aPhysVol );
// void Add( const G4VPhysicalVolume* aPhysVol,
// const G4PVPhysicalVolume* persPhysVol );
// G4PLogicalVolume* LookUp(G4LogicalVolume* aLogVol);
// void Add( const G4LogicalVolume* aLogVol,
// const G4PLogicalVolume* persLogVol );
// G4PVSolid* LookUp(G4VSolid* aSolid);
// void Add( const G4VSolid* aSolid,
// const G4PVSolid* persSolid );
// G4int GetNoSolids();
// G4VSolid* GetSolid(G4int n);
// G4PVSolid* GetPSolid(G4int n);
//
// Note:
// =====
// This class contains G4RWTPtrVector of the transient classes.
// As a result, ooddlx compiler will issue warnings as follows, but it's okay.
// The value of G4RWTPtrVector is used only in transient case
// in this class, and you can safely ignore these warnings.
// ----
// "include/G4PGeometryObjectMap.ddl", line xxx: warning: persistent-capable
// class member type is a problem
// The type of base class RWPtrVector is a problem
// The type of member RWPtrVector::array_ is pointer
// The type of base class G4RWTPtrVector<G4VPhysicalVolume > is a
// problem
// The type of base class RWPtrVector is a problem
// G4PhysVolRefVArray transPhysVolPtrs;
// ^
// ----
//
//
// History:
// 98.06.20 Y.Morita Initial version
#ifndef G4PGeometryObjectMap_h
#define G4PGeometryObjectMap_h 1
#include "g4rw/tpvector.h"
#include "globals.hh"
#include "G4VPhysicalVolume.hh"
#include "G4LogicalVolume.hh"
#include "G4VSolid.hh"
#include "G4PersistentTypes.hh"
#include "G4PersistentSchema.hh"
#include "HepODBMS/odbms/HepODBMS.h"
class G4PVPhysicalVolume;
#pragma ooclassref G4PVPhysicalVolume "G4PVPhysicalVolume_ref.hh"
class G4PLogicalVolume;
#pragma ooclassref G4PLogicalVolume "G4PLogicalVolume_ref.hh"
class G4PVSolid;
#pragma ooclassref G4PVSolid "G4PVSolid_ref.hh"
typedef G4RWTPtrVector<G4VPhysicalVolume> G4VPhysVolRefVArray;
typedef G4RWTPtrVector<G4LogicalVolume> G4LogVolRefVArray;
typedef G4RWTPtrVector<G4VSolid> G4VSolidRefVArray;
typedef d_Varray< d_Ref<G4PVPhysicalVolume> > G4PVPhysVolRefVArray;
typedef d_Varray< d_Ref<G4PLogicalVolume> > G4PLogVolRefVArray;
typedef d_Varray< d_Ref<G4PVSolid> > G4PVSolidRefVArray;
class G4PGeometryObjectMap
: public HepPersObj
{
public:
G4PGeometryObjectMap();
G4PGeometryObjectMap( const G4String theGeometryName );
~G4PGeometryObjectMap();
// template cannot be used in class scope!!
// template<class T_IN, class T_OUT> T_OUT LookUp( const T_IN aGeomObj );
HepRef(G4PVPhysicalVolume) LookUp( G4VPhysicalVolume* aPhysVol );
G4VPhysicalVolume* LookUp( HepRef(G4PVPhysicalVolume) aPhysVol );
HepRef(G4PLogicalVolume) LookUp( G4LogicalVolume* aLogVol);
G4LogicalVolume* LookUp( HepRef(G4PLogicalVolume) aLogVol);
HepRef(G4PVSolid) LookUp( G4VSolid* aSolid);
G4VSolid* LookUp( HepRef(G4PVSolid) persSolid);
void Add( G4VPhysicalVolume* aPhysVol,
HepRef(G4PVPhysicalVolume) persPhysVol );
void Add( HepRef(G4PVPhysicalVolume) persPhysVol,
G4VPhysicalVolume* aPhysVol );
void Add( G4LogicalVolume* aLogVol,
HepRef(G4PLogicalVolume) persLogVol );
void Add( HepRef(G4PLogicalVolume) persLogVol,
G4LogicalVolume* aLogVol );
void Add( G4VSolid* aSolid,
HepRef(G4PVSolid) persSolid );
void Add( HepRef(G4PVSolid) persSolid,
G4VSolid* aSolid );
inline void SetWorldVolume( const HepRef(G4PVPhysicalVolume) aWorld )
{ thePersistentWorldVolume = aWorld; }
inline HepRef(G4PVPhysicalVolume) GetWorldVolume()
{ return thePersistentWorldVolume; }
inline G4int GetNoPhysVol() const { return noPhysVol; }
inline G4int GetNoLogVol() const { return noLogVol; }
inline G4int GetNoSolids() const { return noSolids; }
G4VSolid* GetSolid(G4int n);
HepRef(G4PVSolid) GetPSolid(G4int n);
void InitTransientMap();
private:
// World Volume of this Geometry object tree
d_Ref<G4PVPhysicalVolume> thePersistentWorldVolume;
// Physics Volume Pointer Array
G4Pint noPhysVol;
G4VPhysVolRefVArray transPhysVolPtrs;
G4PVPhysVolRefVArray persPhysVolPtrs;
// Logical Volume Pointer Array
G4Pint noLogVol;
G4LogVolRefVArray transLogVolPtrs;
G4PLogVolRefVArray persLogVolPtrs;
// Solid Pointer Array
G4Pint noSolids;
G4VSolidRefVArray transSolidPtrs;
G4PVSolidRefVArray persSolidPtrs;
};
#endif
source/persistency/geometry/management/include/G4PLogicalVolume.ddl
+77
View File
@@ -0,0 +1,77 @@
// 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: G4PLogicalVolume.ddl,v 1.6.2.1 1999/12/07 20:50:07 gunter Exp $
// GEANT4 tag $Name: geant4-01-00 $
//
//
// class G4PLogicalVolume
// P-verson of the class G4LogicalVolume
// Takashi.Sasaki@kek.jp
#ifndef G4PLOGICALVOLUME_DDL
#define G4PLOGICALVOLUME_DDL 1
#include "globals.hh"
#include "G4PersistentTypes.hh"
#include "G4PersistentSchema.hh"
#include "HepODBMS/odbms/HepODBMS.h"
#include "G4PVSolid.hh"
// Forward declarations
class G4VPhysicalVolume;
class G4LogicalVolume;
class G4VSolid;
#include "G4PVPhysicalVolume.hh"
typedef d_Varray< d_Ref<G4PVPhysicalVolume> > G4PVPhysVolRefVArray;
class G4PLogicalVolume: public HepPersObj
{
public:
G4PLogicalVolume( const G4LogicalVolume* aLogicalVolume,
HepRef(G4PVSolid) persSolid);
~G4PLogicalVolume();
G4LogicalVolume* MakeTransientObject(G4VSolid* aSolid);
HepRef(G4PVSolid) GetSolid();
void SetSolid( HepRef(G4PVSolid) pSolid );
public:
G4int GetNoDaughters() const;
HepRef(G4PVPhysicalVolume) GetDaughter(const G4int i) const;
void AddDaughter(HepRef(G4PVPhysicalVolume) p);
G4bool IsDaughter(const HepRef(G4PVPhysicalVolume) p) const;
void RemoveDaughter(const HepRef(G4PVPhysicalVolume) p);
private:
G4PVPhysVolRefVArray fDaughters;
// G4MagneticField* fMagneticField;
// G4Material* fMaterial;
G4PString fMaterialName;
G4PString fName;
// G4VSensitiveDetector *fSensitiveDetector;
d_Ref<G4PVSolid> fSolid;
// G4UserLimits* fUserLimits;
// G4SmartVoxelHeader* fVoxel;
// const G4VisAttributes* fVisAttributes;
// G4FastSimulationManager* fFastSimulationManager;
// G4bool fIsEnvelope;
G4Pint NoOfDaughters;
public:
inline void SetMaterialName(G4String aName)
{ fMaterialName = aName; }
inline G4String GetMaterialName()
{ return (G4String) fMaterialName; }
};
#endif
source/persistency/geometry/management/include/G4PPVParameterised.ddl
+5 -9
View File
@@ -1,12 +1,12 @@
// This code implementation is the intellectual property of
// the RD44 GEANT4 collaboration.
// 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: G4PPVParameterised.ddl,v 1.1 1999/01/07 16:10:47 gunter Exp $
// GEANT4 tag $Name: geant4-00-01 $
// $Id: G4PPVParameterised.ddl,v 1.3.2.1 1999/12/07 20:50:07 gunter Exp $
// GEANT4 tag $Name: geant4-01-00 $
//
// class G4PPVParameterised
//
@@ -18,6 +18,7 @@
#ifndef G4PPVPARAMETERISED_DDL
#define G4PPVPARAMETERISED_DDL 1
#include "G4PersistentSchema.hh"
#include "G4PPVReplica.hh"
class G4PPVParameterised
@@ -33,13 +34,8 @@ public:
G4LogicalVolume* aLogical,
G4VPhysicalVolume* aMother );
virtual G4int GetCopyNo() const;
protected:
virtual void SetCopyNo(G4int CopyNo);
private:
// ooRef(G4VPVParameterisation) fparam;
// d_Ref<G4VPVParameterisation> fparam;
};
#endif
source/persistency/geometry/management/include/G4PPVPlacement.ddl
+7 -4
View File
@@ -1,18 +1,21 @@
// This code implementation is the intellectual property of
// the RD44 GEANT4 collaboration.
// 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: G4PPVPlacement.ddl,v 1.1 1999/01/07 16:10:47 gunter Exp $
// GEANT4 tag $Name: geant4-00-01 $
// $Id: G4PPVPlacement.ddl,v 1.3.2.1 1999/12/07 20:50:07 gunter Exp $
// GEANT4 tag $Name: geant4-01-00 $
//
//
// P-versieon of G4PVPlacement Takashi.Sasaki@kek.jp
#ifndef G4PPVPLACEMENT_DDL
#define G4PPVPLACEMENT_DDL 1
#include "G4PersistentTypes.hh"
#include "G4PersistentSchema.hh"
class G4VPhysicalVolume;
class G4LogicalVolume;
class G4PLogicalVolume;
@@ -40,7 +43,7 @@ protected:
private:
G4bool fmany; // flag for booleans
// G4bool fallocatedRotM; // flag for allocation of Rotation Matrix
G4int fcopyNo; // for identification
G4Pint fcopyNo; // for identification
};
#endif
source/persistency/geometry/management/include/G4PPVReplica.ddl
+8 -6
View File
@@ -1,12 +1,12 @@
// This code implementation is the intellectual property of
// the RD44 GEANT4 collaboration.
// 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: G4PPVReplica.ddl,v 1.1 1999/01/07 16:10:48 gunter Exp $
// GEANT4 tag $Name: geant4-00-01 $
// $Id: G4PPVReplica.ddl,v 1.3.2.1 1999/12/07 20:50:07 gunter Exp $
// GEANT4 tag $Name: geant4-01-00 $
//
//
// class G4PPVReplica
@@ -19,6 +19,8 @@
#ifndef G4PPVREPLICA_DDL
#define G4PPVREPLICA_DDL
#include "G4PersistentTypes.hh"
#include "G4PersistentSchema.hh"
#include "G4VPhysicalVolume.hh"
#include "G4RotationMatrix.hh"
@@ -45,10 +47,10 @@ protected:
protected:
EAxis faxis;
G4int fnReplicas;
G4double fwidth,foffset;
G4Pint fnReplicas;
G4Pdouble fwidth,foffset;
G4int fcopyNo;
G4Pint fcopyNo;
};
#endif
source/persistency/geometry/management/include/G4PVPhysicalVolume.ddl
+8 -12
View File
@@ -1,12 +1,12 @@
// This code implementation is the intellectual property of
// the RD44 GEANT4 collaboration.
// 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: G4PVPhysicalVolume.ddl,v 1.1 1999/01/07 16:10:48 gunter Exp $
// GEANT4 tag $Name: geant4-00-01 $
// $Id: G4PVPhysicalVolume.ddl,v 1.3.2.1 1999/12/07 20:50:07 gunter Exp $
// GEANT4 tag $Name: geant4-01-00 $
//
//
// class G4PVPhysicalVolume
@@ -17,12 +17,12 @@
#include "globals.hh"
#include "geomdefs.hh"
#include "G4PersistentTypes.hh"
#include "G4PersistentSchema.hh"
#include "G4RotationMatrix.hh"
#include "G4ThreeVector.hh"
#include "HepODBMS/odbms/HepODBMS.h"
#include "HepODBMS/odbms/HepVArray.h"
class G4VPhysicalVolume;
class G4LogicalVolume;
@@ -34,10 +34,6 @@ class G4LogicalVolume;
class G4PLogicalVolume;
#pragma ooclassref G4PLogicalVolume "G4PLogicalVolume_ref.hh"
#ifndef OO_VARRAY_D_DOUBLE
declare(HepVArray,d_Double)
#endif
class G4PVPhysicalVolume: public HepPersObj
{
public:
@@ -74,14 +70,14 @@ public:
virtual void SetCopyNo(G4int CopyNo) = 0;
protected:
HepVArray(d_Double) frot;
HepVArray(d_Double) ftrans;
d_Varray<d_Double> frot;
d_Varray<d_Double> ftrans;
G4ThreeVector ftransvector;
ooRef(G4PLogicalVolume) flogical;
d_Ref<G4PLogicalVolume> flogical;
G4PString fname; // name of the volume
ooRef(G4PVPhysicalVolume) fmother; // The current moher volume
d_Ref<G4PVPhysicalVolume> fmother; // The current moher volume
};
source/persistency/geometry/management/include/G4PVSolid.ddl
-53
View File
@@ -1,53 +0,0 @@
// This code implementation is the intellectual property of
// the RD44 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: G4PVSolid.ddl,v 1.1 1999/01/07 16:10:48 gunter Exp $
// GEANT4 tag $Name: geant4-00-01 $
//
//
// class G4PVSolid
//
// History:
// 19.06.98 A.Kimura Converted from G4VSolid.hh
// 20.06.98 A.Kimura Clean up
#ifndef G4PVSOLID_DDL
#define G4PVSOLID_DDL
#include "globals.hh"
#include "geomdefs.hh"
#include "G4PersistentTypes.hh"
#include "G4VSolid.hh"
#include "HepODBMS/odbms/HepODBMS.h"
class G4PVSolid;
class G4PVSolid : public HepPersObj {
public:
G4PVSolid(const G4String& name);
virtual ~G4PVSolid();
virtual G4VSolid* MakeTransientObject() const = 0;
G4bool operator==( const G4PVSolid& s) const
{
return (this==&s) ? true : false;
}
G4String GetName() const;
void SetName(const G4String& name);
virtual G4GeometryType GetEntityType() const = 0;
private:
G4PString fshapeName; // Name
};
#endif
source/persistency/geometry/management/include/G4PersistentGeomMan.hh
+109
View File
@@ -0,0 +1,109 @@
// 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: G4PersistentGeomMan.hh,v 1.7.2.1 1999/12/07 20:50:07 gunter Exp $
// GEANT4 tag $Name: geant4-01-00 $
//
// class G4PersistentGeomMan
//
// A Utility class for storing and retrieving the geometry objects.
//
// This class is not persistent-capable.
//
// History:
// 98.10.30 Y.Morita Splited from G4PersistencyManager
#ifndef G4PERSISTENTGEOMMAN_H
#define G4PERSISTENTGEOMMAN_H 1
#include "globals.hh"
#include "geomdefs.hh"
#include "HepODBMS/odbms/HepODBMS.h"
#include "G4VPersistentSubMan.hh"
#include "G4VPersistentSubDbMan.hh"
#include "G4PGeometryObjectMap.hh"
#define G4_PHYS_VOLUME_DEPTH_MAX 1000000
// forward declarations
class HepDbApplication;
class G4VSolid;
class G4VPhysicalVolume;
class G4LogicalVolume;
class G4PVPhysicalVolume;
class G4PLogicalVolume;
class G4PVSolid;
class G4PersistentGeomMan
: public G4VPersistentSubMan, public G4VPersistentSubDbMan
{
friend class G4PersistencyManager;
friend class G4TransactionManager;
private:
// to be used by G4PersistencyManager only
G4PersistentGeomMan();
~G4PersistentGeomMan();
private:
HepRef(G4PGeometryObjectMap) f_GeomMap;
private:
// interface with G4PersistencyManager
G4bool Store( HepDbApplication* dbApp,
const G4VPhysicalVolume* aWorld );
G4bool Retrieve( HepDbApplication* dbApp,
G4VPhysicalVolume*& aWorld );
private:
// Characterise `type' of volume - normal/replicated/parameterised
EVolume VolumeType(const G4VPhysicalVolume *pVol) const;
HepRef(G4PVPhysicalVolume) MakePersistentObject (
G4VPhysicalVolume* aPhysVol );
HepRef(G4PLogicalVolume) MakePersistentObject (
G4LogicalVolume* aLogVol );
HepRef(G4PVSolid) MakePersistentObject ( G4VSolid* aSolid );
G4VPhysicalVolume* MakeTransientObject (
HepRef(G4PVPhysicalVolume) aPhysVol,
HepRef(G4PVPhysicalVolume) theMotherVol );
G4LogicalVolume* MakeTransientObject (
HepRef(G4PLogicalVolume) aLogVol,
HepRef(G4PVPhysicalVolume) theMotherVol );
G4VSolid* MakeTransientObject ( HepRef(G4PVSolid) aSolid );
private:
G4int f_nRecursive;
G4int f_tRecursive;
G4String f_GeomMapScopeName;
};
inline EVolume G4PersistentGeomMan::VolumeType(const G4VPhysicalVolume *pVol) const
{
EVolume type;
EAxis axis;
G4int nReplicas;
G4double width,offset;
G4bool consuming;
if (pVol->IsReplicated())
{
pVol->GetReplicationData(axis,nReplicas,width,offset,consuming);
type=(consuming) ? kReplica : kParameterised;
}
else
{
type=kNormal;
}
return type;
}
#endif