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

Import Geant4 10.7.0 source tree

Browse Source
This commit is contained in:
Gabriele Cosmo
2020-12-04 12:30:43 +01:00
parent 67ba86d073
commit dab42d2018
3770 changed files with 226369 additions and 286486 deletions
Download Patch File Download Diff File Expand all files Collapse all files
source/processes/electromagnetic/dna/utils/src/G4DNAMolecularMaterial.cc
+78 -98
View File
@@ -27,9 +27,10 @@
// Author: Mathieu Karamitros
//
#include <utility>
#include "G4DNAMolecularMaterial.hh"
#include "G4Material.hh"
#include <utility>
#include "G4StateManager.hh"
#include "G4Threading.hh"
#include "G4AutoLock.hh"
@@ -38,35 +39,39 @@
using namespace std;
G4DNAMolecularMaterial* G4DNAMolecularMaterial::fInstance(0);
G4Mutex aMutex = G4MUTEX_INITIALIZER;
G4DNAMolecularMaterial* G4DNAMolecularMaterial::fInstance(nullptr);
namespace
{
G4Mutex aMutex = G4MUTEX_INITIALIZER;
}
//------------------------------------------------------------------------------
bool CompareMaterial::operator()(const G4Material* mat1,
const G4Material* mat2) const
{
if (mat1 == 0 && mat2 == 0) return false; //(mat1 == mat2)
if (mat1 == 0) return true; // mat1 < mat2
if (mat2 == 0) return false; //mat2 < mat1
if (mat1 == nullptr && mat2 == nullptr) return false; //(mat1 == mat2)
if (mat1 == nullptr) return true; // mat1 < mat2
if (mat2 == nullptr) return false; //mat2 < mat1
const G4Material* baseMat1 = mat1->GetBaseMaterial();
const G4Material* baseMat2 = mat2->GetBaseMaterial();
if ((baseMat1 || baseMat2) == 0){
if (((baseMat1 != nullptr) || (baseMat2 != nullptr)) == false){
// None of the materials derives from a base material
return mat1 < mat2;
}
else if (baseMat1 && baseMat2){
else if ((baseMat1 != nullptr) && (baseMat2 != nullptr)){
// Both materials derive from a base material
return baseMat1 < baseMat2;
}
else if (baseMat1 && (baseMat2 == 0)){
else if ((baseMat1 != nullptr) && (baseMat2 == nullptr)){
// Only the material 1 derives from a base material
return baseMat1 < mat2;
}
// only case baseMat1==0 && baseMat2 remains
// only case baseMat1==nullptr && baseMat2 remains
return mat1 < baseMat2;
}
@@ -74,77 +79,67 @@ bool CompareMaterial::operator()(const G4Material* mat1,
G4DNAMolecularMaterial* G4DNAMolecularMaterial::Instance()
{
if (!fInstance) new G4DNAMolecularMaterial();
if (!fInstance) fInstance = new G4DNAMolecularMaterial();
return fInstance;
}
//------------------------------------------------------------------------------
void G4DNAMolecularMaterial::DeleteInstance()
{
if (fInstance){
delete fInstance;
fInstance = 0;
}
}
//------------------------------------------------------------------------------
void G4DNAMolecularMaterial::Create()
{
fpCompFractionTable = 0;
fpCompDensityTable = 0;
fpCompNumMolPerVolTable = 0;
fpCompFractionTable = nullptr;
fpCompDensityTable = nullptr;
fpCompNumMolPerVolTable = nullptr;
fIsInitialized = false;
fNMaterials = 0;
fInstance = this;
}
//------------------------------------------------------------------------------
void G4DNAMolecularMaterial::Clear()
{
if (fpCompFractionTable){
G4AutoLock l2(&aMutex);
if (fpCompFractionTable != nullptr){
fpCompFractionTable->clear();
delete fpCompFractionTable;
fpCompFractionTable = 0;
fpCompFractionTable = nullptr;
}
if (fpCompDensityTable){
if (fpCompDensityTable != nullptr){
fpCompDensityTable->clear();
delete fpCompDensityTable;
fpCompDensityTable = 0;
fpCompDensityTable = nullptr;
}
if (fpCompNumMolPerVolTable){
if (fpCompNumMolPerVolTable != nullptr){
fpCompNumMolPerVolTable->clear();
delete fpCompNumMolPerVolTable;
fpCompNumMolPerVolTable = 0;
fpCompNumMolPerVolTable = nullptr;
}
map<const G4Material*, std::vector<double>*, CompareMaterial>::iterator it;
std::map<const G4Material*, std::vector<G4double>*, CompareMaterial>::iterator it;
for (it = fAskedDensityTable.begin(); it != fAskedDensityTable.end(); it++){
if (it->second){
for (it = fAskedDensityTable.begin(); it != fAskedDensityTable.end(); ++it){
if (it->second != nullptr){
delete it->second;
it->second = 0;
it->second = nullptr;
}
}
for (it = fAskedNumPerVolTable.begin(); it != fAskedNumPerVolTable.end();
it++){
if (it->second){
for (it = fAskedNumPerVolTable.begin(); it != fAskedNumPerVolTable.end(); ++it){
if (it->second != nullptr){
delete it->second;
it->second = 0;
it->second = nullptr;
}
}
l2.unlock();
}
//------------------------------------------------------------------------------
G4DNAMolecularMaterial::G4DNAMolecularMaterial() :
G4VStateDependent()
{
Create();
fInstance = this;
}
//------------------------------------------------------------------------------
@@ -155,12 +150,6 @@ G4bool G4DNAMolecularMaterial::Notify(G4ApplicationState requestedState)
->GetPreviousState() == G4State_PreInit){
Initialize();
}
else if (requestedState == G4State_Quit){
// G4cout << "G4DNAMolecularMaterial::Notify ---> received G4State_Quit"
// << G4endl;
Clear();
//DeleteInstance();
}
return true;
}
@@ -187,17 +176,13 @@ G4DNAMolecularMaterial::operator=(const G4DNAMolecularMaterial& rhs)
G4DNAMolecularMaterial::~G4DNAMolecularMaterial()
{
// G4cout << "Deleting G4DNAMolecularMaterial" << G4endl;
Clear();
fInstance = 0;
//assert(G4StateManager::GetStateManager()->DeregisterDependent(this) == true);
}
//------------------------------------------------------------------------------
void G4DNAMolecularMaterial::Initialize()
{
G4AutoLock l(&aMutex);
if (fIsInitialized){
return;
}
@@ -208,21 +193,21 @@ void G4DNAMolecularMaterial::Initialize()
// This is to prevent segment fault if materials are created later on
// Actually this creation should not be done
if (fpCompFractionTable == 0){
G4AutoLock l1(&aMutex);
if (fpCompFractionTable == nullptr){
fpCompFractionTable = new vector<ComponentMap>(materialTable->size());
}
G4Material* mat(0);
G4Material* mat(nullptr);
for (size_t i = 0; i < fNMaterials; i++){
for (std::size_t i = 0; i < fNMaterials; ++i){
mat = materialTable->at(i);
SearchMolecularMaterial(mat, mat, 1);
mat = 0;
}
InitializeDensity();
InitializeNumMolPerVol();
l1.unlock();
fIsInitialized = true;
}
@@ -237,23 +222,23 @@ void G4DNAMolecularMaterial::InitializeDensity()
G4Material::GetMaterialTable()->size());
G4Material* parentMat;
const G4Material* compMat(0);
double massFraction = -1;
double parentDensity = -1;
const G4Material* compMat(nullptr);
G4double massFraction = -1;
G4double parentDensity = -1;
for (size_t i = 0; i < fNMaterials; i++){
for (std::size_t i = 0; i < fNMaterials; ++i){
parentMat = materialTable->at(i);
ComponentMap& massFractionComp = (*fpCompFractionTable)[i];
ComponentMap& densityComp = (*fpCompDensityTable)[i];
parentDensity = parentMat->GetDensity();
for (ComponentMap::iterator it = massFractionComp.begin();
it != massFractionComp.end(); it++){
for (auto it = massFractionComp.cbegin();
it != massFractionComp.cend(); ++it){
compMat = it->first;
massFraction = it->second;
densityComp[compMat] = massFraction * parentDensity;
compMat = 0;
compMat = nullptr;
massFraction = -1;
}
}
@@ -275,19 +260,19 @@ void G4DNAMolecularMaterial::InitializeNumMolPerVol()
if (fpCompDensityTable){
fpCompNumMolPerVolTable = new vector<ComponentMap>(fNMaterials);
const G4Material* compMat(0);
const G4Material* compMat(nullptr);
for (size_t i = 0; i < fNMaterials; i++){
for (std::size_t i = 0; i < fNMaterials; ++i){
ComponentMap& massFractionComp = (*fpCompFractionTable)[i];
ComponentMap& densityComp = (*fpCompDensityTable)[i];
ComponentMap& numMolPerVol = (*fpCompNumMolPerVolTable)[i];
for (ComponentMap::iterator it = massFractionComp.begin();
it != massFractionComp.end(); it++){
for (auto it = massFractionComp.cbegin();
it != massFractionComp.cend(); ++it){
compMat = it->first;
numMolPerVol[compMat] = densityComp[compMat]
/ compMat->GetMassOfMolecule();
compMat = 0;
compMat = nullptr;
}
}
}
@@ -316,9 +301,9 @@ G4DNAMolecularMaterial::RecordMolecularMaterial(G4Material* parentMaterial,
return;
}
ComponentMap::iterator it = matComponent.find(molecularMaterial);
auto it = matComponent.find(molecularMaterial);
if (it == matComponent.end()){
if (it == matComponent.cend()){
matComponent[molecularMaterial] = fraction;
}
else{
@@ -331,7 +316,7 @@ G4DNAMolecularMaterial::RecordMolecularMaterial(G4Material* parentMaterial,
void G4DNAMolecularMaterial::SearchMolecularMaterial(G4Material* parentMaterial,
G4Material* material,
double currentFraction)
G4double currentFraction)
{
if (material->GetMassOfMolecule() != 0.0){ // is a molecular material
RecordMolecularMaterial(parentMaterial, material, currentFraction);
@@ -341,9 +326,9 @@ void G4DNAMolecularMaterial::SearchMolecularMaterial(G4Material* parentMaterial,
G4Material* compMat(nullptr);
G4double fraction = -1.;
std::map<G4Material*, G4double> matComponent = material->GetMatComponents();
std::map<G4Material*, G4double>::iterator it = matComponent.begin();
auto it = matComponent.cbegin();
for (; it != matComponent.end(); it++){
for (; it != matComponent.cend(); ++it){
compMat = it->first;
fraction = it->second;
if (compMat->GetMassOfMolecule() == 0.0){ // is not a molecular material
@@ -359,7 +344,7 @@ void G4DNAMolecularMaterial::SearchMolecularMaterial(G4Material* parentMaterial,
//------------------------------------------------------------------------------
const std::vector<double>*
const std::vector<G4double>*
G4DNAMolecularMaterial::
GetDensityTableFor(const G4Material* lookForMaterial) const
{
@@ -390,28 +375,26 @@ GetDensityTableFor(const G4Material* lookForMaterial) const
}
}
std::map<const G4Material*, std::vector<double>*, CompareMaterial>::
const_iterator it_askedDensityTable =
fAskedDensityTable.find(lookForMaterial);
auto it_askedDensityTable = fAskedDensityTable.find(lookForMaterial);
if (it_askedDensityTable != fAskedDensityTable.end()){
if (it_askedDensityTable != fAskedDensityTable.cend()){
return it_askedDensityTable->second;
}
const G4MaterialTable* materialTable = G4Material::GetMaterialTable();
std::vector<double>* output = new std::vector<double>(materialTable->size());
std::vector<G4double>* output = new std::vector<G4double>(materialTable->size());
ComponentMap::const_iterator it;
G4bool materialWasNotFound = true;
for (size_t i = 0; i < fNMaterials; i++){
for (std::size_t i = 0; i < fNMaterials; ++i){
ComponentMap& densityTable = (*fpCompDensityTable)[i];
it = densityTable.find(lookForMaterial);
if (it == densityTable.end()){
if (it == densityTable.cend()){
(*output)[i] = 0.0;
}
else{
@@ -432,10 +415,10 @@ GetDensityTableFor(const G4Material* lookForMaterial) const
//------------------------------------------------------------------------------
const std::vector<double>* G4DNAMolecularMaterial::GetNumMolPerVolTableFor(
const std::vector<G4double>* G4DNAMolecularMaterial::GetNumMolPerVolTableFor(
const G4Material* lookForMaterial) const
{
if(lookForMaterial==0) return nullptr;
if(lookForMaterial==nullptr) return nullptr;
if (!fpCompNumMolPerVolTable){
if (fIsInitialized){
@@ -464,27 +447,25 @@ const std::vector<double>* G4DNAMolecularMaterial::GetNumMolPerVolTableFor(
}
}
std::map<const G4Material*, std::vector<double>*, CompareMaterial>::
const_iterator it_askedNumMolPerVolTable =
fAskedNumPerVolTable.find(lookForMaterial);
if (it_askedNumMolPerVolTable != fAskedNumPerVolTable.end()){
auto it_askedNumMolPerVolTable = fAskedNumPerVolTable.find(lookForMaterial);
if (it_askedNumMolPerVolTable != fAskedNumPerVolTable.cend()){
return it_askedNumMolPerVolTable->second;
}
const G4MaterialTable* materialTable = G4Material::GetMaterialTable();
std::vector<double>* output = new std::vector<double>(materialTable->size());
std::vector<G4double>* output = new std::vector<G4double>(materialTable->size());
ComponentMap::const_iterator it;
G4bool materialWasNotFound = true;
for (size_t i = 0; i < fNMaterials; i++){
for (std::size_t i = 0; i < fNMaterials; ++i){
ComponentMap& densityTable = (*fpCompNumMolPerVolTable)[i];
it = densityTable.find(lookForMaterial);
if (it == densityTable.end()){
if (it == densityTable.cend()){
(*output)[i] = 0.0;
}
else{
@@ -509,10 +490,9 @@ void G4DNAMolecularMaterial::
PrintNotAMolecularMaterial(const char* methodName,
const G4Material* lookForMaterial) const
{
std::map<const G4Material*, bool, CompareMaterial>::iterator it =
fWarningPrinted.find(lookForMaterial);
auto it = fWarningPrinted.find(lookForMaterial);
if (it == fWarningPrinted.end()){
if (it == fWarningPrinted.cend()){
G4ExceptionDescription exceptionDescription;
exceptionDescription << "The material " << lookForMaterial->GetName()
<< " is not defined as a molecular material."
@@ -544,7 +524,7 @@ GetMolecularConfiguration(const G4Material* material) const
{
int material_id = material->GetIndex();
auto it = fMaterialToMolecularConf.find(material_id);
if(it == fMaterialToMolecularConf.end()) return 0;
if(it == fMaterialToMolecularConf.cend()) return nullptr;
return it->second;
}
@@ -555,7 +535,7 @@ G4DNAMolecularMaterial::
SetMolecularConfiguration(const G4Material* material,
G4MolecularConfiguration* molConf)
{
assert(material != 0);
assert(material != nullptr);
int material_id = material->GetIndex();
fMaterialToMolecularConf[material_id] = molConf;
}
@@ -566,7 +546,7 @@ void
G4DNAMolecularMaterial::SetMolecularConfiguration(const G4Material* material,
const G4String& molUserID)
{
assert(material != 0);
assert(material != nullptr);
int material_id = material->GetIndex();
fMaterialToMolecularConf[material_id] =
G4MoleculeTable::Instance()->GetConfiguration(molUserID, true);
@@ -580,7 +560,7 @@ G4DNAMolecularMaterial::SetMolecularConfiguration(const G4String& materialName,
{
G4Material* material = G4Material::GetMaterial(materialName);
if(material == 0){
if(material == nullptr){
G4cout<< "Material " << materialName
<< " was not found and therefore won't be linked to "
<< molUserID << G4endl;
@@ -600,7 +580,7 @@ GetNumMoleculePerVolumeUnitForMaterial(const G4Material*)
FatalException,"Use standard method: GetNumMolPerVolTableFor"
" at the run initialization to retrieve a read-only table used"
" during stepping. The method is thread-safe.");
return 0;
return 0.;
}
//------------------------------------------------------------------------------
@@ -616,5 +596,5 @@ GetNumMolPerVolForComponentInComposite(const G4Material*,
FatalException,"Use standard method: GetNumMolPerVolTableFor"
" at the run initialization to retrieve a read-only table used"
" during stepping. The method is thread-safe.");
return 0;
return 0.;
}
source/processes/electromagnetic/dna/utils/src/G4ErrorFunction.cc
Executable → Regular
View File