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

Import Geant4 10.6.0.beta source tree

Browse Source
This commit is contained in:
Gabriele Cosmo
2019-06-28 11:59:04 +02:00
parent 28a70706e0
commit d0f911957d
1056 changed files with 95168 additions and 78160 deletions
Download Patch File Download Diff File Expand all files Collapse all files
source/processes/electromagnetic/dna/management/src/G4ITModelHandler.cc
+47 -160
View File
@@ -33,190 +33,77 @@
// -------------------------------------------------------------------
#include "G4ITModelHandler.hh"
#include "G4ITModelManager.hh"
#include "G4VITStepModel.hh"
#include <assert.h>
G4ITModelHandler::G4ITModelHandler()
{
//ctor
fIsInitialized = false;
fTimeStepComputerFlag = false;
fReactionProcessFlag = false;
size_t IT_size(G4ITType::size());
fModelManager.assign(IT_size, std::vector<G4ITModelManager*>());
for (G4int i = 0; i < (int) IT_size; i++)
{
fModelManager[i].assign(IT_size, 0);
}
fIsInitialized = false;
fTimeStepComputerFlag = false;
fReactionProcessFlag = false;
}
G4ITModelHandler::~G4ITModelHandler()
{
//dtor
G4int size = fModelManager.size();
for (G4int i = 0; i < size; i++)
{
for (G4int j = 0; j <= i; j++)
{
if (fModelManager[i][j])
{
delete fModelManager[i][j];
fModelManager[i][j] = 0;
fModelManager[j][i] = 0;
}
}
}
fModelManager.clear();
}
G4ITModelHandler::G4ITModelHandler(const G4ITModelHandler& other)
{
//copy ctor
size_t IT_size(G4ITType::size());
fModelManager.assign(IT_size, std::vector<G4ITModelManager*>());
for (int i = 0; i < (int) IT_size; i++)
{
fModelManager[i].assign(IT_size, 0);
for (int j = 0; j < (int) IT_size; j++)
{
if (other.fModelManager[i][j] != 0)
{
fModelManager[i][j] = new G4ITModelManager(
*(other.fModelManager[i][j]));
}
}
}
fIsInitialized = other.fIsInitialized;
fTimeStepComputerFlag = other.fTimeStepComputerFlag;
fReactionProcessFlag = other.fReactionProcessFlag;
}
G4ITModelHandler& G4ITModelHandler::operator=(const G4ITModelHandler& rhs)
{
if (this == &rhs) return *this; // handle self assignment
//assignment operator
return *this;
}
G4ITModelHandler::~G4ITModelHandler() = default;
void G4ITModelHandler::Initialize()
{
fIsInitialized = true;
for (G4int i = 0; i < int(fModelManager.size()); i++)
{
for (G4int j = 0; j <= i; j++)
{
G4ITModelManager* modman = fModelManager[i][j];
if (modman)
{
modman->Initialize();
}
}
}
fpModelManager->Initialize();
fIsInitialized = true;
}
void G4ITModelHandler::RegisterModel(G4VITStepModel* aModel,
void G4ITModelHandler::RegisterModel(G4VITStepModel* pModel,
G4double startingTime)
{
assert(aModel != 0);
assert(pModel != nullptr);
//________________________________________________
// Prepare the correct model manager
if (fModelManager.empty())
{
size_t IT_size(G4ITType::size());
fModelManager.assign(IT_size, std::vector<G4ITModelManager*>());
G4ITType type1;
G4ITType type2;
for (int i = 0; i < (int) IT_size; i++)
pModel->GetApplicable(type1, type2);
if (type1 != type2)
{
fModelManager[i].assign((size_t) i, 0);
G4Exception("G4ITModelHandler::RegisterModel",
"FeatureDisabled",
FatalException,
"Models for different type ids are not supported anymore. This feature will be superseded.");
}
}
G4ITType type1;
G4ITType type2;
if(!fpModelManager)
{
fpModelManager.reset(new G4ITModelManager());
}
//________________________________________________
// Retrieve applicability
aModel->IsApplicable(type1, type2);
fpModelManager->SetModel(pModel, startingTime);
if (type1 > type2)
{
G4ITType buffer(-1);
buffer = type1;
type1 = type2;
type2 = buffer;
}
if (fModelManager[type1][type2] == 0)
{
fModelManager[type1][type2] = new G4ITModelManager();
}
fModelManager[type1][type2]->SetModel(aModel, startingTime);
//________________________________________________
// Setup ITStepManager
if (aModel->GetTimeStepper())
{
fTimeStepComputerFlag = true;
}
if (aModel->GetReactionProcess())
{
fReactionProcessFlag = true;
}
//________________________________________________
// Setup ITStepManager
if (pModel->GetTimeStepper())
{
fTimeStepComputerFlag = true;
}
if (pModel->GetReactionProcess())
{
fReactionProcessFlag = true;
}
}
void G4ITModelHandler::SetModel(G4ITType type1,
G4ITType type2,
G4VITStepModel* aModel,
G4double startingTime)
std::vector<G4VITStepModel*> G4ITModelHandler::GetActiveModels(G4double globalTime) const
{
assert(aModel == 0);
if (type1 > type2)
{
G4ITType buffer(-1);
buffer = type1;
type1 = type2;
type2 = buffer;
}
if (type1 > (int) fModelManager.capacity())
{
fModelManager.reserve(type1);
}
if (type2 > (int) fModelManager[type1].capacity())
{
fModelManager[type1].reserve(type2);
}
fModelManager[type1][type2]->SetModel(aModel, startingTime);
if(!fpModelManager)
{
return {};
}
return fpModelManager->GetActiveModels(globalTime);
}
G4VITStepModel* G4ITModelHandler::GetModel(G4ITType type1,
G4ITType type2,
const G4double globalTime)
bool G4ITModelHandler::GetTimeStepComputerFlag()
{
if (fModelManager.empty())
{
return 0;
}
if ((int) fModelManager.size() < type1) return 0;
std::vector<G4ITModelManager*>* v = &(fModelManager.at(type1));
if ((int) v->size() < type2) return 0;
if (v->at(type2))
{
return v->at(type2)->GetModel(globalTime);
}
return 0;
return fTimeStepComputerFlag;
}
bool G4ITModelHandler::GetReactionProcessFlag()
{
return fReactionProcessFlag;
}