#include <CMSMonopolePhysics.h>

Inheritance diagram for CMSMonopolePhysics:

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

void	ConstructParticle ()

void	ConstructProcess ()

virtual	~CMSMonopolePhysics ()

Private Attributes
G4bool	deltaRay

std::vector< int >	elCharges

sim::FieldBuilder *	fieldBuilder

G4int	magCharge

std::vector< double >	masses

std::vector< G4Monopole * >	monopoles

G4bool	multiSc

std::vector< std::string >	names

std::vector< int >	pdgEncodings

G4bool	transport

G4int	verbose

Detailed Description

Definition at line 15 of file CMSMonopolePhysics.h.

Constructor & Destructor Documentation

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

Definition at line 18 of file CMSMonopolePhysics.cc.

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

                                                   :
   G4VPhysicsConstructor("Monopole Physics"), fieldBuilder(fB_) {
   
   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(0);
     //std::cout << "CMSMonopolePhysics: Monopole[" << ii
     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(0);
     //std::cout << "CMSMonopolePhysics: Monopole[" << ii
     if (verbose > 0) G4cout << "CMSMonopolePhysics: Monopole[" << ii
                 << "] " << particleName << " Mass "
                 << particle.mass() << " GeV, Magnetic Charge "
                 << magCharge << ", Electric Charge "
                 << particle.charge() << G4endl; 
       }
     }
   }
   // std::cout << "CMSMonopolePhysics has " << names.size()
   if (verbose > 0) G4cout << "CMSMonopolePhysics has " << names.size()
               << " monopole candidates and delta Ray option " 
               << deltaRay << G4endl;
 }

CMSMonopolePhysics::~CMSMonopolePhysics ( )

virtual

Definition at line 68 of file CMSMonopolePhysics.cc.

68 {}

Member Function Documentation

void CMSMonopolePhysics::ConstructParticle ( )

Definition at line 70 of file CMSMonopolePhysics.cc.

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

                                            {
   
   for (unsigned int ii=0; ii<names.size(); ++ii) {
     if (!monopoles[ii]) {
       G4Monopole* mpl = new G4Monopole(names[ii], pdgEncodings[ii],
                        masses[ii], ((pdgEncodings[ii] > 0 ) ? magCharge : -magCharge), elCharges[ii]);;
       monopoles[ii] = mpl;
       //std::cout << "Create G4Monopole " << names[ii] 
       if (verbose > 0) G4cout << "Create G4Monopole " << names[ii] 
                   << " of mass " << masses[ii]/CLHEP::GeV
                   << " GeV, magnetic charge " << ((pdgEncodings[ii] > 0) ? magCharge : -magCharge)
                   << ", electric charge " << elCharges[ii]
                   << " and PDG encoding " << pdgEncodings[ii]
                   << " at " << monopoles[ii] << G4endl;
     }
   }
 }

void CMSMonopolePhysics::ConstructProcess ( )

Definition at line 88 of file CMSMonopolePhysics.cc.

References deltaRay, fieldBuilder, customizeTrackingMonitorSeedNumber::idx, cuy::ii, max(), mod(), monopoles, multiSc, and transport.

                                           {
   // Add standard EM Processes
 
   if (verbose > 0)
     G4cout << "### CMSMonopolePhysics ConstructProcess()" << G4endl;
   for (unsigned int ii=0; ii<monopoles.size(); ++ii) {
     if (monopoles[ii]) {
       G4Monopole* mpl = monopoles[ii];
       G4ProcessManager* pmanager = new G4ProcessManager(mpl);
       mpl->SetProcessManager(pmanager);
 
       G4String particleName = mpl->GetParticleName();
       G4double magn         = mpl->MagneticCharge();
       G4double mass         = mpl->GetPDGMass();
       if (verbose > 1)
     G4cout << "### CMSMonopolePhysics instantiates for " << particleName 
            << " at " << mpl << " Mass " << mass/CLHEP::GeV 
            << " GeV Mag " << magn  << " Process manager " << pmanager 
            << G4endl;
 
       // defined monopole parameters and binning
 
       G4double emin = mass/20000.;
       if(emin < CLHEP::keV) emin = CLHEP::keV;
       G4double emax = std::max(10.*CLHEP::TeV, mass*100);
       G4int nbin = G4int(std::log10(emax/emin));
       if (nbin < 1) nbin = 1;
       nbin *= 10;
 
       G4int idx = 1;
       if (verbose > 1)
     G4cout << "### Magnetic charge " << magn << " and electric charge " 
            << mpl->GetPDGCharge() <<"\n   # of bins in dE/dx table = "
            << nbin << " in the range " << emin << ":" << emax << G4endl;
   
       if (magn == 0.0 || (!transport)) {
     pmanager->AddProcess( new G4Transportation(verbose), -1, 0, 0);
       } else {
     pmanager->AddProcess( new G4MonopoleTransportation(mpl,fieldBuilder,verbose), -1, 0, 0);
       }
 
       if (mpl->GetPDGCharge() != 0.0) {
     if (multiSc) {
       G4hMultipleScattering* hmsc = new G4hMultipleScattering();
       pmanager->AddProcess(hmsc,  -1, idx, idx);
       ++idx;
     }
     if (deltaRay) {
       G4hIonisation* hhioni = new G4hIonisation();
       hhioni->SetDEDXBinning(nbin);
       hhioni->SetMinKinEnergy(emin);
       hhioni->SetMaxKinEnergy(emax);
       pmanager->AddProcess(hhioni,  -1, idx, idx);
     } else {
       G4hhIonisation* hhioni = new G4hhIonisation();
       hhioni->SetDEDXBinning(nbin);
       hhioni->SetMinKinEnergy(emin);
       hhioni->SetMaxKinEnergy(emax);
       pmanager->AddProcess(hhioni,  -1, idx, idx);
     }
     ++idx;
       }
       if(magn != 0.0) {
     G4mplIonisation* mplioni = new G4mplIonisation(magn);
     mplioni->SetDEDXBinning(nbin);
     mplioni->SetMinKinEnergy(emin);
     mplioni->SetMaxKinEnergy(emax);
     if (!deltaRay) {
       G4mplIonisationWithDeltaModel* mod = 
         new G4mplIonisationWithDeltaModel(magn,"PAI");
       mplioni->AddEmModel(0,mod,mod);
     }
     pmanager->AddProcess(mplioni, -1, idx, idx);
     ++idx;
       }
       pmanager->AddProcess( new G4StepLimiter(),  -1, -1, idx);
       if (verbose > 1) pmanager->DumpInfo();
     }
   }
 }