#include <CMSMonopolePhysics.h>

Inheritance diagram for CMSMonopolePhysics:

Public Member Functions
	CMSMonopolePhysics (const HepPDT::ParticleDataTable *table_, const edm::ParameterSet &p)

void	ConstructParticle () override

void	ConstructProcess () override

	~CMSMonopolePhysics () override

Private Attributes
G4bool	deltaRay

std::vector< int >	elCharges

G4int	magCharge

std::vector< double >	masses

std::vector< Monopole * >	monopoles

G4bool	multiSc

std::vector< std::string >	names

std::vector< int >	pdgEncodings

G4bool	transport

G4int	verbose

Detailed Description

Definition at line 18 of file CMSMonopolePhysics.h.

Constructor & Destructor Documentation

CMSMonopolePhysics::CMSMonopolePhysics	(	const HepPDT::ParticleDataTable *	table_,
		const edm::ParameterSet &	p
	)

Definition at line 16 of file CMSMonopolePhysics.cc.

References deltaRay, elCharges, edm::ParameterSet::getUntrackedParameter(), cuy::ii, magCharge, ResonanceBuilder::mass, masses, monopoles, multiSc, names, AlCaHLTBitMon_ParallelJobs::p, pdgEncodings, AlCaHLTBitMon_QueryRunRegistry::string, transport, and verbose.

     : G4VPhysicsConstructor("Monopole Physics") {
   verbose = p.getUntrackedParameter<int>("Verbosity", 0);
   magCharge = p.getUntrackedParameter<int>("MonopoleCharge", 1);
   deltaRay = p.getUntrackedParameter<bool>("MonopoleDeltaRay", true);
   multiSc = p.getUntrackedParameter<bool>("MonopoleMultiScatter", false);
   transport = p.getUntrackedParameter<bool>("MonopoleTransport", true);
   double mass = p.getUntrackedParameter<double>("MonopoleMass", 200);
   if (pdt && mass > 0.0) {
     int ii = 0;
     for (HepPDT::ParticleDataTable::const_iterator p = pdt->begin(); p != pdt->end(); ++p, ++ii) {
       HepPDT::ParticleData particle = (p->second);
       std::string particleName = (particle.name()).substr(0, 8);
       if (strcmp(particleName.c_str(), "Monopole") == 0) {
         names.push_back(particle.name());
         masses.push_back(mass * CLHEP::GeV);
         elCharges.push_back((int)(particle.charge()));
         pdgEncodings.push_back(particle.pid());
         monopoles.push_back(nullptr);
         if (verbose > 0)
           G4cout << "CMSMonopolePhysics: Monopole[" << ii << "] " << particleName << " Mass " << particle.mass()
                  << " GeV, Magnetic Charge " << magCharge << ", Electric Charge " << particle.charge() << G4endl;
       } else if (strcmp(particleName.c_str(), "AntiMono") == 0) {
         names.push_back(particle.name());
         masses.push_back(mass * CLHEP::GeV);
         elCharges.push_back((int)(particle.charge()));
         pdgEncodings.push_back(particle.pid());
         monopoles.push_back(nullptr);
         if (verbose > 0)
           G4cout << "CMSMonopolePhysics: Monopole[" << ii << "] " << particleName << " Mass " << particle.mass()
                  << " GeV, Magnetic Charge " << magCharge << ", Electric Charge " << particle.charge() << G4endl;
       }
     }
   }
   if (verbose > 0)
     G4cout << "CMSMonopolePhysics has " << names.size() << " monopole candidates and delta Ray option " << deltaRay
            << G4endl;
 }

CMSMonopolePhysics::~CMSMonopolePhysics ( )

override

Definition at line 55 of file CMSMonopolePhysics.cc.

55 {}

Member Function Documentation

void CMSMonopolePhysics::ConstructParticle ( )

override

Definition at line 57 of file CMSMonopolePhysics.cc.

References elCharges, cuy::ii, magCharge, masses, monopoles, names, pdgEncodings, and verbose.

                                            {
   for (unsigned int ii = 0; ii < names.size(); ++ii) {
     // monopoles are created once in the master thread
     if (!monopoles[ii]) {
       G4int mc = (pdgEncodings[ii] >= 0) ? magCharge : -magCharge;
       Monopole* mpl = new Monopole(names[ii], pdgEncodings[ii], masses[ii], mc, elCharges[ii]);
       monopoles[ii] = mpl;
       if (verbose > 0)
         G4cout << "Create Monopole " << names[ii] << " of mass " << masses[ii] / CLHEP::GeV << " GeV, magnetic charge "
                << mc << ", electric charge " << elCharges[ii] << " and PDG encoding " << pdgEncodings[ii] << " at "
                << monopoles[ii] << G4endl;
     }
   }
 }

void CMSMonopolePhysics::ConstructProcess ( )

override

Definition at line 72 of file CMSMonopolePhysics.cc.

References edm::errors::Configuration, deltaRay, Exception, cuy::ii, Monopole::MagneticCharge(), ResonanceBuilder::mass, monopoles, multiSc, class-composition::o, and verbose.

                                           {
   // Add standard EM Processes
   if (verbose > 0) {
     G4cout << "### CMSMonopolePhysics ConstructProcess()" << G4endl;
   }
   G4PhysicsListHelper* ph = G4PhysicsListHelper::GetPhysicsListHelper();
 
   for (unsigned int ii = 0; ii < monopoles.size(); ++ii) {
     if (monopoles[ii]) {
       Monopole* mpl = monopoles[ii];
       G4ProcessManager* pmanager = mpl->GetProcessManager();
       if (!pmanager) {
         std::ostringstream o;
         o << "Monopole without a Process Manager";
         throw edm::Exception(edm::errors::Configuration, o.str().c_str());
         return;
       }
 
       G4double magn = mpl->MagneticCharge();
       G4double mass = mpl->GetPDGMass();
       if (verbose > 1) {
         G4cout << "### CMSMonopolePhysics instantiates for " << mpl->GetParticleName() << " at " << mpl << " Mass "
                << mass / CLHEP::GeV << " GeV Mag " << magn << " Process manager " << pmanager << G4endl;
       }
 
       if (magn != 0.0) {
         G4int idxt(0);
         pmanager->RemoveProcess(idxt);
         pmanager->AddProcess(new MonopoleTransportation(mpl, verbose), -1, 0, 0);
       }
 
       if (mpl->GetPDGCharge() != 0.0) {
         if (multiSc) {
           G4hMultipleScattering* hmsc = new G4hMultipleScattering();
           ph->RegisterProcess(hmsc, mpl);
         }
         G4hIonisation* hioni = new G4hIonisation();
         ph->RegisterProcess(hioni, mpl);
       }
       if (magn != 0.0) {
         G4mplIonisation* mplioni = new G4mplIonisation(magn);
         if (!deltaRay) {
           G4mplIonisationWithDeltaModel* ion = new G4mplIonisationWithDeltaModel(magn, "PAI");
           ion->SetParticle(mpl);
           mplioni->AddEmModel(0, ion, ion);
         }
         ph->RegisterProcess(mplioni, mpl);
       }
       pmanager->AddDiscreteProcess(new G4StepLimiter());
       if (verbose > 1) {
         pmanager->DumpInfo();
       }
     }
   }
 }