G4ecpssrFormFactorMixsModel Class Reference

#include <G4ecpssrFormFactorMixsModel.hh>

Inheritance diagram for G4ecpssrFormFactorMixsModel:

Collaboration diagram for G4ecpssrFormFactorMixsModel:

Public Member Functions
	G4ecpssrFormFactorMixsModel ()
virtual	~G4ecpssrFormFactorMixsModel ()
G4double	CalculateM1CrossSection (G4int zTarget, G4double massIncident, G4double energyIncident)
G4double	CalculateM2CrossSection (G4int zTarget, G4double massIncident, G4double energyIncident)
G4double	CalculateM3CrossSection (G4int zTarget, G4double massIncident, G4double energyIncident)
G4double	CalculateM4CrossSection (G4int zTarget, G4double massIncident, G4double energyIncident)
G4double	CalculateM5CrossSection (G4int zTarget, G4double massIncident, G4double energyIncident)
Public Member Functions inherited from G4VecpssrMiModel
	G4VecpssrMiModel ()
virtual	~G4VecpssrMiModel ()

Private Member Functions
G4double	CalculateMiCrossSection (G4int zTarget, G4double massIncident, G4double energyIncident, G4int mShellId)
	G4ecpssrFormFactorMixsModel (const G4ecpssrFormFactorMixsModel &)
G4ecpssrFormFactorMixsModel &	operator= (const G4ecpssrFormFactorMixsModel &right)

Private Attributes
G4VDataSetAlgorithm *	interpolation
std::vector< std::map< G4int, G4VEMDataSet * > >	protonMiXsVector
std::vector< std::map< G4int, G4VEMDataSet * > >	alphaMiXsVector
std::map< G4int, G4VEMDataSet *>	protonM1DataSetMap
std::map< G4int, G4VEMDataSet *>	protonM2DataSetMap
std::map< G4int, G4VEMDataSet *>	protonM3DataSetMap
std::map< G4int, G4VEMDataSet *>	protonM4DataSetMap
std::map< G4int, G4VEMDataSet *>	protonM5DataSetMap
std::map< G4int, G4VEMDataSet *>	alphaM1DataSetMap
std::map< G4int, G4VEMDataSet *>	alphaM2DataSetMap
std::map< G4int, G4VEMDataSet *>	alphaM3DataSetMap
std::map< G4int, G4VEMDataSet *>	alphaM4DataSetMap
std::map< G4int, G4VEMDataSet *>	alphaM5DataSetMap

Detailed Description

Definition at line 47 of file G4ecpssrFormFactorMixsModel.hh.

Constructor & Destructor Documentation

G4ecpssrFormFactorMixsModel() [1/2]

G4ecpssrFormFactorMixsModel::G4ecpssrFormFactorMixsModel

(

)

Definition at line 53 of file G4ecpssrFormFactorMixsModel.cc.

{ 
  interpolation = new G4LinInterpolation();

  for (G4int i=62; i<93; i++) 
  {
      protonM1DataSetMap[i] = new G4EMDataSet(i,interpolation);
      protonM1DataSetMap[i]->LoadData("pixe/ecpssr/proton/m1-");
        
      protonM2DataSetMap[i] = new G4EMDataSet(i,interpolation);
      protonM2DataSetMap[i]->LoadData("pixe/ecpssr/proton/m2-");
        
      protonM3DataSetMap[i] = new G4EMDataSet(i,interpolation);
      protonM3DataSetMap[i]->LoadData("pixe/ecpssr/proton/m3-");
        
      protonM4DataSetMap[i] = new G4EMDataSet(i,interpolation);
      protonM4DataSetMap[i]->LoadData("pixe/ecpssr/proton/m4-");
        
      protonM5DataSetMap[i] = new G4EMDataSet(i,interpolation);
      protonM5DataSetMap[i]->LoadData("pixe/ecpssr/proton/m5-");
  }

  protonMiXsVector.push_back(protonM1DataSetMap);
  protonMiXsVector.push_back(protonM2DataSetMap);
  protonMiXsVector.push_back(protonM3DataSetMap);
  protonMiXsVector.push_back(protonM4DataSetMap);
  protonMiXsVector.push_back(protonM5DataSetMap);


  for (G4int i=62; i<93; i++) 
  {
      alphaM1DataSetMap[i] = new G4EMDataSet(i,interpolation);
      alphaM1DataSetMap[i]->LoadData("pixe/ecpssr/alpha/m1-");
         
      alphaM2DataSetMap[i] = new G4EMDataSet(i,interpolation);
      alphaM2DataSetMap[i]->LoadData("pixe/ecpssr/alpha/m2-");
         
      alphaM3DataSetMap[i] = new G4EMDataSet(i,interpolation);
      alphaM3DataSetMap[i]->LoadData("pixe/ecpssr/alpha/m3-");
         
      alphaM4DataSetMap[i] = new G4EMDataSet(i,interpolation);
      alphaM4DataSetMap[i]->LoadData("pixe/ecpssr/alpha/m4-");
         
      alphaM5DataSetMap[i] = new G4EMDataSet(i,interpolation);
      alphaM5DataSetMap[i]->LoadData("pixe/ecpssr/alpha/m5-");

  }

  alphaMiXsVector.push_back(alphaM1DataSetMap);
  alphaMiXsVector.push_back(alphaM2DataSetMap);
  alphaMiXsVector.push_back(alphaM3DataSetMap);
  alphaMiXsVector.push_back(alphaM4DataSetMap);
  alphaMiXsVector.push_back(alphaM5DataSetMap);



}

~G4ecpssrFormFactorMixsModel()

G4ecpssrFormFactorMixsModel::~G4ecpssrFormFactorMixsModel ( )

virtual

Definition at line 113 of file G4ecpssrFormFactorMixsModel.cc.

{ 
  protonM1DataSetMap.clear();
  alphaM1DataSetMap.clear();
  
  protonM2DataSetMap.clear();
  alphaM2DataSetMap.clear();
  
  protonM3DataSetMap.clear();
  alphaM3DataSetMap.clear();
  
  protonM4DataSetMap.clear();
  alphaM4DataSetMap.clear();
  
  protonM5DataSetMap.clear();
  alphaM5DataSetMap.clear();
  
  delete interpolation;
}

G4ecpssrFormFactorMixsModel() [2/2]

G4ecpssrFormFactorMixsModel::G4ecpssrFormFactorMixsModel ( const G4ecpssrFormFactorMixsModel &  )

private

Member Function Documentation

CalculateM1CrossSection()

G4double G4ecpssrFormFactorMixsModel::CalculateM1CrossSection ( G4int  zTarget, G4double  massIncident, G4double  energyIncident  )

virtual

Implements G4VecpssrMiModel.

Definition at line 167 of file G4ecpssrFormFactorMixsModel.cc.

{

  // mShellId
  return  CalculateMiCrossSection (zTarget, massIncident, energyIncident, 1); 

}

Here is the call graph for this function:

CalculateM2CrossSection()

G4double G4ecpssrFormFactorMixsModel::CalculateM2CrossSection ( G4int  zTarget, G4double  massIncident, G4double  energyIncident  )

virtual

Implements G4VecpssrMiModel.

Definition at line 177 of file G4ecpssrFormFactorMixsModel.cc.

{

  // mShellId
  return  CalculateMiCrossSection (zTarget, massIncident, energyIncident, 2); 

  /*

  G4Proton* aProton = G4Proton::Proton();
  G4Alpha* aAlpha = G4Alpha::Alpha();  
  G4double sigma = 0;

  if (energyIncident > 0.1*MeV && energyIncident < 10*MeV && zTarget < 93 && zTarget > 61) {

    if (massIncident == aProton->GetPDGMass())
      {      
    sigma = protonM2DataSetMap[zTarget]->FindValue(energyIncident/MeV);  
        if (sigma !=0 && energyIncident > protonM2DataSetMap[zTarget]->GetEnergies(0).back()*MeV) return 0.;
      }
    else if (massIncident == aAlpha->GetPDGMass())
      {
        sigma = alphaM2DataSetMap[zTarget]->FindValue(energyIncident/MeV); 
        if (sigma !=0 && energyIncident > alphaM2DataSetMap[zTarget]->GetEnergies(0).back()*MeV) return 0.;
      }
    else
      { 
    sigma = 0.;
      }
  }
  
  // sigma is in internal units: it has been converted from 
  // the input file in barns bt the EmDataset
  return sigma;
  */
}

Here is the call graph for this function:

CalculateM3CrossSection()

G4double G4ecpssrFormFactorMixsModel::CalculateM3CrossSection ( G4int  zTarget, G4double  massIncident, G4double  energyIncident  )

virtual

Implements G4VecpssrMiModel.

Definition at line 215 of file G4ecpssrFormFactorMixsModel.cc.

{

  return  CalculateMiCrossSection (zTarget, massIncident, energyIncident, 3); 
  /*


  G4Proton* aProton = G4Proton::Proton();
  G4Alpha* aAlpha = G4Alpha::Alpha();  
  G4double sigma = 0;

  if (energyIncident > 0.1*MeV && energyIncident < 10*MeV && zTarget < 93 && zTarget > 61) {

    if (massIncident == aProton->GetPDGMass())
      {      
    sigma = protonM3DataSetMap[zTarget]->FindValue(energyIncident/MeV);  
        if (sigma !=0 && energyIncident > protonM3DataSetMap[zTarget]->GetEnergies(0).back()*MeV) return 0.;
      }
    else if (massIncident == aAlpha->GetPDGMass())
      {
        sigma = alphaM3DataSetMap[zTarget]->FindValue(energyIncident/MeV); 
        if (sigma !=0 && energyIncident > alphaM3DataSetMap[zTarget]->GetEnergies(0).back()*MeV) return 0.;
      }
    else
      { 
    sigma = 0.;
      }
  }
  
  // sigma is in internal units: it has been converted from 
  // the input file in barns bt the EmDataset
  return sigma;
  */
}

Here is the call graph for this function:

CalculateM4CrossSection()

G4double G4ecpssrFormFactorMixsModel::CalculateM4CrossSection ( G4int  zTarget, G4double  massIncident, G4double  energyIncident  )

virtual

Implements G4VecpssrMiModel.

Definition at line 252 of file G4ecpssrFormFactorMixsModel.cc.

{

  return  CalculateMiCrossSection (zTarget, massIncident, energyIncident, 4); 
  /*
  G4Proton* aProton = G4Proton::Proton();
  G4Alpha* aAlpha = G4Alpha::Alpha();  
  G4double sigma = 0;

  if (energyIncident > 0.1*MeV && energyIncident < 10*MeV && zTarget < 93 && zTarget > 61) {

    if (massIncident == aProton->GetPDGMass())
      {      
    sigma = protonM3DataSetMap[zTarget]->FindValue(energyIncident/MeV);  
        if (sigma !=0 && energyIncident > protonM3DataSetMap[zTarget]->GetEnergies(0).back()*MeV) return 0.;
      }
    else if (massIncident == aAlpha->GetPDGMass())
      {
        sigma = alphaM3DataSetMap[zTarget]->FindValue(energyIncident/MeV); 
        if (sigma !=0 && energyIncident > alphaM3DataSetMap[zTarget]->GetEnergies(0).back()*MeV) return 0.;
      }
    else
      { 
    sigma = 0.;
      }
  }
  
  // sigma is in internal units: it has been converted from 
  // the input file in barns bt the EmDataset
  return sigma;
  */
}

Here is the call graph for this function:

CalculateM5CrossSection()

G4double G4ecpssrFormFactorMixsModel::CalculateM5CrossSection ( G4int  zTarget, G4double  massIncident, G4double  energyIncident  )

virtual

Implements G4VecpssrMiModel.

Definition at line 287 of file G4ecpssrFormFactorMixsModel.cc.

{

  return  CalculateMiCrossSection (zTarget, massIncident, energyIncident, 5); 
  /*
  G4Proton* aProton = G4Proton::Proton();
  G4Alpha* aAlpha = G4Alpha::Alpha();  
  G4double sigma = 0;

  if (energyIncident > 0.1*MeV && energyIncident < 10*MeV && zTarget < 93 && zTarget > 61) {

    if (massIncident == aProton->GetPDGMass())
      {      
    sigma = protonM3DataSetMap[zTarget]->FindValue(energyIncident/MeV);  
        if (sigma !=0 && energyIncident > protonM3DataSetMap[zTarget]->GetEnergies(0).back()*MeV) return 0.;
      }
    else if (massIncident == aAlpha->GetPDGMass())
      {
        sigma = alphaM3DataSetMap[zTarget]->FindValue(energyIncident/MeV); 
        if (sigma !=0 && energyIncident > alphaM3DataSetMap[zTarget]->GetEnergies(0).back()*MeV) return 0.;
      }
    else
      { 
    sigma = 0.;
      }
  }
  
  // sigma is in internal units: it has been converted from 
  // the input file in barns bt the EmDataset
  return sigma;
  */
}

Here is the call graph for this function:

CalculateMiCrossSection()

G4double G4ecpssrFormFactorMixsModel::CalculateMiCrossSection ( G4int  zTarget, G4double  massIncident, G4double  energyIncident, G4int  mShellId  )

private

Definition at line 135 of file G4ecpssrFormFactorMixsModel.cc.

{
  G4Proton* aProton = G4Proton::Proton();
  G4Alpha* aAlpha = G4Alpha::Alpha();  
  G4double sigma = 0;
  G4int mShellIndex = mShellId -1;

  if (energyIncident > 0.1*MeV && energyIncident < 10*MeV && zTarget < 93 && zTarget > 61) {

    if (massIncident == aProton->GetPDGMass())
      {      
    sigma = protonMiXsVector[mShellIndex][zTarget]->FindValue(energyIncident/MeV);  
        if (sigma !=0 && energyIncident > protonMiXsVector[mShellIndex][zTarget]->GetEnergies(0).back()*MeV) return 0.;
      }
    else if (massIncident == aAlpha->GetPDGMass())
      {
        sigma = alphaMiXsVector[mShellIndex][zTarget]->FindValue(energyIncident/MeV); 
        if (sigma !=0 && energyIncident > alphaMiXsVector[mShellIndex][zTarget]->GetEnergies(0).back()*MeV) return 0.;
      }
    else
      { 
    sigma = 0.;
      }
  }
  
  // sigma is in internal units: it has been converted from 
  // the input file in barns bt the EmDataset
  return sigma;
}

Here is the call graph for this function:

Here is the caller graph for this function:

operator=()

G4ecpssrFormFactorMixsModel& G4ecpssrFormFactorMixsModel::operator= ( const G4ecpssrFormFactorMixsModel &  right )

private

Member Data Documentation

alphaM1DataSetMap

std::map< G4int , G4VEMDataSet* > G4ecpssrFormFactorMixsModel::alphaM1DataSetMap

private

Definition at line 79 of file G4ecpssrFormFactorMixsModel.hh.

alphaM2DataSetMap

std::map< G4int , G4VEMDataSet* > G4ecpssrFormFactorMixsModel::alphaM2DataSetMap

private

Definition at line 80 of file G4ecpssrFormFactorMixsModel.hh.

alphaM3DataSetMap

std::map< G4int , G4VEMDataSet* > G4ecpssrFormFactorMixsModel::alphaM3DataSetMap

private

Definition at line 81 of file G4ecpssrFormFactorMixsModel.hh.

alphaM4DataSetMap

std::map< G4int , G4VEMDataSet* > G4ecpssrFormFactorMixsModel::alphaM4DataSetMap

private

Definition at line 82 of file G4ecpssrFormFactorMixsModel.hh.

alphaM5DataSetMap

std::map< G4int , G4VEMDataSet* > G4ecpssrFormFactorMixsModel::alphaM5DataSetMap

private

Definition at line 83 of file G4ecpssrFormFactorMixsModel.hh.

alphaMiXsVector

std::vector< std::map<G4int,G4VEMDataSet*> > G4ecpssrFormFactorMixsModel::alphaMiXsVector

private

Definition at line 71 of file G4ecpssrFormFactorMixsModel.hh.

interpolation

G4VDataSetAlgorithm* G4ecpssrFormFactorMixsModel::interpolation

private

Definition at line 68 of file G4ecpssrFormFactorMixsModel.hh.

protonM1DataSetMap

std::map< G4int , G4VEMDataSet* > G4ecpssrFormFactorMixsModel::protonM1DataSetMap

private

Definition at line 73 of file G4ecpssrFormFactorMixsModel.hh.

protonM2DataSetMap

std::map< G4int , G4VEMDataSet* > G4ecpssrFormFactorMixsModel::protonM2DataSetMap

private

Definition at line 74 of file G4ecpssrFormFactorMixsModel.hh.

protonM3DataSetMap

std::map< G4int , G4VEMDataSet* > G4ecpssrFormFactorMixsModel::protonM3DataSetMap

private

Definition at line 75 of file G4ecpssrFormFactorMixsModel.hh.

protonM4DataSetMap

std::map< G4int , G4VEMDataSet* > G4ecpssrFormFactorMixsModel::protonM4DataSetMap

private

Definition at line 76 of file G4ecpssrFormFactorMixsModel.hh.

protonM5DataSetMap

std::map< G4int , G4VEMDataSet* > G4ecpssrFormFactorMixsModel::protonM5DataSetMap

private

Definition at line 77 of file G4ecpssrFormFactorMixsModel.hh.

protonMiXsVector

std::vector< std::map<G4int,G4VEMDataSet*> > G4ecpssrFormFactorMixsModel::protonMiXsVector

private

Definition at line 70 of file G4ecpssrFormFactorMixsModel.hh.

---

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

• G4ecpssrFormFactorMixsModel.hh
• G4ecpssrFormFactorMixsModel.cc