Geant4 9.6.0
Toolkit for the simulation of the passage of particles through matter
Loading...
Searching...
No Matches
Public Member Functions | Protected Attributes | List of all members
G4ITModelHandler Class Reference

#include <G4ITModelHandler.hh>

Public Member Functions

 G4ITModelHandler ()
 
 G4ITModelHandler (const G4ITModelHandler &other)
 
G4ITModelHandler & operator= (const G4ITModelHandler &rhs)
 
 ~G4ITModelHandler ()
 
void Initialize ()
 
void RegisterModel (G4VITModel *aModel, const G4double globalTime)
 
G4ITModelManager * GetModelManager (G4ITType, G4ITType)
 
void SetModel (G4ITType, G4ITType, G4VITModel *aModel, G4double startingTime)
 
G4VITModel * GetModel (G4ITType, G4ITType, const G4double globalTime)
 
const std::vector< std::vector< G4ITModelManager * > > * GetAllModelManager ()
 
bool GetTimeStepComputerFlag ()
 
bool GetReactionProcessFlag ()
 

Protected Attributes

G4bool fIsInitialized
 
std::vector< std::vector< G4ITModelManager * > > fModelManager
 
G4bool fTimeStepComputerFlag
 
G4bool fReactionProcessFlag
 

Detailed Description

G4ITModelHandler holds for two IT types the corresponding model manager

Definition at line 48 of file G4ITModelHandler.hh.

Constructor & Destructor Documentation

◆ G4ITModelHandler() [1/2]

G4ITModelHandler::G4ITModelHandler ( )

Definition at line 39 of file G4ITModelHandler.cc.

40{
41 //ctor
42 fIsInitialized = false;
43 fTimeStepComputerFlag = false;
44 fReactionProcessFlag = false;
45
46 size_t IT_size (G4ITType::size());
47
48 fModelManager.assign(IT_size, std::vector<G4ITModelManager*>());
49 for(G4int i = 0 ; i < (int) IT_size ; i++)
50 {
51 fModelManager[i].assign(IT_size,0);
52 }
53}
G4int
int G4int
Definition: G4Types.hh:66
G4ITModelHandler::fModelManager
std::vector< std::vector< G4ITModelManager * > > fModelManager
Definition: G4ITModelHandler.hh:82
G4ITType::size
static size_t size()
Definition: G4ITType.cc:41

◆ G4ITModelHandler() [2/2]

G4ITModelHandler::G4ITModelHandler ( const G4ITModelHandler &  other)

Definition at line 75 of file G4ITModelHandler.cc.

76{
77 //copy ctor
78 size_t IT_size (G4ITType::size());
79
80 fModelManager.assign(IT_size, std::vector<G4ITModelManager*>());
81 for(int i = 0 ; i < (int) IT_size ; i++)
82 {
83 fModelManager[i].assign(IT_size,0);
84 for(int j = 0 ; j < (int) IT_size ; j++)
85 {
86 if(other.fModelManager[i][j] != 0)
87 {
88 fModelManager[i][j] = new G4ITModelManager(*(other.fModelManager[i][j])) ;
89 }
90 }
91 }
92
93 fIsInitialized = other.fIsInitialized;
94 fTimeStepComputerFlag = other.fTimeStepComputerFlag;
95 fReactionProcessFlag = other.fReactionProcessFlag;
96}

◆ ~G4ITModelHandler()

G4ITModelHandler::~G4ITModelHandler ( )

Default destructor

Definition at line 55 of file G4ITModelHandler.cc.

56{
57 //dtor
58 G4int size = fModelManager.size();
59
60 for(G4int i = 0 ; i < size ; i++)
61 {
62 for(G4int j = 0 ; j <= i ; j++)
63 {
64 if(fModelManager[i][j])
65 {
66 delete fModelManager[i][j];
67 fModelManager[i][j] = 0;
68 fModelManager[j][i] = 0;
69 }
70 }
71 }
72 fModelManager.clear();
73}

Member Function Documentation

◆ GetAllModelManager()

const std::vector< std::vector< G4ITModelManager * > > * G4ITModelHandler::GetAllModelManager ( )
inline

Definition at line 72 of file G4ITModelHandler.hh.

73 {
74 return &fModelManager;
75 }

Referenced by G4ITModelProcessor::FindReaction(), and G4ITModelProcessor::InitializeStepper().

◆ GetModel()

G4VITModel * G4ITModelHandler::GetModel ( G4ITType  type1,
G4ITType  type2,
const G4double  globalTime 
)

Definition at line 204 of file G4ITModelHandler.cc.

207{
208 if(fModelManager.empty())
209 {
210 return 0;
211 }
212
213 if((int) fModelManager.size() < type1) return 0;
214
215 std::vector<G4ITModelManager*>* v = &(fModelManager.at(type1));
216
217 if((int) v->size() < type2) return 0;
218
219 if(v->at(type2))
220 {
221 return v->at(type2)->GetModel(globalTime);
222 }
223 return 0;
224}

◆ GetModelManager()

G4ITModelManager * G4ITModelHandler::GetModelManager ( G4ITType  type1,
G4ITType  type2 
)
inline

Definition at line 89 of file G4ITModelHandler.hh.

90{
91 if(fModelManager.empty())
92 {
93 return 0;
94 }
95
96 if((int) fModelManager.size() < type1) return 0;
97
98 std::vector<G4ITModelManager*>* v = &(fModelManager.at(type1));
99
100 if((int) v->size() < type2) return 0;
101
102 return v->at(type2);
103}

◆ GetReactionProcessFlag()

bool G4ITModelHandler::GetReactionProcessFlag ( )
inline

Definition at line 78 of file G4ITModelHandler.hh.

78{return fReactionProcessFlag;}

◆ GetTimeStepComputerFlag()

bool G4ITModelHandler::GetTimeStepComputerFlag ( )
inline

Definition at line 77 of file G4ITModelHandler.hh.

77{return fTimeStepComputerFlag;}

◆ Initialize()

void G4ITModelHandler::Initialize ( )

Definition at line 105 of file G4ITModelHandler.cc.

106{
107 fIsInitialized = true;
108
109 for(G4int i = 0 ; i < int(fModelManager.size()) ; i++)
110 {
111 for(G4int j = 0 ; j <= i ; j++)
112 {
113 G4ITModelManager* modman = fModelManager[i][j];
114 if(modman)
115 {
116 modman->Initialize();
117 }
118 }
119 }
120}

Referenced by G4ITModelProcessor::Initialize().

◆ operator=()

G4ITModelHandler & G4ITModelHandler::operator= ( const G4ITModelHandler &  rhs)

Definition at line 98 of file G4ITModelHandler.cc.

99{
100 if (this == &rhs) return *this; // handle self assignment
101 //assignment operator
102 return *this;
103}

◆ RegisterModel()

void G4ITModelHandler::RegisterModel ( G4VITModel *  aModel,
const G4double  globalTime 
)

Definition at line 122 of file G4ITModelHandler.cc.

125{
126 assert(aModel != 0);
127
128 //________________________________________________
129 // Prepare the correct model manager
130 if( fModelManager.empty() )
131 {
132 size_t IT_size (G4ITType::size());
133 fModelManager.assign(IT_size, std::vector<G4ITModelManager*>());
134
135 for(int i = 0 ; i < (int) IT_size ; i++)
136 {
137 fModelManager[i].assign((size_t) i,0);
138 }
139 }
140
141 G4ITType type1;
142 G4ITType type2;
143
144 //________________________________________________
145 // Retrieve applicability
146 aModel->IsApplicable(type1, type2);
147
148 if(type1 > type2)
149 {
150 G4ITType buffer(-1);
151 buffer = type1;
152 type1 = type2;
153 type2 = buffer;
154 }
155
156 if(fModelManager[type1][type2] == 0)
157 {
158 fModelManager[type1][type2] = new G4ITModelManager();
159 }
160
161 fModelManager[type1][type2]-> SetModel(aModel, startingTime);
162
163 //________________________________________________
164 // Setup ITStepManager
165 if(aModel->GetTimeStepper())
166 {
167 fTimeStepComputerFlag = true;
168 }
169 if(aModel->GetReactionProcess())
170 {
171 fReactionProcessFlag = true;
172 }
173}
G4ITModelHandler::SetModel
void SetModel(G4ITType, G4ITType, G4VITModel *aModel, G4double startingTime)
Definition: G4ITModelHandler.cc:175
G4VITModel::GetTimeStepper
G4VITTimeStepper * GetTimeStepper()
Definition: G4VITModel.hh:123
G4VITModel::IsApplicable
void IsApplicable(G4ITType &type1, G4ITType &type2)
Definition: G4VITModel.cc:88
G4VITModel::GetReactionProcess
G4VITReactionProcess * GetReactionProcess()
Definition: G4VITModel.hh:128
buffer
#define buffer
Definition: xmlparse.cc:611

◆ SetModel()

void G4ITModelHandler::SetModel ( G4ITType  type1,
G4ITType  type2,
G4VITModel *  aModel,
G4double  startingTime 
)

Definition at line 175 of file G4ITModelHandler.cc.

179{
180 assert(aModel == 0);
181
182 if(type1 > type2)
183 {
184 G4ITType buffer(-1);
185 buffer = type1;
186 type1 = type2;
187 type2 = buffer;
188 }
189
190 if(type1 > (int) fModelManager.capacity())
191 {
192 fModelManager.reserve(type1);
193 }
194
195 if(type2 > (int) fModelManager[type1].capacity())
196 {
197 fModelManager[type1].reserve(type2);
198 }
199
200 fModelManager[type1][type2] -> SetModel(aModel, startingTime);
201}

Referenced by RegisterModel(), and SetModel().

Member Data Documentation

◆ fIsInitialized

G4bool G4ITModelHandler::fIsInitialized
protected

Definition at line 81 of file G4ITModelHandler.hh.

Referenced by G4ITModelHandler(), and Initialize().

◆ fModelManager

std::vector<std::vector<G4ITModelManager*> > G4ITModelHandler::fModelManager
protected

Definition at line 82 of file G4ITModelHandler.hh.

Referenced by G4ITModelHandler(), GetAllModelManager(), GetModel(), GetModelManager(), Initialize(), RegisterModel(), SetModel(), and ~G4ITModelHandler().

◆ fReactionProcessFlag

G4bool G4ITModelHandler::fReactionProcessFlag
protected

Definition at line 85 of file G4ITModelHandler.hh.

Referenced by G4ITModelHandler(), GetReactionProcessFlag(), and RegisterModel().

◆ fTimeStepComputerFlag

G4bool G4ITModelHandler::fTimeStepComputerFlag
protected

Definition at line 84 of file G4ITModelHandler.hh.

Referenced by G4ITModelHandler(), GetTimeStepComputerFlag(), and RegisterModel().

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