#include <G4LatticeManager.hh>

Public Member Functions
void	SetVerboseLevel (G4int vb)

void	Reset ()

G4bool	RegisterLattice (G4VPhysicalVolume , G4LatticePhysical )

G4bool	RegisterLattice (G4VPhysicalVolume , G4LatticeLogical )

G4bool	RegisterLattice (G4Material , G4LatticeLogical )

G4LatticeLogical *	LoadLattice (G4Material *, const G4String &latDir)

G4LatticeLogical *	GetLattice (G4Material *) const

G4bool	HasLattice (G4Material *) const

G4LatticePhysical *	LoadLattice (G4VPhysicalVolume *, const G4String &latDir)

G4LatticePhysical *	GetLattice (G4VPhysicalVolume *) const

G4bool	HasLattice (G4VPhysicalVolume *) const

G4double	MapKtoV (G4VPhysicalVolume *, G4int, const G4ThreeVector &) const

G4ThreeVector	MapKtoVDir (G4VPhysicalVolume *, G4int, const G4ThreeVector &) const

Static Public Member Functions
static G4LatticeManager *	GetLatticeManager ()

Protected Types
typedef std::map< G4Material , G4LatticeLogical >	LatticeMatMap

typedef std::set < G4LatticeLogical * >	LatticeLogReg

typedef std::map < G4VPhysicalVolume , G4LatticePhysical >	LatticeVolMap

typedef std::set < G4LatticePhysical * >	LatticePhyReg

Protected Member Functions
void	Clear ()

Protected Attributes
G4int	verboseLevel

LatticeLogReg	fLLattices

LatticeMatMap	fLLatticeList

LatticePhyReg	fPLattices

LatticeVolMap	fPLatticeList

Detailed Description

Definition at line 48 of file G4LatticeManager.hh.

Member Typedef Documentation

typedef std::set<G4LatticeLogical*> G4LatticeManager::LatticeLogReg

protected

Definition at line 90 of file G4LatticeManager.hh.

typedef std::map<G4Material*, G4LatticeLogical*> G4LatticeManager::LatticeMatMap

protected

Definition at line 89 of file G4LatticeManager.hh.

typedef std::set<G4LatticePhysical*> G4LatticeManager::LatticePhyReg

protected

Definition at line 96 of file G4LatticeManager.hh.

typedef std::map<G4VPhysicalVolume*, G4LatticePhysical*> G4LatticeManager::LatticeVolMap

protected

Definition at line 95 of file G4LatticeManager.hh.

Member Function Documentation

void G4LatticeManager::Clear ( )

protected

Definition at line 74 of file G4LatticeManager.cc.

References fLLatticeList, fLLattices, fPLatticeList, and fPLattices.

Referenced by Reset().

                              {
   fPLatticeList.clear();
   fPLattices.clear();
 
   fLLatticeList.clear();
   fLLattices.clear();
 }

G4LatticeLogical * G4LatticeManager::GetLattice ( G4Material * Mat ) const

Definition at line 195 of file G4LatticeManager.cc.

References fLLatticeList, G4cerr, G4cout, G4endl, G4Material::GetName(), and verboseLevel.

Referenced by MapKtoV(), MapKtoVDir(), and G4VPhononProcess::StartTracking().

                                                                     {
   LatticeMatMap::const_iterator latFind = fLLatticeList.find(Mat);
   if (latFind != fLLatticeList.end()) {
     if (verboseLevel)
       G4cout << "G4LatticeManager::GetLattice found " << latFind->second
          << " for " << (Mat?Mat->GetName():"NULL") << "." << G4endl;
     return latFind->second;
   }
 
 
   if (verboseLevel) 
     G4cerr << "G4LatticeManager:: Found no matching lattices for "
        << (Mat?Mat->GetName():"NULL") << "." << G4endl;
 
   return 0;         // No lattice associated with volume
 }

G4LatticePhysical * G4LatticeManager::GetLattice ( G4VPhysicalVolume * Vol ) const

Definition at line 215 of file G4LatticeManager.cc.

References fPLatticeList, G4cerr, G4cout, G4endl, G4VPhysicalVolume::GetName(), and verboseLevel.

                                                                             {
   LatticeVolMap::const_iterator latFind = fPLatticeList.find(Vol);
   if (latFind != fPLatticeList.end()) {
     if (verboseLevel)
       G4cout << "G4LatticeManager::GetLattice found " << latFind->second
          << " for " << (Vol?Vol->GetName():"default") << "." << G4endl;
     return latFind->second;
   }
 
   if (verboseLevel) 
     G4cerr << "G4LatticeManager::GetLattice found no matching lattices for "
        << (Vol?Vol->GetName():"default") << "." << G4endl;
 
   return 0;         // No lattice associated with volume
 }

G4LatticeManager * G4LatticeManager::GetLatticeManager ( )

static

Definition at line 84 of file G4LatticeManager.cc.

Referenced by XPhononStackingAction::ClassifyNewTrack(), and G4VPhononProcess::StartTracking().

                                                       {
   //if no lattice manager exists, create one.
   if (!fLM) fLM = new G4LatticeManager();
   return fLM;
 }

G4bool G4LatticeManager::HasLattice ( G4Material * Mat ) const

Definition at line 241 of file G4LatticeManager.cc.

References fLLatticeList.

                                                          {
   return (fLLatticeList.find(Mat) != fLLatticeList.end());
 }

G4bool G4LatticeManager::HasLattice ( G4VPhysicalVolume * Vol ) const

Definition at line 235 of file G4LatticeManager.cc.

References fPLatticeList.

                                                                 {
   return (fPLatticeList.find(Vol) != fPLatticeList.end());
 }

G4LatticeLogical * G4LatticeManager::LoadLattice	(	G4Material *	Mat,
		const G4String &	latDir
	)

Definition at line 112 of file G4LatticeManager.cc.

References G4cerr, G4cout, G4endl, G4Material::GetName(), G4LatticeReader::MakeLattice(), RegisterLattice(), and verboseLevel.

Referenced by LoadLattice().

                                                 {
   if (verboseLevel) {
     G4cout << "G4LatticeManager::LoadLattice material " << Mat->GetName()
        << " " << latDir << G4endl;
   }
               
   G4LatticeReader latReader(verboseLevel);
   G4LatticeLogical* newLat = latReader.MakeLattice(latDir+"/config.txt");
   if (verboseLevel>1) G4cout << " Created newLat " << newLat << G4endl;
 
   if (newLat) RegisterLattice(Mat, newLat);
   else {
     G4cerr << "ERROR creating " << latDir << " lattice for material "
        << Mat->GetName() << G4endl;
   }
 
   return newLat;
 }

G4LatticePhysical * G4LatticeManager::LoadLattice	(	G4VPhysicalVolume *	Vol,
		const G4String &	latDir
	)

Definition at line 134 of file G4LatticeManager.cc.

References G4cout, G4endl, G4VPhysicalVolume::GetFrameRotation(), G4VPhysicalVolume::GetLogicalVolume(), G4LogicalVolume::GetMaterial(), G4VPhysicalVolume::GetName(), LoadLattice(), RegisterLattice(), and verboseLevel.

                                                 {
   if (verboseLevel) {
     G4cout << "G4LatticeManager::LoadLattice volume " << Vol->GetName()
        << " " << latDir << G4endl;
   }
               
   G4Material* theMat = Vol->GetLogicalVolume()->GetMaterial();
 
   // Create and register the logical lattice, then the physical lattice
   G4LatticeLogical* lLattice = LoadLattice(theMat, latDir);
   if (!lLattice) return 0;
 
   G4LatticePhysical* pLattice =
     new G4LatticePhysical(lLattice, Vol->GetFrameRotation());
   if (pLattice) RegisterLattice(Vol, pLattice);
 
   if (verboseLevel>1) G4cout << " Created pLattice " << pLattice << G4endl;
 
   return pLattice;
 }

G4double G4LatticeManager::MapKtoV	(	G4VPhysicalVolume *	Vol,
		G4int	polarizationState,
		const G4ThreeVector &	k
	)		const

Definition at line 251 of file G4LatticeManager.cc.

References G4cout, G4endl, GetLattice(), python.hepunit::m, G4LatticePhysical::MapKtoV(), and verboseLevel.

Referenced by XPhononStackingAction::ClassifyNewTrack().

                                                 {
   G4LatticePhysical* theLattice = GetLattice(Vol);
   if (verboseLevel)
     G4cout << "G4LatticeManager::MapKtoV using lattice " << theLattice
        << G4endl;
 
   // If no lattice available, use generic "speed of sound"
   return theLattice ? theLattice->MapKtoV(polarizationState, k) : 300.*m/s;
 }

G4ThreeVector G4LatticeManager::MapKtoVDir	(	G4VPhysicalVolume *	Vol,
		G4int	polarizationState,
		const G4ThreeVector &	k
	)		const

Definition at line 269 of file G4LatticeManager.cc.

References G4cout, G4endl, GetLattice(), G4LatticePhysical::MapKtoVDir(), CLHEP::Hep3Vector::unit(), and verboseLevel.

Referenced by XPhononStackingAction::ClassifyNewTrack().

                                                       {
   G4LatticePhysical* theLattice = GetLattice(Vol);
   if (verboseLevel)
     G4cout << "G4LatticeManager::MapKtoVDir using lattice " << theLattice
        << G4endl;
 
   // If no lattice available, propagate along input wavevector
   return theLattice ? theLattice->MapKtoVDir(polarizationState, k) : k.unit();
 }

G4bool G4LatticeManager::RegisterLattice	(	G4VPhysicalVolume *	Vol,
		G4LatticePhysical *	Lat
	)

Definition at line 161 of file G4LatticeManager.cc.

References fPLatticeList, fPLattices, G4cout, G4endl, and verboseLevel.

Referenced by LoadLattice(), and RegisterLattice().

                                              {
   if (!Vol || !Lat) return false;   // Don't register null pointers
 
   // SPECIAL: Register first lattice with a null volume to act as default
   if (fPLatticeList.empty()) fPLatticeList[0] = Lat;
 
   fPLattices.insert(Lat);
   fPLatticeList[Vol] = Lat;
 
   if (verboseLevel) {
     G4cout << "G4LatticeManager::RegisterLattice: "
        << " Total number of physical lattices: " << fPLatticeList.size()-1
        << " (" << fPLattices.size() << " unique)" << G4endl;
   }
 
   return true; 
 }

G4bool G4LatticeManager::RegisterLattice	(	G4VPhysicalVolume *	Vol,
		G4LatticeLogical *	LLat
	)

Definition at line 180 of file G4LatticeManager.cc.

References G4VPhysicalVolume::GetFrameRotation(), G4VPhysicalVolume::GetLogicalVolume(), G4LogicalVolume::GetMaterial(), and RegisterLattice().

                                              {
   if (!Vol || !LLat) return false;  // Don't register null pointers
 
   // Make sure logical lattice is registered for material
   RegisterLattice(Vol->GetLogicalVolume()->GetMaterial(), LLat);
 
   // Create and register new physical lattice to go with volume
   return RegisterLattice(Vol, new G4LatticePhysical(LLat, Vol->GetFrameRotation()));
 }

G4bool G4LatticeManager::RegisterLattice	(	G4Material *	Mat,
		G4LatticeLogical *	Lat
	)

Definition at line 94 of file G4LatticeManager.cc.

References fLLatticeList, fLLattices, G4cout, G4endl, and verboseLevel.

                                             {
   if (!Mat || !Lat) return false;   // Don't register null pointers
 
   fLLattices.insert(Lat);       // Take ownership in registry
   fLLatticeList[Mat] = Lat;
 
   if (verboseLevel) {
     G4cout << "G4LatticeManager::RegisterLattice: "
        << " Total number of logical lattices: " << fLLatticeList.size()
        << " (" << fLLattices.size() << " unique)" << G4endl;
   }
 
   return true; 
 }

void G4LatticeManager::Reset ( )

Definition at line 58 of file G4LatticeManager.cc.

References Clear(), fLLattices, and fPLattices.

                              {
   for (LatticeLogReg::iterator lm=fLLattices.begin();
        lm != fLLattices.end(); ++lm) {
     delete (*lm);
   }
 
   for (LatticePhyReg::iterator pm=fPLattices.begin();
        pm != fPLattices.end(); ++pm) {
     delete (*pm);
   }
 
   Clear();
 }