G4ITModelHandler Class Reference

#include <G4ITModelHandler.hh>


Public Member Functions

 G4ITModelHandler ()
 G4ITModelHandler (const G4ITModelHandler &other)
G4ITModelHandleroperator= (const G4ITModelHandler &rhs)
 ~G4ITModelHandler ()
void Initialize ()
void RegisterModel (G4VITModel *aModel, const G4double globalTime)
G4ITModelManagerGetModelManager (G4ITType, G4ITType)
void SetModel (G4ITType, G4ITType, G4VITModel *aModel, G4double startingTime)
G4VITModelGetModel (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::G4ITModelHandler (  ) 

Definition at line 39 of file G4ITModelHandler.cc.

References fIsInitialized, fModelManager, fReactionProcessFlag, fTimeStepComputerFlag, and G4ITType::size().

00040 {
00041     //ctor
00042     fIsInitialized = false;
00043     fTimeStepComputerFlag = false;
00044     fReactionProcessFlag = false;
00045 
00046     size_t IT_size (G4ITType::size());
00047 
00048     fModelManager.assign(IT_size, std::vector<G4ITModelManager*>());
00049     for(G4int i = 0 ; i < (int) IT_size ; i++)
00050     {
00051         fModelManager[i].assign(IT_size,0);
00052     }
00053 }

G4ITModelHandler::G4ITModelHandler ( const G4ITModelHandler other  ) 

Definition at line 75 of file G4ITModelHandler.cc.

References fModelManager, and G4ITType::size().

00076 {
00077     //copy ctor
00078     size_t IT_size (G4ITType::size());
00079 
00080     fModelManager.assign(IT_size, std::vector<G4ITModelManager*>());
00081     for(int i = 0 ; i < (int) IT_size ; i++)
00082     {
00083         fModelManager[i].assign(IT_size,0);
00084         for(int j = 0 ; j < (int) IT_size ; j++)
00085         {
00086             if(other.fModelManager[i][j] != 0)
00087             {
00088                 fModelManager[i][j] = new G4ITModelManager(*(other.fModelManager[i][j])) ;
00089             }
00090         }
00091     }
00092 
00093     fIsInitialized = other.fIsInitialized;
00094     fTimeStepComputerFlag = other.fTimeStepComputerFlag;
00095     fReactionProcessFlag = other.fReactionProcessFlag;
00096 }

G4ITModelHandler::~G4ITModelHandler (  ) 

Default destructor

Definition at line 55 of file G4ITModelHandler.cc.

References fModelManager.

00056 {
00057     //dtor
00058     G4int size = fModelManager.size();
00059 
00060     for(G4int i = 0 ; i < size ; i++)
00061     {
00062         for(G4int j = 0 ; j <= i ; j++)
00063         {
00064             if(fModelManager[i][j])
00065             {
00066                 delete fModelManager[i][j];
00067                 fModelManager[i][j] = 0;
00068                 fModelManager[j][i] = 0;
00069             }
00070         }
00071     }
00072     fModelManager.clear();
00073 }


Member Function Documentation

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

Definition at line 72 of file G4ITModelHandler.hh.

References fModelManager.

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

00073     {
00074         return &fModelManager;
00075     }

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

Definition at line 204 of file G4ITModelHandler.cc.

References fModelManager.

00207 {
00208     if(fModelManager.empty())
00209     {
00210         return 0;
00211     }
00212 
00213     if((int) fModelManager.size() < type1) return 0;
00214 
00215     std::vector<G4ITModelManager*>* v = &(fModelManager.at(type1));
00216 
00217     if((int) v->size() < type2) return 0;
00218 
00219     if(v->at(type2))
00220     {
00221         return v->at(type2)->GetModel(globalTime);
00222     }
00223     return 0;
00224 }

G4ITModelManager * G4ITModelHandler::GetModelManager ( G4ITType  ,
G4ITType   
) [inline]

Definition at line 89 of file G4ITModelHandler.hh.

References fModelManager.

00090 {
00091     if(fModelManager.empty())
00092     {
00093         return 0;
00094     }
00095 
00096     if((int) fModelManager.size() < type1) return 0;
00097 
00098     std::vector<G4ITModelManager*>* v = &(fModelManager.at(type1));
00099 
00100     if((int) v->size() < type2) return 0;
00101 
00102     return v->at(type2);
00103 }

bool G4ITModelHandler::GetReactionProcessFlag (  )  [inline]

Definition at line 78 of file G4ITModelHandler.hh.

References fReactionProcessFlag.

00078 {return fReactionProcessFlag;}

bool G4ITModelHandler::GetTimeStepComputerFlag (  )  [inline]

Definition at line 77 of file G4ITModelHandler.hh.

References fTimeStepComputerFlag.

00077 {return fTimeStepComputerFlag;}

void G4ITModelHandler::Initialize (  ) 

Definition at line 105 of file G4ITModelHandler.cc.

References fIsInitialized, and fModelManager.

Referenced by G4ITModelProcessor::Initialize().

00106 {
00107     fIsInitialized = true;
00108 
00109     for(G4int i = 0 ; i < int(fModelManager.size()) ; i++)
00110     {
00111         for(G4int j = 0 ; j <= i ; j++)
00112         {
00113             G4ITModelManager* modman = fModelManager[i][j];
00114             if(modman)
00115             {
00116                 modman->Initialize();
00117             }
00118         }
00119     }
00120 }

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

Definition at line 98 of file G4ITModelHandler.cc.

00099 {
00100     if (this == &rhs) return *this; // handle self assignment
00101     //assignment operator
00102     return *this;
00103 }

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

Definition at line 122 of file G4ITModelHandler.cc.

References buffer, fModelManager, fReactionProcessFlag, fTimeStepComputerFlag, G4VITModel::GetReactionProcess(), G4VITModel::GetTimeStepper(), G4VITModel::IsApplicable(), SetModel(), and G4ITType::size().

00125 {
00126     assert(aModel != 0);
00127 
00128     //________________________________________________
00129     // Prepare the correct model manager
00130     if( fModelManager.empty() )
00131     {
00132         size_t IT_size (G4ITType::size());
00133         fModelManager.assign(IT_size, std::vector<G4ITModelManager*>());
00134 
00135         for(int i = 0 ; i < (int) IT_size ; i++)
00136         {
00137             fModelManager[i].assign((size_t) i,0);
00138         }
00139     }
00140 
00141     G4ITType type1;
00142     G4ITType type2;
00143 
00144     //________________________________________________
00145     // Retrieve applicability
00146     aModel->IsApplicable(type1, type2);
00147 
00148     if(type1 > type2)
00149     {
00150         G4ITType buffer(-1);
00151         buffer = type1;
00152         type1 = type2;
00153         type2 = buffer;
00154     }
00155 
00156     if(fModelManager[type1][type2] == 0)
00157     {
00158         fModelManager[type1][type2] = new G4ITModelManager();
00159     }
00160 
00161     fModelManager[type1][type2]-> SetModel(aModel, startingTime);
00162 
00163     //________________________________________________
00164     // Setup ITStepManager
00165     if(aModel->GetTimeStepper())
00166     {
00167         fTimeStepComputerFlag = true;
00168     }
00169     if(aModel->GetReactionProcess())
00170     {
00171         fReactionProcessFlag = true;
00172     }
00173 }

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

Definition at line 175 of file G4ITModelHandler.cc.

References buffer, and fModelManager.

Referenced by RegisterModel().

00179 {
00180     assert(aModel == 0);
00181 
00182     if(type1 > type2)
00183     {
00184         G4ITType buffer(-1);
00185         buffer = type1;
00186         type1 = type2;
00187         type2 = buffer;
00188     }
00189 
00190     if(type1 > (int) fModelManager.capacity())
00191     {
00192         fModelManager.reserve(type1);
00193     }
00194 
00195     if(type2 > (int) fModelManager[type1].capacity())
00196     {
00197         fModelManager[type1].reserve(type2);
00198     }
00199 
00200     fModelManager[type1][type2] -> SetModel(aModel, startingTime);
00201 }


Field Documentation

G4bool G4ITModelHandler::fIsInitialized [protected]

Definition at line 81 of file G4ITModelHandler.hh.

Referenced by G4ITModelHandler(), and Initialize().

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

G4bool G4ITModelHandler::fReactionProcessFlag [protected]

Definition at line 85 of file G4ITModelHandler.hh.

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

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:
Generated on Mon May 27 17:52:19 2013 for Geant4 by  doxygen 1.4.7