Geant4 Cross Reference |
1 // 1 // 2 // ******************************************* 2 // ******************************************************************** 3 // * License and Disclaimer 3 // * License and Disclaimer * 4 // * 4 // * * 5 // * The Geant4 software is copyright of th 5 // * The Geant4 software is copyright of the Copyright Holders of * 6 // * the Geant4 Collaboration. It is provided 6 // * the Geant4 Collaboration. It is provided under the terms and * 7 // * conditions of the Geant4 Software License 7 // * conditions of the Geant4 Software License, included in the file * 8 // * LICENSE and available at http://cern.ch/ 8 // * LICENSE and available at http://cern.ch/geant4/license . These * 9 // * include a list of copyright holders. 9 // * include a list of copyright holders. * 10 // * 10 // * * 11 // * Neither the authors of this software syst 11 // * Neither the authors of this software system, nor their employing * 12 // * institutes,nor the agencies providing fin 12 // * institutes,nor the agencies providing financial support for this * 13 // * work make any representation or warran 13 // * work make any representation or warranty, express or implied, * 14 // * regarding this software system or assum 14 // * regarding this software system or assume any liability for its * 15 // * use. Please see the license in the file 15 // * use. Please see the license in the file LICENSE and URL above * 16 // * for the full disclaimer and the limitatio 16 // * for the full disclaimer and the limitation of liability. * 17 // * 17 // * * 18 // * This code implementation is the result 18 // * This code implementation is the result of the scientific and * 19 // * technical work of the GEANT4 collaboratio 19 // * technical work of the GEANT4 collaboration. * 20 // * By using, copying, modifying or distri 20 // * By using, copying, modifying or distributing the software (or * 21 // * any work based on the software) you ag 21 // * any work based on the software) you agree to acknowledge its * 22 // * use in resulting scientific publicati 22 // * use in resulting scientific publications, and indicate your * 23 // * acceptance of all terms of the Geant4 Sof 23 // * acceptance of all terms of the Geant4 Software license. * 24 // ******************************************* 24 // ******************************************************************** 25 // 25 // >> 26 // $Id: G4ITModelHandler.cc 64057 2012-10-30 15:04:49Z gcosmo $ 26 // 27 // 27 // Author: Mathieu Karamitros (kara (AT) cenbg 28 // Author: Mathieu Karamitros (kara (AT) cenbg . in2p3 . fr) 28 // 29 // 29 // History: 30 // History: 30 // ----------- 31 // ----------- 31 // 10 Oct 2011 M.Karamitros created 32 // 10 Oct 2011 M.Karamitros created 32 // 33 // 33 // ------------------------------------------- 34 // ------------------------------------------------------------------- 34 35 35 #include "G4ITModelHandler.hh" 36 #include "G4ITModelHandler.hh" 36 << 37 #include <assert.h> 37 #include "G4ITModelManager.hh" << 38 #include "G4VITStepModel.hh" << 39 << 40 #include <cassert> << 41 #include <memory> << 42 38 43 G4ITModelHandler::G4ITModelHandler() 39 G4ITModelHandler::G4ITModelHandler() 44 { 40 { >> 41 //ctor 45 fIsInitialized = false; 42 fIsInitialized = false; 46 fTimeStepComputerFlag = false; 43 fTimeStepComputerFlag = false; 47 fReactionProcessFlag = 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 } 48 } 53 } 49 54 50 G4ITModelHandler::~G4ITModelHandler() = defaul << 55 G4ITModelHandler::~G4ITModelHandler() >> 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 } >> 74 >> 75 G4ITModelHandler::G4ITModelHandler(const G4ITModelHandler& other) >> 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 } >> 97 >> 98 G4ITModelHandler& G4ITModelHandler::operator=(const G4ITModelHandler& rhs) >> 99 { >> 100 if (this == &rhs) return *this; // handle self assignment >> 101 //assignment operator >> 102 return *this; >> 103 } 51 104 52 void G4ITModelHandler::Initialize() 105 void G4ITModelHandler::Initialize() 53 { 106 { 54 fpModelManager->Initialize(); << 55 fIsInitialized = true; 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 } 56 } 120 } 57 121 58 void G4ITModelHandler::RegisterModel(G4VITStep << 122 void G4ITModelHandler::RegisterModel( 59 G4double << 123 G4VITModel* aModel, >> 124 G4double startingTime) 60 { 125 { 61 if(fFinalize) << 126 assert(aModel != 0); >> 127 >> 128 //________________________________________________ >> 129 // Prepare the correct model manager >> 130 if( fModelManager.empty() ) 62 { 131 { 63 return; << 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 } 64 } 139 } 65 assert(pModel != nullptr); << 66 140 67 G4ITType type1; 141 G4ITType type1; 68 G4ITType type2; 142 G4ITType type2; 69 143 70 pModel->GetApplicable(type1, type2); << 144 //________________________________________________ >> 145 // Retrieve applicability >> 146 aModel->IsApplicable(type1, type2); 71 147 72 if (type1 != type2) << 148 if(type1 > type2) 73 { 149 { 74 G4Exception("G4ITModelHandler::Registe << 150 G4ITType buffer(-1); 75 "FeatureDisabled", << 151 buffer = type1; 76 FatalException, << 152 type1 = type2; 77 "Models for different type << 153 type2 = buffer; 78 } 154 } 79 155 80 if(!fpModelManager) << 156 if(fModelManager[type1][type2] == 0) 81 { 157 { 82 fpModelManager = std::make_unique<G4IT << 158 fModelManager[type1][type2] = new G4ITModelManager(); 83 } 159 } 84 160 85 fpModelManager->SetModel(pModel, startingT << 161 fModelManager[type1][type2]-> SetModel(aModel, startingTime); 86 162 87 //________________________________________ 163 //________________________________________________ 88 // Setup ITStepManager 164 // Setup ITStepManager 89 if (pModel->GetTimeStepper() != nullptr) << 165 if(aModel->GetTimeStepper()) 90 { 166 { 91 fTimeStepComputerFlag = true; 167 fTimeStepComputerFlag = true; 92 } 168 } 93 if (pModel->GetReactionProcess() != nullpt << 169 if(aModel->GetReactionProcess()) 94 { 170 { 95 fReactionProcessFlag = true; 171 fReactionProcessFlag = true; 96 } 172 } 97 } 173 } 98 174 99 std::vector<G4VITStepModel*> G4ITModelHandler: << 175 void G4ITModelHandler::SetModel(G4ITType type1, >> 176 G4ITType type2, >> 177 G4VITModel* aModel, >> 178 G4double startingTime) 100 { 179 { 101 if(!fpModelManager) << 180 assert(aModel == 0); >> 181 >> 182 if(type1 > type2) 102 { 183 { 103 return {}; << 184 G4ITType buffer(-1); >> 185 buffer = type1; >> 186 type1 = type2; >> 187 type2 = buffer; 104 } 188 } 105 return fpModelManager->GetActiveModels(glo << 106 } << 107 189 108 bool G4ITModelHandler::GetTimeStepComputerFlag << 190 if(type1 > (int) fModelManager.capacity()) 109 { << 191 { 110 return fTimeStepComputerFlag; << 192 fModelManager.reserve(type1); 111 } << 193 } 112 194 113 bool G4ITModelHandler::GetReactionProcessFlag( << 195 if(type2 > (int) fModelManager[type1].capacity()) 114 { << 196 { 115 return fReactionProcessFlag; << 197 fModelManager[type1].reserve(type2); 116 } << 198 } 117 199 118 void G4ITModelHandler::Reset() << 200 fModelManager[type1][type2] -> SetModel(aModel, startingTime); 119 { << 120 fpModelManager.reset(); << 121 } 201 } 122 202 123 void G4ITModelHandler::Finalize() << 203 >> 204 G4VITModel* G4ITModelHandler::GetModel(G4ITType type1, >> 205 G4ITType type2, >> 206 const G4double globalTime) 124 { 207 { 125 fFinalize = true; << 208 if(fModelManager.empty()) 126 } << 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 } 225