Geant4 Cross Reference

Cross-Referencing   Geant4
Geant4/processes/electromagnetic/dna/management/src/G4ITModelHandler.cc

Version: [ ReleaseNotes ] [ 1.0 ] [ 1.1 ] [ 2.0 ] [ 3.0 ] [ 3.1 ] [ 3.2 ] [ 4.0 ] [ 4.0.p1 ] [ 4.0.p2 ] [ 4.1 ] [ 4.1.p1 ] [ 5.0 ] [ 5.0.p1 ] [ 5.1 ] [ 5.1.p1 ] [ 5.2 ] [ 5.2.p1 ] [ 5.2.p2 ] [ 6.0 ] [ 6.0.p1 ] [ 6.1 ] [ 6.2 ] [ 6.2.p1 ] [ 6.2.p2 ] [ 7.0 ] [ 7.0.p1 ] [ 7.1 ] [ 7.1.p1 ] [ 8.0 ] [ 8.0.p1 ] [ 8.1 ] [ 8.1.p1 ] [ 8.1.p2 ] [ 8.2 ] [ 8.2.p1 ] [ 8.3 ] [ 8.3.p1 ] [ 8.3.p2 ] [ 9.0 ] [ 9.0.p1 ] [ 9.0.p2 ] [ 9.1 ] [ 9.1.p1 ] [ 9.1.p2 ] [ 9.1.p3 ] [ 9.2 ] [ 9.2.p1 ] [ 9.2.p2 ] [ 9.2.p3 ] [ 9.2.p4 ] [ 9.3 ] [ 9.3.p1 ] [ 9.3.p2 ] [ 9.4 ] [ 9.4.p1 ] [ 9.4.p2 ] [ 9.4.p3 ] [ 9.4.p4 ] [ 9.5 ] [ 9.5.p1 ] [ 9.5.p2 ] [ 9.6 ] [ 9.6.p1 ] [ 9.6.p2 ] [ 9.6.p3 ] [ 9.6.p4 ] [ 10.0 ] [ 10.0.p1 ] [ 10.0.p2 ] [ 10.0.p3 ] [ 10.0.p4 ] [ 10.1 ] [ 10.1.p1 ] [ 10.1.p2 ] [ 10.1.p3 ] [ 10.2 ] [ 10.2.p1 ] [ 10.2.p2 ] [ 10.2.p3 ] [ 10.3 ] [ 10.3.p1 ] [ 10.3.p2 ] [ 10.3.p3 ] [ 10.4 ] [ 10.4.p1 ] [ 10.4.p2 ] [ 10.4.p3 ] [ 10.5 ] [ 10.5.p1 ] [ 10.6 ] [ 10.6.p1 ] [ 10.6.p2 ] [ 10.6.p3 ] [ 10.7 ] [ 10.7.p1 ] [ 10.7.p2 ] [ 10.7.p3 ] [ 10.7.p4 ] [ 11.0 ] [ 11.0.p1 ] [ 11.0.p2 ] [ 11.0.p3, ] [ 11.0.p4 ] [ 11.1 ] [ 11.1.1 ] [ 11.1.2 ] [ 11.1.3 ] [ 11.2 ] [ 11.2.1 ] [ 11.2.2 ] [ 11.3.0 ]

Diff markup

Differences between /processes/electromagnetic/dna/management/src/G4ITModelHandler.cc (Version 11.3.0) and /processes/electromagnetic/dna/management/src/G4ITModelHandler.cc (Version 9.5.p2)


  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 //                                                 26 //
 27 // Author: Mathieu Karamitros (kara (AT) cenbg     27 // Author: Mathieu Karamitros (kara (AT) cenbg . in2p3 . fr) 
 28 //                                                 28 //
 29 // History:                                        29 // History:
 30 // -----------                                     30 // -----------
 31 // 10 Oct 2011 M.Karamitros created                31 // 10 Oct 2011 M.Karamitros created
 32 //                                                 32 //
 33 // -------------------------------------------     33 // -------------------------------------------------------------------
 34                                                    34 
 35 #include "G4ITModelHandler.hh"                     35 #include "G4ITModelHandler.hh"
 36                                                <<  36 #include <assert.h>
 37 #include "G4ITModelManager.hh"                 << 
 38 #include "G4VITStepModel.hh"                   << 
 39                                                << 
 40 #include <cassert>                             << 
 41 #include <memory>                              << 
 42                                                    37 
 43 G4ITModelHandler::G4ITModelHandler()               38 G4ITModelHandler::G4ITModelHandler()
 44 {                                                  39 {
                                                   >>  40     //ctor
 45     fIsInitialized = false;                        41     fIsInitialized = false;
 46     fTimeStepComputerFlag = false;                 42     fTimeStepComputerFlag = false;
 47     fReactionProcessFlag = false;                  43     fReactionProcessFlag = false;
                                                   >>  44 
                                                   >>  45     size_t IT_size (G4ITType::size());
                                                   >>  46 
                                                   >>  47     fModelManager.assign(IT_size, std::vector<G4ITModelManager*>());
                                                   >>  48     for(G4int i = 0 ; i < (int) IT_size ; i++)
                                                   >>  49     {
                                                   >>  50         fModelManager[i].assign(IT_size,0);
                                                   >>  51     }
 48 }                                                  52 }
 49                                                    53 
 50 G4ITModelHandler::~G4ITModelHandler() = defaul <<  54 G4ITModelHandler::~G4ITModelHandler()
                                                   >>  55 {
                                                   >>  56     //dtor
                                                   >>  57     G4int size = fModelManager.size();
                                                   >>  58 
                                                   >>  59     for(G4int i = 0 ; i < size ; i++)
                                                   >>  60     {
                                                   >>  61         for(G4int j = 0 ; j <= i ; j++)
                                                   >>  62         {
                                                   >>  63             if(fModelManager[i][j])
                                                   >>  64             {
                                                   >>  65                 delete fModelManager[i][j];
                                                   >>  66                 fModelManager[i][j] = 0;
                                                   >>  67                 fModelManager[j][i] = 0;
                                                   >>  68             }
                                                   >>  69         }
                                                   >>  70     }
                                                   >>  71     fModelManager.clear();
                                                   >>  72 }
                                                   >>  73 
                                                   >>  74 G4ITModelHandler::G4ITModelHandler(const G4ITModelHandler& other)
                                                   >>  75 {
                                                   >>  76     //copy ctor
                                                   >>  77     size_t IT_size (G4ITType::size());
                                                   >>  78 
                                                   >>  79     fModelManager.assign(IT_size, std::vector<G4ITModelManager*>());
                                                   >>  80     for(int i = 0 ; i < (int) IT_size ; i++)
                                                   >>  81     {
                                                   >>  82         fModelManager[i].assign(IT_size,0);
                                                   >>  83         for(int j = 0 ; j < (int) IT_size ; j++)
                                                   >>  84         {
                                                   >>  85             if(other.fModelManager[i][j] != 0)
                                                   >>  86             {
                                                   >>  87                 fModelManager[i][j] = new G4ITModelManager(*(other.fModelManager[i][j])) ;
                                                   >>  88             }
                                                   >>  89         }
                                                   >>  90     }
                                                   >>  91 
                                                   >>  92     fIsInitialized = other.fIsInitialized;
                                                   >>  93     fTimeStepComputerFlag = other.fTimeStepComputerFlag;
                                                   >>  94     fReactionProcessFlag = other.fReactionProcessFlag;
                                                   >>  95 }
                                                   >>  96 
                                                   >>  97 G4ITModelHandler& G4ITModelHandler::operator=(const G4ITModelHandler& rhs)
                                                   >>  98 {
                                                   >>  99     if (this == &rhs) return *this; // handle self assignment
                                                   >> 100     //assignment operator
                                                   >> 101     return *this;
                                                   >> 102 }
 51                                                   103 
 52 void G4ITModelHandler::Initialize()               104 void G4ITModelHandler::Initialize()
 53 {                                                 105 {
 54     fpModelManager->Initialize();              << 
 55     fIsInitialized = true;                        106     fIsInitialized = true;
                                                   >> 107 
                                                   >> 108     for(G4int i = 0 ; i < int(fModelManager.size()) ; i++)
                                                   >> 109     {
                                                   >> 110         for(G4int j = 0 ; j <= i ; j++)
                                                   >> 111         {
                                                   >> 112             G4ITModelManager* modman = fModelManager[i][j];
                                                   >> 113             if(modman)
                                                   >> 114             {
                                                   >> 115                 modman->Initialize();
                                                   >> 116             }
                                                   >> 117         }
                                                   >> 118     }
 56 }                                                 119 }
 57                                                   120 
 58 void G4ITModelHandler::RegisterModel(G4VITStep << 121 void G4ITModelHandler::RegisterModel(
 59                                      G4double  << 122     G4VITModel* aModel,
                                                   >> 123     G4double startingTime)
 60 {                                                 124 {
 61     if(fFinalize)                              << 125     assert(aModel != 0);
                                                   >> 126 
                                                   >> 127     //________________________________________________
                                                   >> 128     // Prepare the correct model manager
                                                   >> 129     if( fModelManager.empty() )
 62     {                                             130     {
 63       return;                                  << 131         size_t IT_size (G4ITType::size());
                                                   >> 132         fModelManager.assign(IT_size, std::vector<G4ITModelManager*>());
                                                   >> 133 
                                                   >> 134         for(int i = 0 ; i < (int) IT_size ; i++)
                                                   >> 135         {
                                                   >> 136             fModelManager[i].assign((size_t) i,0);
                                                   >> 137         }
 64     }                                             138     }
 65     assert(pModel != nullptr);                 << 
 66                                                   139 
 67     G4ITType type1;                               140     G4ITType type1;
 68     G4ITType type2;                               141     G4ITType type2;
 69                                                   142 
 70     pModel->GetApplicable(type1, type2);       << 143     //________________________________________________
                                                   >> 144     // Retrieve applicability
                                                   >> 145     aModel->IsApplicable(type1, type2);
 71                                                   146 
 72     if (type1 != type2)                        << 147     if(type1 > type2)
 73     {                                             148     {
 74         G4Exception("G4ITModelHandler::Registe << 149         G4ITType buffer(-1);
 75                     "FeatureDisabled",         << 150         buffer = type1;
 76                     FatalException,            << 151         type1 = type2;
 77                     "Models for different type << 152         type2 = buffer;
 78     }                                             153     }
 79                                                   154 
 80     if(!fpModelManager)                        << 155     if(fModelManager[type1][type2] == 0)
 81     {                                             156     {
 82         fpModelManager = std::make_unique<G4IT << 157         fModelManager[type1][type2] = new G4ITModelManager();
 83     }                                             158     }
 84                                                   159 
 85     fpModelManager->SetModel(pModel, startingT << 160     fModelManager[type1][type2]-> SetModel(aModel, startingTime);
 86                                                   161 
 87     //________________________________________    162     //________________________________________________
 88     // Setup ITStepManager                        163     // Setup ITStepManager
 89     if (pModel->GetTimeStepper() != nullptr)   << 164     if(aModel->GetTimeStepper())
 90     {                                             165     {
 91         fTimeStepComputerFlag = true;             166         fTimeStepComputerFlag = true;
 92     }                                             167     }
 93     if (pModel->GetReactionProcess() != nullpt << 168     if(aModel->GetReactionProcess())
 94     {                                             169     {
 95         fReactionProcessFlag = true;              170         fReactionProcessFlag = true;
 96     }                                             171     }
 97 }                                                 172 }
 98                                                   173 
 99 std::vector<G4VITStepModel*> G4ITModelHandler: << 174 void G4ITModelHandler::SetModel(G4ITType type1,
                                                   >> 175                               G4ITType type2,
                                                   >> 176                               G4VITModel* aModel,
                                                   >> 177                               G4double startingTime)
100 {                                                 178 {
101     if(!fpModelManager)                        << 179     assert(aModel == 0);
                                                   >> 180 
                                                   >> 181     if(type1 > type2)
102     {                                             182     {
103         return {};                             << 183         G4ITType buffer(-1);
                                                   >> 184         buffer = type1;
                                                   >> 185         type1 = type2;
                                                   >> 186         type2 = buffer;
104     }                                             187     }
105     return fpModelManager->GetActiveModels(glo << 
106 }                                              << 
107                                                   188 
108 bool G4ITModelHandler::GetTimeStepComputerFlag << 189     if(type1 > (int) fModelManager.capacity())
109 {                                              << 190     {
110     return fTimeStepComputerFlag;              << 191         fModelManager.reserve(type1);
111 }                                              << 192     }
112                                                   193 
113 bool G4ITModelHandler::GetReactionProcessFlag( << 194     if(type2 > (int) fModelManager[type1].capacity())
114 {                                              << 195     {
115     return fReactionProcessFlag;               << 196         fModelManager[type1].reserve(type2);
116 }                                              << 197     }
117                                                   198 
118 void G4ITModelHandler::Reset()                 << 199     fModelManager[type1][type2] -> SetModel(aModel, startingTime);
119 {                                              << 
120     fpModelManager.reset();                    << 
121 }                                                 200 }
122                                                   201 
123 void G4ITModelHandler::Finalize()              << 202 
                                                   >> 203 G4VITModel* G4ITModelHandler::GetModel(G4ITType type1,
                                                   >> 204                                      G4ITType type2,
                                                   >> 205                                      const G4double globalTime)
124 {                                                 206 {
125   fFinalize = true;                            << 207     if(fModelManager.empty())
126 }                                              << 208     {
                                                   >> 209         return 0;
                                                   >> 210     }
                                                   >> 211 
                                                   >> 212     if((int) fModelManager.size() < type1) return 0;
                                                   >> 213 
                                                   >> 214     std::vector<G4ITModelManager*>* v = &(fModelManager.at(type1));
                                                   >> 215 
                                                   >> 216     if((int) v->size() < type2) return 0;
                                                   >> 217 
                                                   >> 218     if(v->at(type2))
                                                   >> 219     {
                                                   >> 220         return v->at(type2)->GetModel(globalTime);
                                                   >> 221     }
                                                   >> 222     return 0;
                                                   >> 223 }
                                                      224