Ignore:
Timestamp:
Jun 18, 2010, 11:42:07 AM (14 years ago)
Author:
garnier
Message:

update geant4-09-04-beta-cand-01 interfaces-V09-03-09 vis-V09-03-08

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/source/processes/electromagnetic/utils/src/G4LossTableManager.cc

    r1228 r1315  
    2424// ********************************************************************
    2525//
    26 // $Id: G4LossTableManager.cc,v 1.97 2009/10/29 19:25:28 vnivanch Exp $
    27 // GEANT4 tag $Name: geant4-09-03 $
     26// $Id: G4LossTableManager.cc,v 1.101 2010/06/04 15:33:56 vnivanch Exp $
     27// GEANT4 tag $Name: geant4-09-04-beta-cand-01 $
    2828//
    2929// -------------------------------------------------------------------
    … …  
    7070// 12-02-07 Add SetSkin, SetLinearLossLimit (V.Ivanchenko)
    7171// 18-06-07 Move definition of msc parameters to G4EmProcessOptions (V.Ivanchenko)
    72 // 21-02-08 Add G4EmSaturation (V.Ivanchenko)
     72// 21-02-08 Added G4EmSaturation (V.Ivanchenko)
     73// 12-04-10 Added PreparePhsyicsTables and BuildPhysicsTables entries (V.Ivanchenko)
    7374//
    7475// Class Description:
    … …  
    9697#include "G4EmTableType.hh"
    9798#include "G4LossTableBuilder.hh"
     99#include "G4Region.hh"
    98100
    99101G4LossTableManager* G4LossTableManager::theInstance = 0;
    … …  
    114116G4LossTableManager::~G4LossTableManager()
    115117{
    116   for (G4int i=0; i<n_loss; i++) {
    117     if( loss_vector[i] ) delete loss_vector[i];
     118  for (G4int i=0; i<n_loss; ++i) {
     119    if( loss_vector[i] ) { delete loss_vector[i]; }
    118120  }
    119121  size_t msc = msc_vector.size();
    120   for (size_t j=0; j<msc; j++) {
    121     if( msc_vector[j] ) delete msc_vector[j];
     122  for (size_t j=0; j<msc; ++j) {
     123    if( msc_vector[j] ) { delete msc_vector[j]; }
    122124  }
    123125  size_t emp = emp_vector.size();
    124   for (size_t k=0; k<emp; k++) {
    125     if( emp_vector[k] ) delete emp_vector[k];
     126  for (size_t k=0; k<emp; ++k) {
     127    if( emp_vector[k] ) { delete emp_vector[k]; }
    126128  }
    127129  size_t mod = mod_vector.size();
    128   for (size_t a=0; a<mod; a++) {
    129     if( mod_vector[a] ) delete mod_vector[a];
     130  for (size_t a=0; a<mod; ++a) {
     131    if( mod_vector[a] ) { delete mod_vector[a]; }
    130132  }
    131133  size_t fmod = fmod_vector.size();
    132   for (size_t b=0; b<fmod; b++) {
    133     if( fmod_vector[b] ) delete fmod_vector[b];
     134  for (size_t b=0; b<fmod; ++b) {
     135    if( fmod_vector[b] ) { delete fmod_vector[b]; }
    134136  }
    135137  Clear();
    … …  
    146148  n_loss = 0;
    147149  run = 0;
    148   //  first_entry = true;
     150  startInitialisation = false;
    149151  all_tables_are_built = false;
    150   all_tables_are_stored = false;
    151152  currentLoss = 0;
    152153  currentParticle = 0;
     154  firstParticle = 0;
    153155  lossFluctuationFlag = true;
    154156  subCutoffFlag = false;
    … …  
    158160  maxFinalStep = 0.0;
    159161  minKinEnergy = 0.1*keV;
    160   maxKinEnergy = 100.0*TeV;
    161   maxKinEnergyForMuons = 100.*TeV;
    162   theMessenger = new G4EnergyLossMessenger();
    163   theElectron  = G4Electron::Electron();
    164   tableBuilder = new G4LossTableBuilder();
    165   emCorrections= new G4EmCorrections();
    166   emSaturation = new G4EmSaturation();
    167   emConfigurator = new G4EmConfigurator();
     162  maxKinEnergy = 10.0*TeV;
     163  nbinsLambda  = 77;
     164  nbinsPerDecade = 7;
     165  maxKinEnergyForMuons = 10.*TeV;
    168166  integral = true;
    169167  integralActive = false;
    … …  
    178176  factorForAngleLimit = 1.0;
    179177  verbose = 1;
     178  theMessenger = new G4EnergyLossMessenger();
     179  theElectron  = G4Electron::Electron();
     180  tableBuilder = new G4LossTableBuilder();
     181  emCorrections= new G4EmCorrections();
     182  emSaturation = new G4EmSaturation();
     183  emConfigurator = new G4EmConfigurator(verbose);
    180184  tableBuilder->SetSplineFlag(splineFlag);
    181185}
    … …  
    207211void G4LossTableManager::Register(G4VEnergyLossProcess* p)
    208212{
    209   n_loss++;
     213  ++n_loss;
    210214  loss_vector.push_back(p);
    211215  part_vector.push_back(0);
    … …  
    217221  isActive.push_back(true);
    218222  all_tables_are_built = false;
    219   if(!lossFluctuationFlag) p->SetLossFluctuations(false);
    220   if(subCutoffFlag)        p->ActivateSubCutoff(true);
    221   if(rndmStepFlag)         p->SetRandomStep(true);
    222   if(stepFunctionActive)   p->SetStepFunction(maxRangeVariation, maxFinalStep);
    223   if(integralActive)       p->SetIntegral(integral);
    224   if(minEnergyActive)      p->SetMinKinEnergy(minKinEnergy);
    225   if(maxEnergyActive)      p->SetMaxKinEnergy(maxKinEnergy);
     223  if(!lossFluctuationFlag) { p->SetLossFluctuations(false); }
     224  if(subCutoffFlag)        { p->ActivateSubCutoff(true); }
     225  if(rndmStepFlag)         { p->SetRandomStep(true); }
     226  if(stepFunctionActive)   { p->SetStepFunction(maxRangeVariation, maxFinalStep); }
     227  if(integralActive)       { p->SetIntegral(integral); }
     228  if(minEnergyActive)      { p->SetMinKinEnergy(minKinEnergy); }
     229  if(maxEnergyActive)      { p->SetMaxKinEnergy(maxKinEnergy); }
    226230  if(verbose > 1)
    227231    G4cout << "G4LossTableManager::Register G4VEnergyLossProcess : "
    … …  
    233237void G4LossTableManager::DeRegister(G4VEnergyLossProcess* p)
    234238{
    235   for (G4int i=0; i<n_loss; i++) {
    236     if(loss_vector[i] == p) loss_vector[i] = 0;
     239  for (G4int i=0; i<n_loss; ++i) {
     240    if(loss_vector[i] == p) { loss_vector[i] = 0; }
    237241  }
    238242}
    … …  
    254258{
    255259  size_t msc = msc_vector.size();
    256   for (size_t i=0; i<msc; i++) {
    257     if(msc_vector[i] == p) msc_vector[i] = 0;
     260  for (size_t i=0; i<msc; ++i) {
     261    if(msc_vector[i] == p) { msc_vector[i] = 0; }
    258262  }
    259263}
    … …  
    275279{
    276280  size_t emp = emp_vector.size();
    277   for (size_t i=0; i<emp; i++) {
    278     if(emp_vector[i] == p) emp_vector[i] = 0;
     281  for (size_t i=0; i<emp; ++i) {
     282    if(emp_vector[i] == p) { emp_vector[i] = 0; }
    279283  }
    280284}
    … …  
    296300{
    297301  size_t n = mod_vector.size();
    298   for (size_t i=0; i<n; i++) {
    299     if(mod_vector[i] == p) mod_vector[i] = 0;
     302  for (size_t i=0; i<n; ++i) {
     303    if(mod_vector[i] == p) { mod_vector[i] = 0; }
    300304  }
    301305}
    … …  
    317321{
    318322  size_t n = fmod_vector.size();
    319   for (size_t i=0; i<n; i++) {
    320     if(fmod_vector[i] == p) fmod_vector[i] = 0;
     323  for (size_t i=0; i<n; ++i) {
     324    if(fmod_vector[i] == p) { fmod_vector[i] = 0; }
    321325  }
    322326}
    … …  
    336340     G4VEnergyLossProcess* p)
    337341{
    338   n_loss++;
     342  ++n_loss;
    339343  loss_vector.push_back(p);
    340344  part_vector.push_back(part);
    … …  
    349353//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.....
    350354
    351 void G4LossTableManager::EnergyLossProcessIsInitialised(
    352                    const G4ParticleDefinition* particle,
    353                    G4VEnergyLossProcess* p)
    354 {
    355   if (run == 0 || (particle == firstParticle && all_tables_are_built) ) {
     355void
     356G4LossTableManager::PreparePhysicsTable(const G4ParticleDefinition* particle,
     357                                        G4VEnergyLossProcess* p)
     358{
     359  if (1 < verbose) {
     360    G4cout << "G4LossTableManager::PreparePhysicsTable for "
     361           << particle->GetParticleName()
     362           << " and " << p->GetProcessName() << " run= " << run << G4endl;
     363  }
     364  // start initialisation for the first run
     365  startInitialisation = true;
     366
     367  if( 0 == run ) {
     368    emConfigurator->PrepareModels(particle, p);
     369
     370    // initialise particles for given process
     371    for (G4int j=0; j<n_loss; ++j) {
     372      if (p == loss_vector[j]) {
     373        if (!part_vector[j]) { part_vector[j] = particle; }
     374      }
     375    }
     376  }
     377}
     378
     379//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.....
     380
     381void
     382G4LossTableManager::PreparePhysicsTable(const G4ParticleDefinition* particle,
     383                                        G4VEmProcess* p)
     384{
     385  if (1 < verbose) {
     386    G4cout << "G4LossTableManager::PreparePhysicsTable for "
     387           << particle->GetParticleName()
     388           << " and " << p->GetProcessName() << G4endl;
     389  }
     390  // start initialisation for the first run
     391  if( 0 == run ) {
     392    emConfigurator->PrepareModels(particle, p);
     393  }
     394  startInitialisation = true;
     395}
     396
     397//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.....
     398
     399void
     400G4LossTableManager::PreparePhysicsTable(const G4ParticleDefinition* particle,
     401                                        G4VMultipleScattering* p)
     402{
     403  if (1 < verbose) {
     404    G4cout << "G4LossTableManager::PreparePhysicsTable for "
     405           << particle->GetParticleName()
     406           << " and " << p->GetProcessName() << G4endl;
     407  }
     408  // start initialisation for the first run
     409  if( 0 == run ) {
     410    emConfigurator->PrepareModels(particle, p);
     411  }
     412}
     413
     414//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.....
     415
     416void
     417G4LossTableManager::BuildPhysicsTable(const G4ParticleDefinition*)
     418{
     419  if(0 == run && startInitialisation) {
     420    emConfigurator->Clear();
     421  }
     422}
     423
     424//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.....
     425
     426void G4LossTableManager::BuildPhysicsTable(
     427     const G4ParticleDefinition* aParticle,
     428     G4VEnergyLossProcess* p)
     429{
     430  if(1 < verbose) {
     431    G4cout << "### G4LossTableManager::BuildDEDXTable() is requested for "
     432           << aParticle->GetParticleName()
     433           << " and process " << p->GetProcessName()
     434           << G4endl;
     435  }
     436  // clear configurator
     437  if(0 == run && startInitialisation) {
     438    emConfigurator->Clear();
     439    firstParticle = aParticle;
     440  }
     441  startInitialisation = false;
     442
     443  // initialisation before any table is built
     444  if ( aParticle == firstParticle ) {
    356445    all_tables_are_built = true;
    357446
    358     if(1 < verbose)
    359       G4cout << "### G4LossTableManager start initilisation of tables"
     447    if(1 < verbose) {
     448      G4cout << "### G4LossTableManager start initilisation for first particle "
     449             << firstParticle->GetParticleName()
    360450             << G4endl;
    361     for (G4int i=0; i<n_loss; i++) {
     451    }
     452    for (G4int i=0; i<n_loss; ++i) {
    362453      G4VEnergyLossProcess* el = loss_vector[i];
    363454
    … …  
    365456        const G4ProcessManager* pm = el->GetProcessManager();
    366457        isActive[i] = pm->GetProcessActivation(el);
     458        if(0 == run) { base_part_vector[i] = el->BaseParticle(); }
    367459        tables_are_built[i] = false;
    368         all_tables_are_built = false;
    369         if(!isActive[i]) el->SetIonisation(false);
     460        all_tables_are_built= false;
     461        if(!isActive[i]) { el->SetIonisation(false); }
    370462 
    371463        if(1 < verbose) {
    … …  
    374466                 << "  active= " << pm->GetProcessActivation(el)
    375467                 << "  table= " << tables_are_built[i]
    376                  << "  isIonisation= " << el->IsIonisationProcess()
    377                  << G4endl;
     468                 << "  isIonisation= " << el->IsIonisationProcess();
     469          if(base_part_vector[i]) {
     470            G4cout << "  base particle " << base_part_vector[i]->GetParticleName();
     471          }
     472          G4cout << G4endl;
    378473        }
    379474      } else {
    … …  
    382477      }
    383478    }
    384     if (0 == run) firstParticle = particle;
    385     run++;
    386   }
    387 
    388   currentParticle = 0;
    389 
    390   SetParameters(p);
    391   for (G4int j=0; j<n_loss; j++) {
    392     if (p == loss_vector[j]) {
    393 
    394       if (!part_vector[j]) {
    395         part_vector[j] = particle;
    396         base_part_vector[j] = p->BaseParticle();
     479    ++run;
     480    currentParticle = 0;
     481  }
     482
     483  // Set run time parameters
     484  SetParameters(aParticle, p);
     485
     486  if (all_tables_are_built) { return; }
     487
     488  // Build tables for given particle
     489  all_tables_are_built = true;
     490
     491  for(G4int i=0; i<n_loss; ++i) {
     492    if(p == loss_vector[i] && !tables_are_built[i] && !base_part_vector[i]) {
     493      const G4ParticleDefinition* curr_part = part_vector[i];
     494      if(1 < verbose) {
     495        G4cout << "### BuildPhysicsTable for " << p->GetProcessName()
     496               << " and " << curr_part->GetParticleName()
     497               << " start BuildTable " << G4endl;
    397498      }
    398       if(maxEnergyForMuonsActive) {
    399         G4double dm = std::abs(particle->GetPDGMass() - 105.7*MeV);
    400         if(dm < 5.*MeV) p->SetMaxKinEnergy(maxKinEnergyForMuons);
    401       }
    402 
    403       if(1 < verbose) {
    404         G4cout << "For " << p->GetProcessName()
    405                << " for " << part_vector[j]->GetParticleName()
    406                << " tables_are_built= " << tables_are_built[j]
    407                << " procFlag= " << loss_vector[j]->TablesAreBuilt()
    408                << " all_tables_are_built= "     << all_tables_are_built
    409                << G4endl;
    410       }
    411     }
    412   }
    413 }
    414 
    415 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.....
    416 
    417 G4EnergyLossMessenger* G4LossTableManager::GetMessenger()
    418 {
    419   return theMessenger;
    420 }
    421 
    422 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.....
    423 
    424 void G4LossTableManager::ParticleHaveNoLoss(
    425      const G4ParticleDefinition* aParticle)
    426 {
    427   G4String s = " dE/dx table not found for "
    428              + aParticle->GetParticleName() + " !";
    429   G4Exception("G4LossTableManager::ParticleHaveNoLoss", "EM01",
    430               FatalException, s);
    431 
    432 }
    433 
    434 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.....
    435 
    436 G4bool G4LossTableManager::BuildCSDARange() const
    437 {
    438   return buildCSDARange;
    439 }
    440 
    441 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.....
    442 
    443 void G4LossTableManager::BuildPhysicsTable(
    444      const G4ParticleDefinition* aParticle,
    445      G4VEnergyLossProcess* p)
    446 {
    447   if(1 < verbose) {
    448     G4cout << "### G4LossTableManager::BuildDEDXTable() is requested for "
    449            << aParticle->GetParticleName()
    450            << " and process " << p->GetProcessName()
    451            << G4endl;
    452   }
    453   if (all_tables_are_built) return;
    454   all_tables_are_built = true;
    455 
    456   for(G4int i=0; i<n_loss; i++) {
    457     if(!tables_are_built[i] && !base_part_vector[i]) {
    458       const G4ParticleDefinition* curr_part = part_vector[i];
    459499      G4VEnergyLossProcess* curr_proc = BuildTables(curr_part);
    460       if(curr_proc) CopyTables(curr_part, curr_proc);
    461     }
    462   }
    463 
    464   for (G4int ii=0; ii<n_loss; ii++) {
    465     if ( !tables_are_built[ii] ) {
    466       all_tables_are_built = false;
    467       break;
    468     }
     500      if(curr_proc) { CopyTables(curr_part, curr_proc); }
     501    }
     502    if ( !tables_are_built[i] ) { all_tables_are_built = false; }
    469503  }
    470504
    … …  
    473507           << "all_tables_are_built= " << all_tables_are_built
    474508           << G4endl;
    475 
    476     if(all_tables_are_built)
     509   
     510    if(all_tables_are_built) {
    477511      G4cout << "### All dEdx and Range tables are built #####" << G4endl;
     512    }
    478513  }
    479514}
    … …  
    484519                                          G4VEnergyLossProcess* base_proc)
    485520{
    486   for (G4int j=0; j<n_loss; j++) {
     521  for (G4int j=0; j<n_loss; ++j) {
    487522
    488523    G4VEnergyLossProcess* proc = loss_vector[j];
    489     if(proc == base_proc || proc->Particle() == part)
    490       tables_are_built[j] = true;
     524    //if(proc == base_proc || proc->Particle() == part)
     525    //  tables_are_built[j] = true;
    491526
    492527    if (!tables_are_built[j] && part == base_part_vector[j]) {
    … …  
    511546    }
    512547
    513     if (theElectron == part && theElectron == proc->SecondaryParticle() )
     548    if (theElectron == part && theElectron == proc->SecondaryParticle() ) {
    514549      proc->SetSecondaryRangeTable(base_proc->RangeTableForLoss());
     550    }
    515551  }
    516552}
    … …  
    535571  G4int i;
    536572
    537   for (i=0; i<n_loss; i++) {
     573  for (i=0; i<n_loss; ++i) {
    538574    p = loss_vector[i];
    539575    if (p && aParticle == part_vector[i] && !tables_are_built[i]) {
    … …  
    602638  std::vector<G4PhysicsTable*> listCSDA;
    603639
    604   for (i=0; i<n_dedx; i++) {
     640  for (i=0; i<n_dedx; ++i) {
    605641    p = loss_list[i];
    606642    p->SetIonisation(false);
    … …  
    658694//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.....
    659695
     696G4EnergyLossMessenger* G4LossTableManager::GetMessenger()
     697{
     698  return theMessenger;
     699}
     700
     701//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.....
     702
     703void G4LossTableManager::ParticleHaveNoLoss(
     704     const G4ParticleDefinition* aParticle)
     705{
     706  G4String s = " dE/dx table not found for "
     707             + aParticle->GetParticleName() + " !";
     708  G4Exception("G4LossTableManager::ParticleHaveNoLoss", "EM01",
     709              FatalException, s);
     710
     711}
     712
     713//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.....
     714
     715G4bool G4LossTableManager::BuildCSDARange() const
     716{
     717  return buildCSDARange;
     718}
     719
     720//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.....
     721
    660722void G4LossTableManager::SetLossFluctuations(G4bool val)
    661723{
    662724  lossFluctuationFlag = val;
    663   for(G4int i=0; i<n_loss; i++) {
    664     if(loss_vector[i]) loss_vector[i]->SetLossFluctuations(val);
    665   }
    666 }
    667 
    668 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.....
    669 
    670 void G4LossTableManager::SetSubCutoff(G4bool val)
     725  for(G4int i=0; i<n_loss; ++i) {
     726    if(loss_vector[i]) { loss_vector[i]->SetLossFluctuations(val); }
     727  }
     728}
     729
     730//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.....
     731
     732void G4LossTableManager::SetSubCutoff(G4bool val, const G4Region* r)
    671733{
    672734  subCutoffFlag = val;
    673   for(G4int i=0; i<n_loss; i++) {
    674     if(loss_vector[i]) loss_vector[i]->ActivateSubCutoff(val);
     735  for(G4int i=0; i<n_loss; ++i) {
     736    if(loss_vector[i]) { loss_vector[i]->ActivateSubCutoff(val, r); }
    675737  }
    676738}
    … …  
    682744  integral = val;
    683745  integralActive = true;
    684   for(G4int i=0; i<n_loss; i++) {
    685     if(loss_vector[i]) loss_vector[i]->SetIntegral(val);
     746  for(G4int i=0; i<n_loss; ++i) {
     747    if(loss_vector[i]) { loss_vector[i]->SetIntegral(val); }
    686748  }
    687749  size_t emp = emp_vector.size();
    688   for (size_t k=0; k<emp; k++) {
    689     if(emp_vector[k]) emp_vector[k]->SetIntegral(val);
     750  for (size_t k=0; k<emp; ++k) {
     751    if(emp_vector[k]) { emp_vector[k]->SetIntegral(val); }
    690752  }
    691753}
    … …  
    696758{
    697759  minSubRange = val;
    698   for(G4int i=0; i<n_loss; i++) {
    699     if(loss_vector[i]) loss_vector[i]->SetMinSubRange(val);
     760  for(G4int i=0; i<n_loss; ++i) {
     761    if(loss_vector[i]) { loss_vector[i]->SetMinSubRange(val); }
    700762  }
    701763}
    … …  
    706768{
    707769  rndmStepFlag = val;
    708   for(G4int i=0; i<n_loss; i++) {
    709     if(loss_vector[i]) loss_vector[i]->SetRandomStep(val);
     770  for(G4int i=0; i<n_loss; ++i) {
     771    if(loss_vector[i]) { loss_vector[i]->SetRandomStep(val); }
    710772  }
    711773}
    … …  
    717779  minEnergyActive = true;
    718780  minKinEnergy = val;
    719   for(G4int i=0; i<n_loss; i++) {
    720     if(loss_vector[i]) loss_vector[i]->SetMinKinEnergy(val);
     781  for(G4int i=0; i<n_loss; ++i) {
     782    if(loss_vector[i]) { loss_vector[i]->SetMinKinEnergy(val); }
    721783  }
    722784  size_t msc = msc_vector.size();
    723   for (size_t j=0; j<msc; j++) {
    724     if(msc_vector[j]) msc_vector[j]->SetMinKinEnergy(val);
     785  for (size_t j=0; j<msc; ++j) {
     786    if(msc_vector[j]) { msc_vector[j]->SetMinKinEnergy(val); }
    725787  }
    726788  size_t emp = emp_vector.size();
    727   for (size_t k=0; k<emp; k++) {
    728     if(emp_vector[k]) emp_vector[k]->SetMinKinEnergy(val);
     789  for (size_t k=0; k<emp; ++k) {
     790    if(emp_vector[k]) { emp_vector[k]->SetMinKinEnergy(val); }
    729791  }
    730792}
    … …  
    736798  maxEnergyActive = true;
    737799  maxKinEnergy = val;
    738   for(G4int i=0; i<n_loss; i++) {
    739     if(loss_vector[i]) loss_vector[i]->SetMaxKinEnergy(val);
     800  for(G4int i=0; i<n_loss; ++i) {
     801    if(loss_vector[i]) { loss_vector[i]->SetMaxKinEnergy(val); }
    740802  }
    741803  size_t msc = msc_vector.size();
    742   for (size_t j=0; j<msc; j++) {
    743     if(msc_vector[j]) msc_vector[j]->SetMaxKinEnergy(val);
     804  for (size_t j=0; j<msc; ++j) {
     805    if(msc_vector[j]) { msc_vector[j]->SetMaxKinEnergy(val); }
    744806  }
    745807  size_t emp = emp_vector.size();
    746   for (size_t k=0; k<emp; k++) {
    747     if(emp_vector[k]) emp_vector[k]->SetMaxKinEnergy(val);
     808  for (size_t k=0; k<emp; ++k) {
     809    if(emp_vector[k]) { emp_vector[k]->SetMaxKinEnergy(val); }
    748810  }
    749811}
    … …  
    753815void G4LossTableManager::SetMaxEnergyForCSDARange(G4double val)
    754816{
    755   for(G4int i=0; i<n_loss; i++) {
    756     if(loss_vector[i]) loss_vector[i]->SetMaxKinEnergyForCSDARange(val);
     817  for(G4int i=0; i<n_loss; ++i) {
     818    if(loss_vector[i]) { loss_vector[i]->SetMaxKinEnergyForCSDARange(val); }
    757819  }
    758820}
    … …  
    770832void G4LossTableManager::SetDEDXBinning(G4int val)
    771833{
    772   for(G4int i=0; i<n_loss; i++) {
    773     if(loss_vector[i]) loss_vector[i]->SetDEDXBinning(val);
     834  for(G4int i=0; i<n_loss; ++i) {
     835    if(loss_vector[i]) { loss_vector[i]->SetDEDXBinning(val); }
    774836  }
    775837}
    … …  
    779841void G4LossTableManager::SetDEDXBinningForCSDARange(G4int val)
    780842{
    781   for(G4int i=0; i<n_loss; i++) {
    782     if(loss_vector[i]) loss_vector[i]->SetDEDXBinningForCSDARange(val);
     843  for(G4int i=0; i<n_loss; ++i) {
     844    if(loss_vector[i]) { loss_vector[i]->SetDEDXBinningForCSDARange(val); }
    783845  }
    784846}
    … …  
    788850void G4LossTableManager::SetLambdaBinning(G4int val)
    789851{
     852  G4int n = val/G4int(std::log10(maxKinEnergy/minKinEnergy));
     853  if(n < 5) {
     854    G4cout << "G4LossTableManager::SetLambdaBinning WARNING "
     855           << "too small number of bins " << val << "  ignored"
     856           << G4endl;
     857    return;
     858  }
     859  nbinsLambda = val;
     860  nbinsPerDecade = n;
    790861  size_t msc = msc_vector.size();
    791   for (size_t j=0; j<msc; j++) {
    792     if(msc_vector[j]) msc_vector[j]->SetBinning(val);
     862  for (size_t j=0; j<msc; ++j) {
     863    if(msc_vector[j]) { msc_vector[j]->SetBinning(val); }
    793864  }
    794865  size_t emp = emp_vector.size();
    795   for (size_t k=0; k<emp; k++) {
    796     if(emp_vector[k]) emp_vector[k]->SetLambdaBinning(val);
    797   }
     866  for (size_t k=0; k<emp; ++k) {
     867    if(emp_vector[k]) { emp_vector[k]->SetLambdaBinning(val); }
     868  }
     869}
     870
     871//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.....
     872
     873G4int G4LossTableManager::GetNumberOfBinsPerDecade() const
     874{
     875  return nbinsPerDecade;
    798876}
    799877
    … …  
    803881{
    804882  verbose = val;
    805   for(G4int i=0; i<n_loss; i++) {
    806     if(loss_vector[i]) loss_vector[i]->SetVerboseLevel(val);
     883  for(G4int i=0; i<n_loss; ++i) {
     884    if(loss_vector[i]) { loss_vector[i]->SetVerboseLevel(val); }
    807885  }
    808886  size_t msc = msc_vector.size();
    809   for (size_t j=0; j<msc; j++) {
    810     if(msc_vector[j]) msc_vector[j]->SetVerboseLevel(val);
     887  for (size_t j=0; j<msc; ++j) {
     888    if(msc_vector[j]) { msc_vector[j]->SetVerboseLevel(val); }
    811889  }
    812890  size_t emp = emp_vector.size();
    813   for (size_t k=0; k<emp; k++) {
    814     if(emp_vector[k]) emp_vector[k]->SetVerboseLevel(val);
    815   }
     891  for (size_t k=0; k<emp; ++k) {
     892    if(emp_vector[k]) { emp_vector[k]->SetVerboseLevel(val); }
     893  }
     894  emConfigurator->SetVerbose(val);
     895  //tableBuilder->SetVerbose(val);
     896  //emCorrections->SetVerbose(val);
     897  emSaturation->SetVerbose(val);
    816898}
    817899
    … …  
    823905  maxRangeVariation = v1;
    824906  maxFinalStep = v2;
    825   for(G4int i=0; i<n_loss; i++) {
    826     if(loss_vector[i]) loss_vector[i]->SetStepFunction(v1, v2);
     907  for(G4int i=0; i<n_loss; ++i) {
     908    if(loss_vector[i]) { loss_vector[i]->SetStepFunction(v1, v2); }
    827909  }
    828910}
    … …  
    832914void G4LossTableManager::SetLinearLossLimit(G4double val)
    833915{
    834   for(G4int i=0; i<n_loss; i++) {
    835     if(loss_vector[i]) loss_vector[i]->SetLinearLossLimit(val);
     916  for(G4int i=0; i<n_loss; ++i) {
     917    if(loss_vector[i]) { loss_vector[i]->SetLinearLossLimit(val); }
    836918  }
    837919}
    … …  
    846928//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.....
    847929
    848 void G4LossTableManager::SetParameters(G4VEnergyLossProcess* p)
    849 {
    850   if(stepFunctionActive) p->SetStepFunction(maxRangeVariation, maxFinalStep);
    851   if(integralActive)     p->SetIntegral(integral);
    852   if(minEnergyActive)    p->SetMinKinEnergy(minKinEnergy);
    853   if(maxEnergyActive)    p->SetMaxKinEnergy(maxKinEnergy);
     930void
     931G4LossTableManager::SetParameters(const G4ParticleDefinition* aParticle,
     932                                  G4VEnergyLossProcess* p)
     933{
     934  if(stepFunctionActive) { p->SetStepFunction(maxRangeVariation, maxFinalStep); }
     935  if(integralActive)     { p->SetIntegral(integral); }
     936  if(minEnergyActive)    { p->SetMinKinEnergy(minKinEnergy); }
     937  if(maxEnergyActive)    { p->SetMaxKinEnergy(maxKinEnergy); }
    854938  p->SetVerboseLevel(verbose);
     939  if(maxEnergyForMuonsActive) {
     940    G4double dm = std::abs(aParticle->GetPDGMass() - 105.7*MeV);
     941    if(dm < 5.*MeV) { p->SetMaxKinEnergy(maxKinEnergyForMuons); }
     942  }
    855943}
    856944
    … …  
    858946
    859947const std::vector<G4VEnergyLossProcess*>&
    860       G4LossTableManager::GetEnergyLossProcessVector()
     948G4LossTableManager::GetEnergyLossProcessVector()
    861949{
    862950  return loss_vector;
    … …  
    873961
    874962const std::vector<G4VMultipleScattering*>&
    875       G4LossTableManager::GetMultipleScatteringVector()
     963G4LossTableManager::GetMultipleScatteringVector()
    876964{
    877965  return msc_vector;
    … …  
    9251013void G4LossTableManager::SetFactorForAngleLimit(G4double val)
    9261014{
    927   if(val > 0.0) factorForAngleLimit = val;
     1015  if(val > 0.0) { factorForAngleLimit = val; }
    9281016}
    9291017
Note: See TracChangeset for help on using the changeset viewer.