larg4::ModularPhysicsList Class Reference

#include <PhysicsList.h>

Inheritance diagram for larg4::ModularPhysicsList:

Public Member Functions
virtual void	ConstructProcess ()
void	RegisterPhysics (G4VPhysicsConstructor *g)
const G4VPhysicsConstructor *	GetPhysics (G4int index) const
const G4VPhysicsConstructor *	GetPhysics (const G4String &name) const

Detailed Description

Definition at line 62 of file PhysicsList.h.

Member Function Documentation

void larg4::ModularPhysicsList::ConstructProcess ( )

virtual

Definition at line 36 of file PhysicsList.cxx.

  {
    // We don't need to modify G4VModularPhysicsList's
    // AddTransportation method.  Just invoke it directly.
    G4VModularPhysicsList::AddTransportation();

    ////////////////////////////////////////////////////////////////////////////////////////
    // This is the "new" code that has to be added to
    // G4VModularPhysicsList::ConstructProcess() to handle the
    // parallel geometry.

    art::ServiceHandle<sim::LArG4Parameters const> lgp;
    bool DisableWireplanes = lgp->DisableWireplanes();

    G4ParallelWorldScoringProcess* LArVoxelParallelWorldScoringProcess =
      new G4ParallelWorldScoringProcess("LArVoxelReadoutScoringProcess");

    G4ParallelWorldScoringProcess* OpDetParallelWorldScoringProcess =
      new G4ParallelWorldScoringProcess("OpDetReadoutScoringProcess");

    // Note that the name below MUST match the name used in the
    // LArVoxelReadoutGeometry or OpDetReadoutGeometry constructor.
    LArVoxelParallelWorldScoringProcess->SetParallelWorld("LArVoxelReadoutGeometry");
    OpDetParallelWorldScoringProcess->SetParallelWorld("OpDetReadoutGeometry");

    // Tell all the particles in the physics list to recognize the
    // LAr voxel parallel world.  "theParticleIterator" is defined in
    // G4VUserPhysicsList.hh.  Only photons recognise the OpDet parallel
    // world.
    static G4ParticleTable* fParticleTable = G4ParticleTable::GetParticleTable();
    G4ParticleTable::G4PTblDicIterator* theParticleIterator;
    theParticleIterator = fParticleTable->GetIterator();
    theParticleIterator->reset();
    while ((*theParticleIterator)()) {
      G4ParticleDefinition* particle = theParticleIterator->value();

      if (particle->GetParticleType() == "opticalphoton") {
        G4ProcessManager* pmanager = particle->GetProcessManager();
        pmanager->AddProcess(OpDetParallelWorldScoringProcess);
        pmanager->SetProcessOrderingToLast(OpDetParallelWorldScoringProcess, idxAtRest);
        pmanager->SetProcessOrdering(OpDetParallelWorldScoringProcess, idxAlongStep, 1);
        pmanager->SetProcessOrderingToLast(OpDetParallelWorldScoringProcess, idxPostStep);
      }

      // Only apply voxel processing in the LAr TPC if the particles are
      // charged and they have a significant life-time.
      else if (particle->GetPDGCharge() != 0 && !particle->IsShortLived()) {
        G4ProcessManager* pmanager = particle->GetProcessManager();
        if (!DisableWireplanes) {
          pmanager->AddProcess(LArVoxelParallelWorldScoringProcess);
          pmanager->SetProcessOrderingToLast(LArVoxelParallelWorldScoringProcess, idxAtRest);
          pmanager->SetProcessOrdering(LArVoxelParallelWorldScoringProcess, idxAlongStep, 1);
          pmanager->SetProcessOrderingToLast(LArVoxelParallelWorldScoringProcess, idxPostStep);
        }

        // Do secondary biasing under control of K0Bias switch.
        G4bool genSecondaries(false);
        G4bool cE(false);
        if (((particle->GetParticleName() == G4MuonPlus::MuonPlus()->GetParticleName() ||
              particle->GetParticleName() == G4MuonMinus::MuonMinus()->GetParticleName()) &&
             lgp->UseCustomPhysics()) ||
            ((particle->GetParticleName() == G4Proton::Proton()->GetParticleName() ||
              particle->GetParticleName() == G4Neutron::Neutron()->GetParticleName() ||
              particle->GetParticleName() == G4KaonZeroShort::KaonZeroShort()->GetParticleName() ||
              particle->GetParticleName() == G4KaonZeroLong::KaonZeroLong()->GetParticleName() ||
              particle->GetParticleName() == G4Lambda::Lambda()->GetParticleName()) &&
             lgp->UseCustomPhysics())) {
          std::vector<std::string> EnabledPhysics = lgp->EnabledPhysics();
          for (std::vector<std::string>::const_iterator it = EnabledPhysics.begin();
               it != EnabledPhysics.end();
               it++) {
            std::string PhysicsName = (*it);
            if (!PhysicsName.compare("SynchrotronAndGN") && lgp->K0Bias()) {
              genSecondaries = true;
            }
            if (!PhysicsName.compare("ChargeExchange")) { cE = true; }
          } // end loop over enabled physics
        }   // end if using custom physics

        if (genSecondaries) {
          G4int nSecondaries(lgp->K0Bias());
          G4int fXSBias(lgp->MNXSBias());
          G4int xSBias(lgp->MNXBias());
          mf::LogInfo("PhysicsList: ")
            << "Turning on WrappedMuNuclear for " << particle->GetParticleName() << "s with "
            << nSecondaries << " appropriately weighted secondaries."
            << " XSBias is set to " << xSBias
            << " and the cross-section is increased by a factor of " << fXSBias << ".";
          G4MuonNuclearProcess* g4MNI = new G4MuonNuclearProcess();
          MuNuclearSplittingProcessXSecBias* munuclSplitting =
            new MuNuclearSplittingProcessXSecBias();
          G4bool active(true);

          munuclSplitting->SetNSplit(nSecondaries, xSBias, fXSBias);
          munuclSplitting->SetIsActive(active);
          munuclSplitting->RegisterProcess(g4MNI);
          // Middle  -1 with no biasing.
          // The middle +1 enforces AlongStepDoIt active for MuNuclear, I claim.
          if (xSBias && (fXSBias > 1))
            pmanager->AddProcess(munuclSplitting, -1, 1, 1);
          else
            pmanager->AddProcess(munuclSplitting, -1, -1, 1);
        } // end if generating secondaries

        if (cE) {
          mf::LogInfo("PhysicsList: ")
            << "Turning on ChargeExchange for " << particle->GetParticleName() << "s.";
          G4ChargeExchange* model = new G4ChargeExchange();
          G4ChargeExchangeProcess* p = new G4ChargeExchangeProcess();

          p->RegisterMe(model);
          pmanager->AddDiscreteProcess(p);

        } // end if doing charge exchange
      }   // end if short lived particle
    }     // end loop over particles

    // End of code "added" to G4VModularPhysicsList::ConstructProcess()
    ////////////////////////////////////////////////////////////////////////////////////////

    // This code is also unchanged from
    // G4VModularPhysicsList::ConstructProcess(); it means "activate
    // the physics processes and particle combinations we've specified
    // in physicsVector."  The physicsVector is built up by the
    // pre-supplied Geant4 physics list; see PhysicsList.h for the
    // name of that list.  "physicsVector" is defined in
    // G4VModularPhysicsList.hh.
    G4PhysConstVector::iterator itr;
    for (itr = G4MT_physicsVector->begin(); itr != G4MT_physicsVector->end(); ++itr) {
      (*itr)->ConstructProcess();
    }
  } // end ConstructProcess

const G4VPhysicsConstructor* larg4::ModularPhysicsList::GetPhysics ( G4int  index ) const

inline

Definition at line 76 of file PhysicsList.h.

    {
      return G4VModularPhysicsList::GetPhysics(index);
    }

const G4VPhysicsConstructor* larg4::ModularPhysicsList::GetPhysics ( const G4String &  name ) const

inline

Definition at line 81 of file PhysicsList.h.

    {
      return G4VModularPhysicsList::GetPhysics(name);
    }

void larg4::ModularPhysicsList::RegisterPhysics ( G4VPhysicsConstructor *  g )

inline

Definition at line 71 of file PhysicsList.h.

    {
      G4VModularPhysicsList::RegisterPhysics(g);
    }

---

The documentation for this class was generated from the following files:

• larsim/larsim/LegacyLArG4/PhysicsList.h
• larsim/larsim/LegacyLArG4/PhysicsList.cxx