In This Package:

DsPhysConsOptical.cc

Go to the documentation of this file.

#define USE_CUSTOM_CERENKOV
#define USE_CUSTOM_SCINTILLATION

#include "DsPhysConsOptical.h"
#include "DsG4OpRayleigh.h"

#ifdef USE_CUSTOM_CERENKOV
#include "DsG4Cerenkov.h"
#else
#include "G4Cerenkov.hh"
#endif

#ifdef USE_CUSTOM_SCINTILLATION
#include "DsG4Scintillation.h"
#else
#include "G4Scintillation.hh"
#endif

#include "GaudiKernel/DeclareFactoryEntries.h" 
#include "GaudiKernel/IProperty.h" 

#include "G4OpAbsorption.hh"
#include "G4OpRayleigh.hh"
#include "G4OpBoundaryProcess.hh"
#include "G4ProcessManager.hh"
#include "G4FastSimulationManagerProcess.hh"

DECLARE_TOOL_FACTORY(DsPhysConsOptical);


DsPhysConsOptical::DsPhysConsOptical(const std::string& type,
                                     const std::string& name, 
                                     const IInterface* parent)
    : GiGaPhysConstructorBase(type,name,parent)
{
    declareProperty("CerenMaxPhotonsPerStep",m_cerenMaxPhotonPerStep = 300,
                    "Limit step to at most this many (unscaled) Cerenkov photons.");

    declareProperty("ScintDoReemission",m_doReemission = true,
                    "Do reemission in scintilator.");
    declareProperty("ScintDoScintAndCeren",m_doScintAndCeren = true,
                    "Do both scintillation and Cerenkov in scintilator.");

    declareProperty("UseCerenkov", m_useCerenkov=true, 
                    "Use the Cerenkov process?");

    declareProperty("UseScintillation",m_useScintillation=true,
                    "Use the Scintillation process?");
    declareProperty("UseRayleigh", m_useRayleigh=true,
                    "Use the Rayleigh scattering process?");
    declareProperty("UseAbsorption", m_useAbsorption=true,
                    "Use light absorption process?");
    declareProperty("UseFastMu300nsTrick", m_useFastMu300nsTrick=false,
                    "Use Fast muon simulation?");
    declareProperty("ScintillationYieldFactor",m_ScintillationYieldFactor = 1.0,
                    "Scale the number of scintillation photons per MeV by this much.");
   
    declareProperty("BirksConstant1", m_birksConstant1 = 6.5e-3*g/cm2/MeV, 
                    "Birks constant C1");
    declareProperty("BirksConstant2", m_birksConstant2 = 2.1e-6*(g/cm2/MeV)*(g/cm2/MeV), 
                   "Birks constant C2");

    declareProperty("PreQE", m_preQE=0.32,
                    "Miximal possible PMT QE value to be applied on the stage of "
                    "generating photons in scintillation/Cerenkov processes");

    declareProperty("ApplyPreQE",m_applyPreQE=true,
                    "Apply preQE on stage of generating photons of not.");
}

StatusCode DsPhysConsOptical::initialize()
{
    info()<<"Photons prescaling is "<<( m_applyPreQE?"on":"off" )
          <<". Preliminary applied efficiency is "<<m_preQE<<endreq;
    info()<<"Make sure the same values are set for the DsPmtSensDet"<<endreq;
    return this->GiGaPhysConstructorBase::initialize();
}

DsPhysConsOptical::~DsPhysConsOptical()
{
}

void DsPhysConsOptical::ConstructParticle()
{
}

void DsPhysConsOptical::ConstructProcess()
{
#ifdef USE_CUSTOM_CERENKOV
    
    info () << "Using customized DsG4Cerenkov." << endreq;
    DsG4Cerenkov* cerenkov = 0;
    if (m_useCerenkov) {
        cerenkov = new DsG4Cerenkov();
        cerenkov->SetMaxNumPhotonsPerStep(m_cerenMaxPhotonPerStep);
        cerenkov->SetApplyPreQE(m_applyPreQE);
        cerenkov->SetPreQE(m_preQE);
        // cerenkov->SetPhotonWeight(m_cerenPhotonScaleWeight);
        cerenkov->SetTrackSecondariesFirst(true);
    }
#else
    info () << "Using standard G4Cerenkov." << endreq;
    G4Cerenkov* cerenkov = 0;
    if (m_useCerenkov) {
        cerenkov = new G4Cerenkov();
        cerenkov->SetMaxNumPhotonsPerStep(m_cerenMaxPhotonPerStep);
        cerenkov->SetTrackSecondariesFirst(true);
    }
#endif

#ifdef USE_CUSTOM_SCINTILLATION
    DsG4Scintillation* scint = 0;
    info() << "Using customized DsG4Scintillation." << endreq;
    scint = new DsG4Scintillation();
    scint->SetBirksConstant1(m_birksConstant1);
    scint->SetBirksConstant2(m_birksConstant2);
    scint->SetDoReemission(m_doReemission);
    scint->SetDoBothProcess(m_doScintAndCeren);
    // scint->SetPhotonWeight(m_scintPhotonScaleWeight);
    scint->SetApplyPreQE(m_applyPreQE);
    scint->SetPreQE(m_preQE);
    scint->SetScintillationYieldFactor(m_ScintillationYieldFactor); //1.);
    scint->SetUseFastMu300nsTrick(m_useFastMu300nsTrick);
    scint->SetTrackSecondariesFirst(true);
    if (!m_useScintillation) {
        scint->SetNoOp();
    }
#else  // standard G4 scint
    G4Scintillation* scint = 0;
    if (m_useScintillation) {
        info() << "Using standard G4Scintillation." << endreq;
        scint = new G4Scintillation();
        scint->SetScintillationYieldFactor(m_ScintillationYieldFactor); // 1.);
        scint->SetTrackSecondariesFirst(true);
    }
#endif

    G4OpAbsorption* absorb = 0;
    if (m_useAbsorption) {
        absorb = new G4OpAbsorption();
    }

    DsG4OpRayleigh* rayleigh = 0;
    if (m_useRayleigh) {
        rayleigh = new DsG4OpRayleigh();
        //        rayleigh->SetVerboseLevel(2);
    }

    G4OpBoundaryProcess* boundproc = new G4OpBoundaryProcess();
    boundproc->SetModel(unified);

    G4FastSimulationManagerProcess* fast_sim_man
        = new G4FastSimulationManagerProcess("fast_sim_man");
    
    theParticleIterator->reset();
    while( (*theParticleIterator)() ) {

        G4ParticleDefinition* particle = theParticleIterator->value();
        G4ProcessManager* pmanager = particle->GetProcessManager();
    
        // Caution: as of G4.9, Cerenkov becomes a Discrete Process.
        // This code assumes a version of G4Cerenkov from before this version.

        if(cerenkov && cerenkov->IsApplicable(*particle)) {
            pmanager->AddProcess(cerenkov);
            pmanager->SetProcessOrdering(cerenkov, idxPostStep);
            debug() << "Process: adding Cherenkov to " 
                    << particle->GetParticleName() << endreq;
        }

        if(scint && scint->IsApplicable(*particle)) {
            pmanager->AddProcess(scint);
            pmanager->SetProcessOrderingToLast(scint, idxAtRest);
            pmanager->SetProcessOrderingToLast(scint, idxPostStep);
            debug() << "Process: adding Scintillation to "
                    << particle->GetParticleName() << endreq;
        }

        if (particle == G4OpticalPhoton::Definition()) {
            if (absorb)
                pmanager->AddDiscreteProcess(absorb);
            if (rayleigh)
                pmanager->AddDiscreteProcess(rayleigh);
            pmanager->AddDiscreteProcess(boundproc);
            //pmanager->AddDiscreteProcess(pee);
            pmanager->AddDiscreteProcess(fast_sim_man);
        }
    }
}

---