G4DNAModelInterface.cc

Go to the documentation of this file.

//
// ********************************************************************
// * License and Disclaimer                                           *
// *                                                                  *
// * The  Geant4 software  is  copyright of the Copyright Holders  of *
// * the Geant4 Collaboration.  It is provided  under  the terms  and *
// * conditions of the Geant4 Software License,  included in the file *
// * LICENSE and available at  http://cern.ch/geant4/license .  These *
// * include a list of copyright holders.                             *
// *                                                                  *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work  make  any representation or  warranty, express or implied, *
// * regarding  this  software system or assume any liability for its *
// * use.  Please see the license in the file  LICENSE  and URL above *
// * for the full disclaimer and the limitation of liability.         *
// *                                                                  *
// * This  code  implementation is the result of  the  scientific and *
// * technical work of the GEANT4 collaboration.                      *
// * By using,  copying,  modifying or  distributing the software (or *
// * any work based  on the software)  you  agree  to acknowledge its *
// * use  in  resulting  scientific  publications,  and indicate your *
// * acceptance of all terms of the Geant4 Software license.          *
// ********************************************************************
//
//
// Contact authors: S. Meylan, C. Villagrasa
//
// email: [email protected], [email protected]
 
#include "G4DNAModelInterface.hh"
#include "G4PhysicalConstants.hh"
#include "G4SystemOfUnits.hh"
#include "G4DNAMolecularMaterial.hh"
 
 
G4DNAModelInterface::G4DNAModelInterface(const G4String &nam)
    : G4VEmModel(nam), fName(nam), fpParticleChangeForGamma(0), fSampledMat("")
{
 
}
 
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
 
G4DNAModelInterface::~G4DNAModelInterface()
{
    // Loop on all the registered models to properly delete them (free the memory)
    for(std::size_t i=0, ie = fRegisteredModels.size(); i<ie; ++i)
    {
      if(fRegisteredModels.at(i) != nullptr) delete fRegisteredModels.at(i);
    }
}
 
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
 
void G4DNAModelInterface::Initialise(const G4ParticleDefinition* particle,
                                     const G4DataVector& cuts)
{
    // Those two statements are necessary to override the energy limits set in the G4DNAProcesses (ionisation, elastic, etc...).
    // Indeed, with the ModelInterface system, the model define themselves their energy limits per material and particle.
    // Therefore, such a limit should not be in the G4DNAProcess classes.
    //
    SetLowEnergyLimit(0.);
    SetHighEnergyLimit(DBL_MAX);
 
    fpParticleChangeForGamma = GetParticleChangeForGamma();
 
    // Loop on all the registered models to initialise them
    for(std::size_t i=0, ie = fRegisteredModels.size(); i<ie; ++i)
    {
      fRegisteredModels.at(i)->Initialise(particle, cuts, fpParticleChangeForGamma);
    }
 
 
    // Build the [material][particle]=Models table
    // used to retrieve the model corresponding to the current material/particle couple
    BuildMaterialParticleModelTable(particle);
 
    BuildMaterialMolPerVolTable();
}
 
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
 
G4double G4DNAModelInterface::CrossSectionPerVolume(const G4Material* material,
                                                 const G4ParticleDefinition* p,
                                                 G4double ekin,
                                                 G4double emin,
                                                 G4double emax)
{
    // Method to return the crossSection * nbMoleculePerUnitVolume to the process class.
    // Process class then calculates the path.
    // The cross section is calculated in the registered model(s) and this class just call the method
    // Two cases are handled here: normal material and composite material.
    //
    // Idea:
    // *** Simple material ***
    // Ask for the cross section of the chosen model.
    // Multiply it by the number of medium molecules per volume unit.
    // Return the value.
    // *** Composite material ***
    // Ask for the cross section of the chosen model for each component.
    // Apply a factor to each cross section and sum the results. The factor is the molecule number of component per composite volume unit.
    // The total cross section is returned.
 
    // To reset the sampledMat variable.
    // Can be used by user to retrieve current component
    fSampledMat = "";
 
    // This is the value to be sum up and to be returned at then end
    G4double crossSectionTimesNbMolPerVol (0);
 
    // Reset the map saving the material and the cumulated corresponding cross section
    // Used in SampleSecondaries if the interaction is selected for the step and if the material is a composite
    fMaterialCS.clear();
 
     // This is the value to be used by SampleSecondaries
    fCSsumTot = 0;
 
    // *****************************
    // Material is not a composite
    // *****************************
    //
    if(material->GetMatComponents().empty())
    {
        // Get the material name
        const G4String& materialName = material->GetName();
 
        // Use the table to get the  model
        G4VDNAModel* model = GetDNAModel(materialName, p->GetParticleName(), ekin);
 
        // Get the nunber of molecules per volume unit for that material
        G4double nbOfMoleculePerVolumeUnit = GetNumMoleculePerVolumeUnitForMaterial(material);
 
        // Calculate the cross section times the number of molecules
        if(model != 0)
            crossSectionTimesNbMolPerVol = nbOfMoleculePerVolumeUnit * model->CrossSectionPerVolume(material, materialName, p, ekin, emin, emax);
        else // no model was selected, we are out of the energy ranges
            crossSectionTimesNbMolPerVol = 0.;
    }
 
    // ********************************
    // Material is a composite
    // ********************************
    //
    else
    {
        // Copy the map in a local variable
        // Otherwise we get segmentation fault and iterator pointing to nowhere: do not know why...
        // Maybe MatComponents map is overrided by something somewhere ?
        std::map<G4Material*, G4double> componentsMap = material->GetMatComponents();
 
        // Retrieve the iterator
        std::map<G4Material*, G4double>::const_iterator it = componentsMap.begin();
 
        // Get the size
        std::size_t componentNumber = componentsMap.size();
 
        // Loop on all the components
        //for(it = material->GetMatComponents().begin(); it!=material->GetMatComponents().end();++it)
        for(std::size_t i=0; i<componentNumber; ++i)
        {
            // Get the current component
            G4Material* component = it->first;
 
            // Get the current component mass fraction
            //G4double massFraction = it->second;
 
            // Get the number of component molecules in a volume unit of composite material
            G4double nbMoleculeOfComponentInCompositeMat = GetNumMolPerVolUnitForComponentInComposite(component, material);
 
            // Get the current component name
            const G4String componentName = component->GetName();
 
            // Retrieve the model corresponding to the current component (ie material)
            G4VDNAModel* model = GetDNAModel(componentName, p->GetParticleName(), ekin);
 
            // Add the component part of the cross section to the cross section variable.
            // The component cross section is multiplied by the total molecule number in the composite scaled by the mass fraction.
            if(model != 0)
                crossSectionTimesNbMolPerVol =
                        nbMoleculeOfComponentInCompositeMat * model->CrossSectionPerVolume(component, componentName, p, ekin, emin, emax);
            else // no model was selected, we are out of the energy ranges
                crossSectionTimesNbMolPerVol = 0.;
 
            // Save the component name and its calculated crossSectionTimesNbMolPerVol
            // To be used by sampling secondaries if the interaction is selected for the step
            fMaterialCS[componentName] = crossSectionTimesNbMolPerVol;
 
            // Save the component name and its calculated crossSectionTimesNbMolPerVol
            // To be used by sampling secondaries if the interaction is selected for the step
            fCSsumTot += crossSectionTimesNbMolPerVol;
 
            // Move forward the iterator
            ++it;
        }
 
        crossSectionTimesNbMolPerVol = fCSsumTot;
 
    }
 
    // return the cross section times the number of molecules
    // the path of the interaction will be calculated using that value
    return crossSectionTimesNbMolPerVol;
}
 
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
 
void G4DNAModelInterface::SampleSecondaries(std::vector<G4DynamicParticle*>* fVect,
                                         const G4MaterialCutsCouple* couple,
                                         const G4DynamicParticle* aDynamicParticle,
                                         G4double tmin,
                                         G4double tmax)
{
    // To call the sampleSecondaries method of the registered model(s)
    // In the case of composite material, we need to choose a component to call the method from.
    // To do so we use a random sampling on the crossSectionTimesNbMolPerVol used in CrossSectionPerVolume method.
    // If we enter that method it means the corresponding interaction (and process) has been chosen for the current step.
 
    G4String materialName;
 
    // *******************************
    // Material is not a composite
    // *******************************
    //
    if(couple->GetMaterial()->GetMatComponents().empty())
    {
        materialName = couple->GetMaterial()->GetName();
    }
 
    // ****************************
    // Material is a composite
    // ****************************
    //
    else
    {
        // Material is a composite
        // We need to select a component
 
        // We select a random number between 0 and fCSSumTot
        G4double rand = G4UniformRand()*fCSsumTot;
 
        G4double cumulCS (0);
 
        G4bool result = false;
 
        // We loop on each component cumulated cross section
        //
        // Retrieve the iterators
        std::map<const G4String , G4double>::const_iterator it = fMaterialCS.begin();
        std::map<const G4String , G4double>::const_iterator ite = fMaterialCS.end();
        // While this is true we do not have found our component.
        while(rand>cumulCS)
        {
            // Check if the sampling is ok
            if(it==ite)
            {
                G4Exception("G4DNAModelManager::SampleSecondaries","em0006",
                            FatalException,
                            "The random component selection has failed: we ran into the end of the map without having a selected component");
                return; // to make some compilers happy
            }
 
            // Set the cumulated value for the iteration
            cumulCS += it->second;
 
            // Check if we have reach the material to be selected
            // The DBL_MAX is here to take into account a return DBL_MAX in CSPerVol for the elastic model
            // to force elastic sampleSecondaries where the particle can be killed.
            // Used when paticle energy is lower than limit.
            if(rand<cumulCS || cumulCS >= DBL_MAX)
            {
                // we have our selected material
                materialName = it->first;
                result = true;
                break;
            }
 
            // make the iterator move forward
            ++it;
        }
 
        // Check that we get a result
        if(!result)
        {
            // it is possible to end up here if the return DBL_MAX of CSPerVol in the elastic model is not taken into account
 
            G4Exception("G4DNAModelManager::SampleSecondaries","em0006",
                        FatalException,
                        "The random component selection has failed: while loop ended without a selected component.");
            return; // to make some compilers happy
        }
 
    }
 
    // **************************************
    // Call the SampleSecondaries method
    // **************************************
 
    // Rename material if modified NIST material
    // This is needed when material is obtained from G4MaterialCutsCouple
    if(materialName.find("_MODIFIED")!=G4String::npos)
    {
        materialName = materialName.substr(0,materialName.size()-9);
    }
 
    fSampledMat = materialName;
 
    G4VDNAModel* model = GetDNAModel(materialName,
                                     aDynamicParticle->GetParticleDefinition()->GetParticleName(),
                                     aDynamicParticle->GetKineticEnergy() );
            //fMaterialParticleModelTable[materialName][aDynamicParticle->GetDefinition()->GetParticleName()][0];
 
    model->SampleSecondaries(fVect, couple, materialName, aDynamicParticle, fpParticleChangeForGamma, tmin, tmax);
}
 
void G4DNAModelInterface::RegisterModel(G4VDNAModel* model)
{
    fRegisteredModels.push_back(model);
}
 
void G4DNAModelInterface::RegisterModel(G4VEmModel* model, const G4ParticleDefinition* particle)
{
    G4DNADummyModel* dummyWrapper = new G4DNADummyModel("G4_WATER", particle, model->GetName(), model);
 
    RegisterModel(dummyWrapper);
}
 
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
 
void G4DNAModelInterface::BuildMaterialParticleModelTable(const G4ParticleDefinition* p)
{
    // Method to build a map: [material][particle] = Model*.
    // The map is used to retrieve the correct model for the current particle/material couple.
 
    // Get the current particle name
    const G4String& pName = p->GetParticleName();
 
    // Retrieve the iterator
    G4MaterialTable::iterator it;
 
    // Loop on all materials registered in the simulation
    for(it = G4Material::GetMaterialTable()->begin(); it!=G4Material::GetMaterialTable()->end(); ++it)
    {
        // Get the material pointer
        G4Material* mat = *it;
 
        // Get the map
        std::map<G4Material*, G4double> componentMap = mat->GetMatComponents();
 
        // Get the number of component within the composite
        std::size_t compositeSize = componentMap.size();
 
        // Check that the material is not a composite material
        if(componentMap.empty())
        {
            // Get the material name
            const G4String& matName = mat->GetName();
 
            // Insert the model in the table.
            InsertModelInTable(matName, pName);
        }
        // if the material is a composite material then we need to loop on all its components to register them
        else
        {
            // Retrieve the component map begin iterator
            std::map<G4Material*, G4double>::const_iterator itComp = componentMap.begin();
 
            // Loop on all the components of the material
            //for(itComp = mat->GetMatComponents().begin(); itComp != eitComp; ++itComp)
            for(unsigned int k=0; k<compositeSize; ++k)
            {
                G4Material* component = itComp->first;
 
//                // Check that the component is not itself a composite
//                if(component->GetMatComponents().size()!=0)
//                {
//                    std::ostringstream oss;
//                    oss<<"Material "<<mat->GetName()<<" is a composite and its component ";
//                    oss<<component->GetName()<<" is also a composite material. Building composite with other composites is not implemented yet";
//                    oss<<G4endl;
//                    G4Exception("G4DNAModelManager::BuildMaterialParticleModelTable","em0006",
//                                FatalException, oss.str().c_str());
//                    return; // to make some compilers happy
//                }
 
                // Get the current component name
                const G4String compName = component->GetName();
 
                // If there is a model then insert the model corresponding to the component in the table
                // contains a if statement to check we have not registered the material as a component or a normal material before.
                InsertModelInTable(compName, pName);
 
                // move forward the iterator
                ++itComp;
            }
        }
    }
}
 
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
 
void G4DNAModelInterface::BuildMaterialMolPerVolTable()
{
    // To be sure the G4DNAMolecularMaterial is initialized
    G4DNAMolecularMaterial::Instance()->Initialize();
 
    G4MaterialTable* materialTable = G4Material::GetMaterialTable();
 
    // Loop on all the materials inside the "materialTable"
    for(size_t i=0, ie=materialTable->size(); i<ie; i++)
    {
        // Current material
        G4Material* currentMaterial = materialTable->at(i);
 
        // Current material name
        const G4String& currentMatName = currentMaterial->GetName();
 
        // Will the material be used in this interface instance ?
        // Loop on all the materials that can be dealt with in this class
        MaterialParticleModelTable::iterator it = fMaterialParticleModelTable.begin();
        MaterialParticleModelTable::iterator ite = fMaterialParticleModelTable.end();
        for(; it != ite; it++)
        {
            const G4String& materialName = it->first;
 
            if(materialName == currentMatName)
            {
                const std::vector<double>* numMolPerVolForMat = G4DNAMolecularMaterial::Instance()->GetNumMolPerVolTableFor(currentMaterial);
                fMaterialMolPerVol[materialName] = numMolPerVolForMat;
            }
        }
    }
}
 
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
 
void G4DNAModelInterface::InsertModelInTable(const G4String& matName, const G4String& pName)
{
    // To insert the model(s) in the table Material Particule -> Model(s)
 
    // First, we need to check if the current material has already been inserted in the table.
    // This is possible because of the composite material. We could add a component M1 and then try to add the independant M1 material.
    // This case must be avoided. Checking if M1 is already in the table is the way to avoid it.
    //
    // Chech if the current material and particle are already in the table.
    // If they are: do nothing.
    // If they are not: add the model(s)
    //
    // Check for the material
    if(fMaterialParticleModelTable.find(matName) == fMaterialParticleModelTable.end())
    {
        // Check for the particle
        if(fMaterialParticleModelTable[matName].find(pName) == fMaterialParticleModelTable[matName].end())
        {
            G4int modelNbForMaterial (0);
 
            // Loop on all models registered in the simulation to check:
            // 1- if they can be applied to the current material
            // 2- if they can be applied to the current particle
            for(std::size_t i=0, ie=fRegisteredModels.size(); i<ie; ++i)
            {
                // check if the model is correct for material and particle (previous 1 and 2)
                if(fRegisteredModels[i]->IsParticleExistingInModelForMaterial(pName, matName))
                {
                    // if yes then add the model in the map
                    fMaterialParticleModelTable[matName][pName].push_back(fRegisteredModels[i]);
 
                    // and add one to the "there is a model" material flag
                    ++modelNbForMaterial;
                }
            }
 
            // The model(s) applicable to the currently selected material should be in the map.
            // We check if there are several models for the material.
            if(modelNbForMaterial>1)
            {
                // If there are several models for a given material and particle couple it could be
                // because of the energy ranges. We will check if the energy ranges are coherent.
 
                // Get the models (vector)
                std::vector<G4VDNAModel*>& models = fMaterialParticleModelTable[matName][pName];
 
                // Declare a map to sort the limits (G4double) and a model "id" (G4int).
                // The model id is created on the fly here.
                // The idea is to fill a map with [limit] = counter. This map will be auto-sorted
                // and we will check by iterating on it that the counter order is maintained.
 
                // Delcare the map
                std::map<G4double, G4int, std::less<G4double> > sortMap;
 
                G4double smallDiff = 0.01 *eV;
 
                // Loop on all the model for the current couple
                // and fill a map with [lim] = modelNumber
                for(std::size_t ii=0, em=models.size(); ii<em; ++ii)
                {
                    G4double lowLim = models[ii]->GetLowELimit(matName, pName);
                    G4double highLim = models[ii]->GetHighELimit(matName, pName);
 
                    if(sortMap.find(lowLim) != sortMap.end() )
                    {
                        lowLim += smallDiff;
                    }
 
                    sortMap[lowLim] = (G4int)ii;
 
                    if(sortMap.find(highLim) != sortMap.end() )
                    {
                        highLim -= smallDiff;
                    }
 
                    sortMap[highLim] = (G4int)ii;
                }
 
                // The map has been created and ordered at this point.
                // We will check the map order.
 
                // Loop on the sortMap with iterator and check the order is correct.
                std::map<G4double, G4int>::iterator it = sortMap.begin();
 
                // First energy limit value
                G4double dummyLim = it->first - smallDiff;
 
                // Loop on all the models again.
                // The goal is to check if for each limit pairs we have the same model number
                // and that the upper and lower limit are consistent.
                for(std::size_t ii=0, eii=models.size(); ii<eii; ++ii)
                {
                    G4double lim1 = it->first - smallDiff;
                    G4int count1 = it->second;
 
                    // Iterate
                    ++it;
 
                    G4double lim2 = it->first + smallDiff;
                    G4int count2 = it->second;
 
                    // Iterate
                    ++it;
 
                    // Check model number and energy limit consistency
                    // std::abs(dummyLim - lim1) > 1.*eV because we cannot do (dummyLim != lim1)
                    // without experimenting precision loss. Therefore, the std::abs(...) > tolerance is the usual way of avoiding
                    // the issue.
                    if( (count1 != count2) || ( std::abs(dummyLim - lim1) > 1.*eV ) )
                    {
                        // Error
 
                        std::ostringstream oss;
                        oss<<"The material "<<matName<<" and the particle "<<pName;
                        oss<<" have several models registered for the "<<fName<<" interaction and their energy ranges ";
                        oss<<"do not match. \nEnergy ranges: \n";
 
                        for(std::size_t iii=0, eiii=models.size(); iii<eiii; ++iii)
                        {
                            oss<<models[iii]->GetName()<<"\n";
                            oss<<"low: "<<models[iii]->GetLowELimit(matName, pName)/eV<<" eV \n";
                            oss<<"high: "<<models[iii]->GetHighELimit(matName, pName)/eV<<" eV \n";
                        }
 
                        G4Exception("G4DNAModelManager::InsertModelInTable","em0006",
                                    FatalException, oss.str().c_str());
                        return; // to make some compilers happy
                    }
 
                    dummyLim = lim2;
                }
 
                // If we are here then everything was ok.
            }
            // no model for the material case
            else if(modelNbForMaterial==0)
            {
//                std::ostringstream oss;
//                oss<<"The material "<<matName<<" and the particle "<<pName;
//                oss<<" does not have any model registered for the "<<fName<<" interaction. ";
 
//                G4Exception("G4DNAModelManager::InsertModelInTable","em0006",
//                            FatalException, oss.str().c_str());
//                return; // to make some compilers happy
            }
        }
    }
}
 
G4VDNAModel *G4DNAModelInterface::GetDNAModel(const G4String &material, const G4String &particle, G4double ekin)
{
    // Output pointer
    G4VDNAModel* model = 0;
 
    // Get a reference to all the models for the couple (material and particle)
    std::vector<G4VDNAModel*>& models = fMaterialParticleModelTable[material][particle];
 
    // We must choose one of the model(s) accordingly to the particle energy and the model energy range(s)
 
    //G4bool isOneModelSelected = false;
 
    // Loop on all the models within the models vector and check if ekin is within the energy range.
    for(std::size_t i=0, ie=models.size(); i<ie; ++i)
    {
        // ekin is in the energy range: we select the model and stop the loop.
        if( ekin >= models[i]->GetLowELimit(material, particle)
                && ekin < models[i]->GetHighELimit(material, particle) )
        {
            // Select the model
            model = models[i];
 
            // Boolean flag
            //isOneModelSelected = true;
 
            // Quit the for loop
            break;
        }
 
        // ekin is not in the energy range: we continue the loop.
    }
 
//    // If no model was selected then fatal error
//    if(!isOneModelSelected)
//    {
//        G4String msg = "No model has ";
//        msg += ekin/eV;
//        msg += " eV in its energy range. Therefore nothing was selected.";
 
//        G4Exception("G4DNAModelManager::GetDNAModel","em0006",
//                    FatalException,
//                    msg);
//    }
 
    // Return a pointer to the selected model
    return model;
}
 
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
 
G4double G4DNAModelInterface::GetNumMoleculePerVolumeUnitForMaterial(const G4Material* mat)
{
    return fMaterialMolPerVol[mat->GetName()]->at(mat->GetIndex() );
}
 
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
 
G4double G4DNAModelInterface::GetNumMolPerVolUnitForComponentInComposite(const G4Material* component, const G4Material* composite)
{
    return fMaterialMolPerVol[component->GetName() ]->at(composite->GetIndex() );
}