G4LatticeManager Class Reference

#include <G4LatticeManager.hh>

Public Member Functions
G4LatticeLogical *	GetLattice (G4Material *) const
G4LatticePhysical *	GetLattice (G4VPhysicalVolume *) const
G4bool	HasLattice (G4Material *) const
G4bool	HasLattice (G4VPhysicalVolume *) const
G4LatticeLogical *	LoadLattice (G4Material *, const G4String &latDir)
G4LatticePhysical *	LoadLattice (G4VPhysicalVolume *, const G4String &latDir)
G4double	MapKtoV (G4VPhysicalVolume *, G4int, const G4ThreeVector &) const
G4ThreeVector	MapKtoVDir (G4VPhysicalVolume *, G4int, const G4ThreeVector &) const
G4bool	RegisterLattice (G4Material *, G4LatticeLogical *)
G4bool	RegisterLattice (G4VPhysicalVolume *, G4LatticeLogical *)
G4bool	RegisterLattice (G4VPhysicalVolume *, G4LatticePhysical *)
void	Reset ()
void	SetVerboseLevel (G4int vb)

Static Public Member Functions
static G4LatticeManager *	GetLatticeManager ()

Protected Types
typedef std::set< G4LatticeLogical * >	LatticeLogReg
typedef std::map< G4Material *, G4LatticeLogical * >	LatticeMatMap
typedef std::set< G4LatticePhysical * >	LatticePhyReg
typedef std::map< G4VPhysicalVolume *, G4LatticePhysical * >	LatticeVolMap

Protected Member Functions
void	Clear ()

Protected Attributes
LatticeMatMap	fLLatticeList
LatticeLogReg	fLLattices
LatticeVolMap	fPLatticeList
LatticePhyReg	fPLattices
G4int	verboseLevel

Private Member Functions
	G4LatticeManager ()
virtual	~G4LatticeManager ()

Static Private Attributes
static G4LatticeManager *	fLM = 0

Detailed Description

Definition at line 47 of file G4LatticeManager.hh.

Member Typedef Documentation

LatticeLogReg

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

protected

Definition at line 89 of file G4LatticeManager.hh.

LatticeMatMap

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

protected

Definition at line 88 of file G4LatticeManager.hh.

LatticePhyReg

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

protected

Definition at line 95 of file G4LatticeManager.hh.

LatticeVolMap

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

protected

Definition at line 94 of file G4LatticeManager.hh.

Constructor & Destructor Documentation

G4LatticeManager()

G4LatticeManager::G4LatticeManager ( )

private

Definition at line 53 of file G4LatticeManager.cc.

                                   : verboseLevel(0) {
  Clear();
}

References Clear().

Referenced by GetLatticeManager().

Member Function Documentation

Clear()

void G4LatticeManager::Clear ( )

protected

Definition at line 79 of file G4LatticeManager.cc.

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

References fLLatticeList, fLLattices, fPLatticeList, and fPLattices.

Referenced by G4LatticeManager(), and Reset().

GetLattice() [1/2]

G4LatticeLogical * G4LatticeManager::GetLattice

(

G4Material *

Mat

)

const

Definition at line 209 of file G4LatticeManager.cc.

                                                                    {
  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
}

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

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

GetLattice() [2/2]

G4LatticePhysical * G4LatticeManager::GetLattice

(

G4VPhysicalVolume *

Vol

)

const

Definition at line 228 of file G4LatticeManager.cc.

                                                                            {
  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
}

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

GetLatticeManager()

G4LatticeManager * G4LatticeManager::GetLatticeManager ( )

static

Definition at line 89 of file G4LatticeManager.cc.

                                                      {
  // if no lattice manager exists, create one.
  G4AutoLock latLock(&latMutex);    // Protect before changing pointer
  if (!fLM) fLM = new G4LatticeManager();
  latLock.unlock();
 
  return fLM;
}

References fLM, G4LatticeManager(), anonymous_namespace{G4LatticeManager.cc}::latMutex, and G4TemplateAutoLock< _Mutex_t >::unlock().

Referenced by G4VPhononProcess::StartTracking().

HasLattice() [1/2]

G4bool G4LatticeManager::HasLattice

(

G4Material *

Mat

)

const

Definition at line 254 of file G4LatticeManager.cc.

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

References fLLatticeList.

HasLattice() [2/2]

G4bool G4LatticeManager::HasLattice

(

G4VPhysicalVolume *

Vol

)

const

Definition at line 248 of file G4LatticeManager.cc.

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

References fPLatticeList.

LoadLattice() [1/2]

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

Definition at line 122 of file G4LatticeManager.cc.

                                                {
  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;
}

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

Referenced by LoadLattice().

LoadLattice() [2/2]

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

Definition at line 144 of file G4LatticeManager.cc.

                                                {
  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;
}

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

MapKtoV()

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

Definition at line 264 of file G4LatticeManager.cc.

                                                {
  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;
}

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

MapKtoVDir()

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

Definition at line 282 of file G4LatticeManager.cc.

                                                      {
  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();
}

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

RegisterLattice() [1/3]

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

Definition at line 102 of file G4LatticeManager.cc.

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

References fLLatticeList, fLLattices, G4cout, G4endl, anonymous_namespace{G4LatticeManager.cc}::latMutex, G4TemplateAutoLock< _Mutex_t >::unlock(), and verboseLevel.

RegisterLattice() [2/3]

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

Definition at line 194 of file G4LatticeManager.cc.

                                             {
  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()));
}

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

RegisterLattice() [3/3]

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

Definition at line 171 of file G4LatticeManager.cc.

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

References fPLatticeList, fPLattices, G4cout, G4endl, anonymous_namespace{G4LatticeManager.cc}::latMutex, G4TemplateAutoLock< _Mutex_t >::unlock(), and verboseLevel.

Referenced by LoadLattice(), and RegisterLattice().

Reset()

void G4LatticeManager::Reset

(

)

Definition at line 63 of file G4LatticeManager.cc.

                             {
  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();
}

References Clear(), fLLattices, and fPLattices.

Referenced by ~G4LatticeManager().

SetVerboseLevel()

void G4LatticeManager::SetVerboseLevel ( G4int  vb )

inline

Definition at line 54 of file G4LatticeManager.hh.

{ verboseLevel = vb; }

References verboseLevel.

~G4LatticeManager()

G4LatticeManager::~G4LatticeManager ( )

privatevirtual

Definition at line 57 of file G4LatticeManager.cc.

                                    {
  Reset();          // Deletes all lattices
}

References Reset().

Field Documentation

fLLatticeList

LatticeMatMap G4LatticeManager::fLLatticeList

protected

Definition at line 92 of file G4LatticeManager.hh.

Referenced by Clear(), GetLattice(), HasLattice(), and RegisterLattice().

fLLattices

LatticeLogReg G4LatticeManager::fLLattices

protected

Definition at line 91 of file G4LatticeManager.hh.

Referenced by Clear(), RegisterLattice(), and Reset().

fLM

G4LatticeManager * G4LatticeManager::fLM = 0

staticprivate

Definition at line 49 of file G4LatticeManager.hh.

Referenced by GetLatticeManager().

fPLatticeList

LatticeVolMap G4LatticeManager::fPLatticeList

protected

Definition at line 98 of file G4LatticeManager.hh.

Referenced by Clear(), GetLattice(), HasLattice(), and RegisterLattice().

fPLattices

LatticePhyReg G4LatticeManager::fPLattices

protected

Definition at line 97 of file G4LatticeManager.hh.

Referenced by Clear(), RegisterLattice(), and Reset().

verboseLevel

G4int G4LatticeManager::verboseLevel

protected

Definition at line 86 of file G4LatticeManager.hh.

Referenced by GetLattice(), LoadLattice(), MapKtoV(), MapKtoVDir(), RegisterLattice(), and SetVerboseLevel().

---

The documentation for this class was generated from the following files:

• source/processes/solidstate/phonon/include/G4LatticeManager.hh
• source/processes/solidstate/phonon/src/G4LatticeManager.cc