G4LatticeManager Class Reference

#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 47 of file G4LatticeManager.hh.

Member Typedef Documentation

LatticeLogReg

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

protected

Definition at line 89 of file G4LatticeManager.hh.

LatticeMatMap

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

protected

Definition at line 88 of file G4LatticeManager.hh.

LatticePhyReg

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

protected

Definition at line 95 of file G4LatticeManager.hh.

LatticeVolMap

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

protected

Definition at line 94 of file G4LatticeManager.hh.

Member Function Documentation

Clear()

void G4LatticeManager::Clear ( )

protected

Definition at line 79 of file G4LatticeManager.cc.

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

Referenced by 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() : G4String("NULL")) << "."
             << G4endl;
    return latFind->second;
  }
 
  if (verboseLevel) 
    G4cerr << "G4LatticeManager:: Found no matching lattices for "
           << (Mat ? Mat->GetName() : G4String("NULL")) << "." << G4endl;
 
  return nullptr;           // No lattice associated with volume
}

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

GetLattice() [2/2]

G4LatticePhysical * G4LatticeManager::GetLattice

(

G4VPhysicalVolume *

Vol

)

const

Definition at line 229 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() : G4String("default")) << "."
             << G4endl;
    return latFind->second;
  }
 
  if (verboseLevel) 
    G4cerr << "G4LatticeManager::GetLattice found no matching lattices for "
           << (Vol ? Vol->GetName() : G4String("default")) << "." << G4endl;
 
  return nullptr;           // No lattice associated with volume
}

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

Referenced by G4VPhononProcess::StartTracking().

HasLattice() [1/2]

G4bool G4LatticeManager::HasLattice

(

G4Material *

Mat

)

const

Definition at line 256 of file G4LatticeManager.cc.

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

HasLattice() [2/2]

G4bool G4LatticeManager::HasLattice

(

G4VPhysicalVolume *

Vol

)

const

Definition at line 250 of file G4LatticeManager.cc.

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

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

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

MapKtoV()

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

Definition at line 266 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;
}

MapKtoVDir()

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

Definition at line 284 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();
}

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

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

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

Referenced by LoadLattice(), 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();
}

SetVerboseLevel()

void G4LatticeManager::SetVerboseLevel ( G4int vb )

inline

Definition at line 54 of file G4LatticeManager.hh.

{ verboseLevel = vb; }

Member Data 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().

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(), GetLattice(), LoadLattice(), LoadLattice(), MapKtoV(), MapKtoVDir(), RegisterLattice(), RegisterLattice(), and SetVerboseLevel().

---

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

• G4LatticeManager.hh
• G4LatticeManager.cc