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 10.1.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 // $Id: G4ITModelHandler.cc 85244 2014-10-27 08:24:13Z 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 {
 45     fIsInitialized = false;                    <<  41   //ctor
 46     fTimeStepComputerFlag = false;             <<  42   fIsInitialized = false;
 47     fReactionProcessFlag = false;              <<  43   fTimeStepComputerFlag = false;
 48 }                                              <<  44   fReactionProcessFlag = false;
 49                                                    45 
 50 G4ITModelHandler::~G4ITModelHandler() = defaul <<  46   size_t IT_size(G4ITType::size());
 51                                                    47 
 52 void G4ITModelHandler::Initialize()            <<  48   fModelManager.assign(IT_size, std::vector<G4ITModelManager*>());
 53 {                                              <<  49   for (G4int i = 0; i < (int) IT_size; i++)
 54     fpModelManager->Initialize();              <<  50   {
 55     fIsInitialized = true;                     <<  51     fModelManager[i].assign(IT_size, 0);
                                                   >>  52   }
 56 }                                                  53 }
 57                                                    54 
 58 void G4ITModelHandler::RegisterModel(G4VITStep <<  55 G4ITModelHandler::~G4ITModelHandler()
 59                                      G4double  << 
 60 {                                                  56 {
 61     if(fFinalize)                              <<  57   //dtor
 62     {                                          <<  58   G4int size = fModelManager.size();
 63       return;                                  << 
 64     }                                          << 
 65     assert(pModel != nullptr);                 << 
 66                                                    59 
 67     G4ITType type1;                            <<  60   for (G4int i = 0; i < size; i++)
 68     G4ITType type2;                            <<  61   {
 69                                                <<  62     for (G4int j = 0; j <= i; j++)
 70     pModel->GetApplicable(type1, type2);       << 
 71                                                << 
 72     if (type1 != type2)                        << 
 73     {                                              63     {
 74         G4Exception("G4ITModelHandler::Registe <<  64       if (fModelManager[i][j])
 75                     "FeatureDisabled",         <<  65       {
 76                     FatalException,            <<  66         delete fModelManager[i][j];
 77                     "Models for different type <<  67         fModelManager[i][j] = 0;
 78     }                                          <<  68         fModelManager[j][i] = 0;
 79                                                <<  69       }
 80     if(!fpModelManager)                        << 
 81     {                                          << 
 82         fpModelManager = std::make_unique<G4IT << 
 83     }                                          << 
 84                                                << 
 85     fpModelManager->SetModel(pModel, startingT << 
 86                                                << 
 87     //________________________________________ << 
 88     // Setup ITStepManager                     << 
 89     if (pModel->GetTimeStepper() != nullptr)   << 
 90     {                                          << 
 91         fTimeStepComputerFlag = true;          << 
 92     }                                          << 
 93     if (pModel->GetReactionProcess() != nullpt << 
 94     {                                          << 
 95         fReactionProcessFlag = true;           << 
 96     }                                              70     }
                                                   >>  71   }
                                                   >>  72   fModelManager.clear();
 97 }                                                  73 }
 98                                                    74 
 99 std::vector<G4VITStepModel*> G4ITModelHandler: <<  75 G4ITModelHandler::G4ITModelHandler(const G4ITModelHandler& other)
100 {                                                  76 {
101     if(!fpModelManager)                        <<  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++)
102     {                                              85     {
103         return {};                             <<  86       if (other.fModelManager[i][j] != 0)
                                                   >>  87       {
                                                   >>  88         fModelManager[i][j] = new G4ITModelManager(
                                                   >>  89             *(other.fModelManager[i][j]));
                                                   >>  90       }
104     }                                              91     }
105     return fpModelManager->GetActiveModels(glo <<  92   }
106 }                                              << 
107                                                    93 
108 bool G4ITModelHandler::GetTimeStepComputerFlag <<  94   fIsInitialized = other.fIsInitialized;
109 {                                              <<  95   fTimeStepComputerFlag = other.fTimeStepComputerFlag;
110     return fTimeStepComputerFlag;              <<  96   fReactionProcessFlag = other.fReactionProcessFlag;
111 }                                                  97 }
112                                                    98 
113 bool G4ITModelHandler::GetReactionProcessFlag( <<  99 G4ITModelHandler& G4ITModelHandler::operator=(const G4ITModelHandler& rhs)
114 {                                                 100 {
115     return fReactionProcessFlag;               << 101   if (this == &rhs) return *this; // handle self assignment
                                                   >> 102   //assignment operator
                                                   >> 103   return *this;
116 }                                                 104 }
117                                                   105 
118 void G4ITModelHandler::Reset()                 << 106 void G4ITModelHandler::Initialize()
119 {                                                 107 {
120     fpModelManager.reset();                    << 108   fIsInitialized = true;
                                                   >> 109 
                                                   >> 110   for (G4int i = 0; i < int(fModelManager.size()); i++)
                                                   >> 111   {
                                                   >> 112     for (G4int j = 0; j <= i; j++)
                                                   >> 113     {
                                                   >> 114       G4ITModelManager* modman = fModelManager[i][j];
                                                   >> 115       if (modman)
                                                   >> 116       {
                                                   >> 117         modman->Initialize();
                                                   >> 118       }
                                                   >> 119     }
                                                   >> 120   }
121 }                                                 121 }
122                                                   122 
123 void G4ITModelHandler::Finalize()              << 123 void G4ITModelHandler::RegisterModel(G4VITStepModel* aModel,
                                                   >> 124                                      G4double startingTime)
124 {                                                 125 {
125   fFinalize = true;                            << 126   assert(aModel != 0);
126 }                                              << 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 }
                                                   >> 174 
                                                   >> 175 void G4ITModelHandler::SetModel(G4ITType type1,
                                                   >> 176                                 G4ITType type2,
                                                   >> 177                                 G4VITStepModel* aModel,
                                                   >> 178                                 G4double startingTime)
                                                   >> 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 }
                                                   >> 202 
                                                   >> 203 G4VITStepModel* G4ITModelHandler::GetModel(G4ITType type1,
                                                   >> 204                                            G4ITType type2,
                                                   >> 205                                            const G4double globalTime)
                                                   >> 206 {
                                                   >> 207   if (fModelManager.empty())
                                                   >> 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