def test_problem_sim_v250(self):
if is_bad_file(self.filepath_problem_sim_v250):
raise SkipTest
# .sim
file = File.File()
file.readFromFilepath(self.filepath_problem_sim_v250)
self.assertEqual(self.filepath_problem_sim_v250, file._filepath)
self.assertEqual(0, file._numberSimulations)
option_simulation_data = file.getOptionSimulationData()
version = option_simulation_data.getVersion()
self.assertEqual(Version.VERSION_2_50, version)
simulation_options = option_simulation_data.getSimulationOptions()
number_electrons = simulation_options.getNumberElectrons()
self.assertEqual(200, number_electrons)
incident_energy_keV = simulation_options.getIncidentEnergy_keV()
self.assertAlmostEqual(1.0, incident_energy_keV)
toa_deg = simulation_options.getTOA_deg()
self.assertAlmostEqual(40.0, toa_deg)
number_xray_layers = simulation_options.getNumberXRayLayers()
self.assertEqual(500, number_xray_layers)
if is_bad_file(self.filepath_good_sim_v251):
raise SkipTest
# .sim
file = File.File()
file.readFromFilepath(self.filepath_good_sim_v251)
self.assertEqual(self.filepath_good_sim_v251, file._filepath)
self.assertEqual(0, file._numberSimulations)
option_simulation_data = file.getOptionSimulationData()
version = option_simulation_data.getVersion()
self.assertEqual(Version.VERSION_2_51, version)
simulation_options = option_simulation_data.getSimulationOptions()
number_electrons = simulation_options.getNumberElectrons()
self.assertEqual(200, number_electrons)
incident_energy_keV = simulation_options.getIncidentEnergy_keV()
self.assertAlmostEqual(1.0, incident_energy_keV)
toa_deg = simulation_options.getTOA_deg()
self.assertAlmostEqual(40.0, toa_deg)
number_xray_layers = simulation_options.getNumberXRayLayers()
self.assertEqual(500, number_xray_layers)
def test_CasNoPsfs(self):
"""
Tests for method `CasNoPsfs`.
"""
filepath = resource_filename(__name__, "../../../test_data/casino3.x/PSFs/SiN_woPSFs_bG_T200nm.cas")
if is_bad_file(filepath):
raise SkipTest(filepath)
casinoFile = File.File(filepath)
versionRef = Version.SIM_OPTIONS_VERSION_3_3_0_0
versionStrRef = "3.3.0.0"
version = casinoFile.getVersion()
self.assertEqual(versionRef, version)
versionStr = casinoFile._extractVersionString(version)
self.assertEqual(versionStrRef, versionStr)
optionsAdvancedPsfsSettings = casinoFile.getOptions().getOptionsAdvancedPsfsSettings()
self.assertEqual(False, optionsAdvancedPsfsSettings.isGeneratingPSFs())
scanPointResults = casinoFile.getScanPointResults()
self.assertEqual(False, scanPointResults[0].isPsfs())
self.assertEqual(None, scanPointResults[0].getPointSpreadFunctionMatrix())
def setUp(self):
unittest.TestCase.setUp(self)
filepath = resource_filename(__name__, "../../test_data/casino3.x/SiSubstrateThreeLines_Points.sim")
if is_bad_file(filepath):
raise SkipTest
self.file = open(filepath, 'rb')
def test_read(self):
if is_bad_file(self.filepathSim):
raise SkipTest
file = open(self.filepathSim, 'rb')
reader = OptionsMicro.OptionsMicro()
error = reader.read(file)
self.assertEqual(None, error)
self.assertEqual(30107002, reader._version)
self.assertEqual(0, reader.scanning_mode)
self.assertAlmostEqual(0.0, reader.X_plane_position)
self.assertAlmostEqual(1.0, reader.scanPtDist)
self.assertEqual(1, reader.keep_simulation_data)
reader = OptionsMicro.OptionsMicro()
file = open(self.filepathCas, 'rb')
error = reader.read(file)
self.assertEqual(None, error)
self.assertEqual(30107002, reader._version)
self.assertEqual(0, reader.scanning_mode)
self.assertAlmostEqual(0.0, reader.X_plane_position)
self.assertAlmostEqual(1.0, reader.scanPtDist)
self.assertEqual(1, reader.keep_simulation_data)
def test_read(self):
if is_bad_file(self.filepathCas):
raise SkipTest
file = open(self.filepathCas, 'rb')
file.seek(2012986)
results = RegionIntensityInfo.RegionIntensityInfo()
error = results.read(file)
self.assertEqual(None, error)
self.assertEqual(30105022, results._version)
self.assertAlmostEqual(0.0, results._energyIntensity)
self.assertEqual(1, results._regionID)
self.assertAlmostEqual(0.0, results._normalizedEnergyIntensity)
error = results.read(file)
self.assertEqual(None, error)
self.assertEqual(30105022, results._version)
self.assertAlmostEqual(0.0, results._energyIntensity)
self.assertEqual(2, results._regionID)
self.assertAlmostEqual(0.0, results._normalizedEnergyIntensity)
error = results.read(file)
self.assertEqual(None, error)
self.assertEqual(30105022, results._version)
self.assertAlmostEqual(7.268071702406E+05, results._energyIntensity)
self.assertEqual(3, results._regionID)
self.assertAlmostEqual(7.268071702406E-01, results._normalizedEnergyIntensity)
def test_getFileType(self):
if is_bad_file(self.filepathSim):
raise SkipTest
casinoFile = File.File(self.filepathSim)
type = casinoFile.getFileType()
self.assertEqual(File.SIMULATION_CONFIGURATIONS, type)
def test_init(self):
if is_bad_file(self.filepathSim):
raise SkipTest
casinoFile = File.File(self.filepathSim)
self.assertEqual(self.filepathSim, casinoFile.getFilepath())
def test_get_total_xray_intensities_1_esr(self):
if is_bad_file(self.filepath_cas_v251):
raise SkipTest
with open(self.filepath_cas_v251, 'rb') as file:
file.seek(0)
element = Element.Element()
# read the empty simulation data structure.
element.read(file, 500, self.version_2_51)
self.assertEqual(50193, file.tell())
# read the first simulation data structure.
element.read(file, 500, self.version_2_51)
self.assertEqual(100638, file.tell())
intensities_ref = {}
intensities_ref[ATOMLINE_KA1] = 9.269059346795805e-07
intensities_ref[ATOMLINE_KA2] = 4.662984097246555e-07
intensities_ref[ATOMLINE_KB1] = 1.355707793206891e-08
intensities = element.get_total_xray_intensities_1_esr()
self.assertEqual(len(intensities_ref), len(intensities))
for atomic_line in intensities:
with self.subTest(atomic_line=atomic_line):
self.assertAlmostEqual(intensities_ref[atomic_line]*1.0e6, intensities[atomic_line]*1.0e6)
def test__readVersion(self):
if is_bad_file(self.filepathSim):
raise SkipTest
casinoFile = File.File(self.filepathSim)
file = casinoFile._open(self.filepathSim)
version = casinoFile._readVersion(file)
self.assertEqual(30107002, version)
def test_read(self):
if is_bad_file(self.filepathCas):
raise SkipTest
file = open(self.filepathSim, 'rb')
file.seek(7159)
element = Element.Element()
element.read(file)
self.assertEqual(30105010, element._version)
self.assertEqual(0, element._elementID)
self.assertAlmostEqual(0.660569621292935, element._weightFraction)
self.assertAlmostEqual(0.372901678657074, element._atomicFraction)
self.assertAlmostEqual(0.0, element._sigmaTElastic)
self.assertEqual(311, element._repetition)
self.assertEqual(6.0, element.Z)
self.assertEqual('C', element.Nom)
self.assertAlmostEqual(2.62, element.Rho)
self.assertAlmostEqual(12.011, element.A)
self.assertAlmostEqual(0.0, element.J)
self.assertAlmostEqual(0.0, element.K_Gauvin)
self.assertAlmostEqual(-9.584629012423031e+36, element.K_Monsel)
self.assertAlmostEqual(1.0, element.ef)
self.assertAlmostEqual(7.000000000000E+07, element.kf)
self.assertAlmostEqual(15.0, element.ep)
for index in range(3):
self.assertAlmostEqual(0.0, element.Int_PRZ[index])
self.assertAlmostEqual(0.0, element.Int_PRZ_ABS[index])
def test_readTextFile(self):
if is_bad_file(self.filepath_Cu_K):
raise SkipTest
xrayRadialReader = XrayRadialReader.XrayRadialReader()
xrayRadialReader.readTextFile(self.filepath_Cu_K)
xrayRadial = xrayRadialReader.getData('Cu', XrayRadialReader.K)
self.assertEqual(XrayRadialReader.K, xrayRadial.getLine())
self.assertEqual("Cu", xrayRadial.getElementSymbol())
dataLabelsRef = [XrayRadial.DISTANCE_nm, XrayRadial.INTENSITY, XrayRadial.INTENSITY_ABSORBED]
self.assertEqual(dataLabelsRef, xrayRadial.getDataLabels())
distances_nm = xrayRadial.getDistances_nm()
self.assertEqual(500, len(distances_nm))
self.assertAlmostEqual(0.0, distances_nm[0])
self.assertAlmostEqual(953.396625, distances_nm[-1])
intensities = xrayRadial.getIntensities()
self.assertEqual(500, len(intensities))
self.assertAlmostEqual(111.260633, intensities[0])
self.assertAlmostEqual(0.000128, intensities[-1])
intensitiesAbsorbed = xrayRadial.getIntensitiesAbsorbed()
self.assertEqual(500, len(intensitiesAbsorbed))
self.assertAlmostEqual(111.007526, intensitiesAbsorbed[0])
self.assertAlmostEqual(0.000127, intensitiesAbsorbed[-1])
def test_read(self):
if is_bad_file(self.filepathSim):
raise SkipTest
file = open(self.filepathSim, 'rb')
file.seek(6560)
region = Region.Region()
region.read(file)
self.assertEqual(30107003, region._version)
self.assertAlmostEqual(50.0, region._carrierDiffusionLength)
self.assertEqual(1, region._numberElements)
self.assertAlmostEqual(2.33, region.Rho)
self.assertAlmostEqual(-1.0, region._workFunction)
self.assertAlmostEqual(-1.0, region._averagePlasmonEnergy)
self.assertEqual(1, region.ID)
self.assertEqual(0, region.Substrate)
self.assertEqual(0, region.User_Density)
self.assertEqual(0, region.User_Composition)
self.assertEqual(0, region._checked)
self.assertEqual("SiSubtrate", region.Name)
self.assertEqual(1, region._numberSampleObjects)
self.assertEqual(1, region._sampleObjectIDs[0])
self.assertAlmostEqual(0.0, region._mollerInit)
self.assertAlmostEqual(0.235, region._triangleColor_X)
self.assertAlmostEqual(0.235, region._triangleColor_Y)
self.assertAlmostEqual(1.0, region._triangleColor_Z)
self.assertEqual("Si", region._chemicalName)
def test_read(self):
if is_bad_file(self.filepathSim):
raise SkipTest
file = open(self.filepathSim, 'rb')
reader = OptionsDist.OptionsDist()
error = reader.read(file)
self.assertEqual(None, error)
self.assertEqual(30107002, reader._version)
self.assertAlmostEqual(1.0, reader.DenrMax / OptionsDist.autoFlag)
self.assertAlmostEqual(1000.0, reader.DEposCyl_Z)
self.assertEqual(0, reader.DEposCyl_Z_Log)
self.assertEqual(OptionsDist.DIST_DEPOS_POSITION_ABSOLUTE, reader.DEpos_Position)
reader = OptionsDist.OptionsDist()
file = open(self.filepathCas, 'rb')
error = reader.read(file)
self.assertEqual(None, error)
self.assertEqual(30107002, reader._version)
self.assertAlmostEqual(1.0, reader.DenrMax / OptionsDist.autoFlag)
self.assertAlmostEqual(1000.0, reader.DEposCyl_Z)
self.assertEqual(0, reader.DEposCyl_Z_Log)
self.assertEqual(OptionsDist.DIST_DEPOS_POSITION_ABSOLUTE, reader.DEpos_Position)
def testReadCasFile(self):
if is_bad_file(self.filepathSim):
raise SkipTest
casinoFile = File.File(self.filepathCas)
casinoFile.open()
self.assertEqual(30107002, casinoFile._version)
self.assertEqual(1, casinoFile._numberSimulations)
def test_read_StringIO(self):
if is_bad_file(self.filepathCas):
raise SkipTest
f = open(self.filepathCas, 'rb')
file = BytesIO(f.read())
file.mode = 'rb'
f.close()
self._read_tests(file)
def test_read_StringIO(self):
if is_bad_file(self.filepathSim):
raise SkipTest
f = open(self.filepathSim, 'rb')
file = BytesIO(f.read())
file.mode = 'rb'
f.close()
self._read_tests(file, self.version_2_45)
def test_read(self):
if is_bad_file(self.filepathSim):
raise SkipTest
file = open(self.filepathSim, 'rb')
reader = SampleReader.SampleReader()
error = reader.read(file)
self.assertEqual(None, error)
self.assertEqual(30107002, reader._version)
if is_bad_file(self.filepathCas):
raise SkipTest
file = open(self.filepathCas, 'rb')
reader = SampleReader.SampleReader()
error = reader.read(file)
self.assertEqual(None, error)
self.assertEqual(30107002, reader._version)
def test_read(self):
if is_bad_file(self.filepathSim):
raise SkipTest
file = open(self.filepathSim, 'rb')
file.seek(6536)
regionOptions = RegionOptions.RegionOptions()
regionOptions.read(file)
self.assertEqual(8, regionOptions._numberRegions)
def test_read_StringIO(self):
if is_bad_file(self.filepathSim):
raise SkipTest
f = open(self.filepathSim, 'rb')
buf = BytesIO(f.read())
buf.mode = 'rb'
f.close()
self._read_tests(buf)
def testGetTotalXrayIntensities(self):
if is_bad_file(self.filepathCas):
raise SkipTest
# Single region
f = open(self.filepathCas, 'rb')
f.seek(98348)
simulation_data = SimulationData.SimulationData()
simulation_data.read(f)
f.close()
intensities = simulation_data.getTotalXrayIntensities()
self.assertAlmostEqual(2538.63, intensities[5][LINE_K][GENERATED], 2)
self.assertAlmostEqual(344.49, intensities[5][LINE_K][EMITTED], 2)
self.assertAlmostEqual(111.30, intensities[6][LINE_K][GENERATED], 2)
self.assertAlmostEqual(46.88, intensities[6][LINE_K][EMITTED], 2)
# Multiple regions
if is_bad_file(self.filepathCas_nicr):
raise SkipTest
f = open(self.filepathCas_nicr, 'rb')
f.seek(98348)
simulation_data = SimulationData.SimulationData()
simulation_data.read(f)
f.close()
intensities = simulation_data.getTotalXrayIntensities()
self.assertAlmostEqual(0.76, intensities[79][LINE_M][GENERATED], 2)
self.assertAlmostEqual(0.52, intensities[79][LINE_M][EMITTED], 2)
self.assertAlmostEqual(293.88, intensities[24][LINE_K][GENERATED], 2)
self.assertAlmostEqual(290.78, intensities[24][LINE_K][EMITTED], 2)
self.assertAlmostEqual(712.32, intensities[24][LINE_L][GENERATED], 2)
self.assertAlmostEqual(430.56, intensities[24][LINE_L][EMITTED], 2)
self.assertAlmostEqual(6.62, intensities[28][LINE_K][GENERATED], 2)
self.assertAlmostEqual(6.53, intensities[28][LINE_K][EMITTED], 2)
self.assertAlmostEqual(1115.51, intensities[28][LINE_L][GENERATED], 2)
self.assertAlmostEqual(457.79, intensities[28][LINE_L][EMITTED], 2)
self.assertAlmostEqual(1.57, intensities[14][LINE_K][GENERATED], 2)
self.assertAlmostEqual(1.22, intensities[14][LINE_K][EMITTED], 2)
def setUp(self):
unittest.TestCase.setUp(self)
resultsPath = resource_filename(__name__, "../../../test_data/casino3.x/createImage")
self._casBinnedFilepath = os.path.join(resultsPath, "Au_C_thin_1nm_Inside_100ke_binned.cas")
if is_bad_file(self._casBinnedFilepath):
raise SkipTest()
self._casAllFilepath = os.path.join(resultsPath, "Au_C_thin_1nm_Inside_100ke_all.cas")
self._imageBinned = IntensityImage.IntensityImage(self._casBinnedFilepath)
def test__readExtension(self):
if is_bad_file(self.filepathSim):
raise SkipTest
casinoFile = File.File(self.filepathSim)
file = casinoFile._open(self.filepathSim)
extension = casinoFile._readExtension(file)
self.assertEqual(File.SIMULATION_CONFIGURATIONS, extension)
file = open(self.filepathCas, 'rb')
extension = casinoFile._readExtension(file)
self.assertEqual(File.SIMULATION_RESULTS, extension)
def test_getLine(self):
if is_bad_file(self.filepath_Cu_K):
raise SkipTest
xrayRadialReader = XrayRadialReader.XrayRadialReader()
xrayRadialReader.readTextFile(self.filepath_Cu_K)
xrayRadial = xrayRadialReader.getData('Cu', XrayRadialReader.K)
self.assertEqual(XrayRadialReader.K, xrayRadial.getLine())
if is_bad_file(self.filepath_Cu_L):
raise SkipTest
xrayRadialReader = XrayRadialReader.XrayRadialReader()
xrayRadialReader.readTextFile(self.filepath_Cu_L)
xrayRadial = xrayRadialReader.getData('Cu', XrayRadialReader.L)
self.assertEqual(XrayRadialReader.L, xrayRadial.getLine())
if is_bad_file(self.filepath_Au_M):
raise SkipTest
xrayRadialReader = XrayRadialReader.XrayRadialReader()
xrayRadialReader.readTextFile(self.filepath_Au_M)
xrayRadial = xrayRadialReader.getData('Au', XrayRadialReader.M)
self.assertEqual(XrayRadialReader.M, xrayRadial.getLine())
def test_getElementSymbol(self):
if is_bad_file(self.filepath_Cu_K):
raise SkipTest
xrayRadialReader = XrayRadialReader.XrayRadialReader()
xrayRadialReader.readTextFile(self.filepath_Cu_K)
xrayRadial = xrayRadialReader.getData('Cu', XrayRadialReader.K)
self.assertEqual("Cu", xrayRadial.getElementSymbol())
if is_bad_file(self.filepath_Cu_L):
raise SkipTest
xrayRadialReader = XrayRadialReader.XrayRadialReader()
xrayRadialReader.readTextFile(self.filepath_Cu_L)
xrayRadial = xrayRadialReader.getData('Cu', XrayRadialReader.L)
self.assertEqual("Cu", xrayRadial.getElementSymbol())
if is_bad_file(self.filepath_Au_M):
raise SkipTest
xrayRadialReader = XrayRadialReader.XrayRadialReader()
xrayRadialReader.readTextFile(self.filepath_Au_M)
xrayRadial = xrayRadialReader.getData('Au', XrayRadialReader.M)
self.assertEqual("Au", xrayRadial.getElementSymbol())
def test_skipReadingData(self):
if is_bad_file(self.filepathCas):
raise SkipTest
file = File.File()
file.readFromFilepath(self.filepathCas, isSkipReadingData=False)
trajectories_data = file.getResultsFirstSimulation().getTrajectoriesData()
self.assertEqual(221, trajectories_data._numberTrajectories)
self.assertEqual(89, trajectories_data._trajectories[0].NbElec)
self.assertEqual(89, len(trajectories_data._trajectories[0]._scatteringEvents))
event = trajectories_data._trajectories[0]._scatteringEvents[0]
self.assertAlmostEqual(-2.903983831406E+00, event.X)
self.assertAlmostEqual(-3.020418643951E+00, event.Y)
self.assertAlmostEqual(0.0, event.Z)
self.assertAlmostEqual(4.000000000000E+00, event.E)
self.assertEqual(0, event.Intersect)
self.assertEqual(0, event.id)
file = File.File()
file.readFromFilepath(self.filepathCas, isSkipReadingData=True)
trajectories_data = file.getResultsFirstSimulation().getTrajectoriesData()
self.assertEqual(221, trajectories_data._numberTrajectories)
self.assertEqual(89, trajectories_data._trajectories[0].NbElec)
self.assertEqual(0, len(trajectories_data._trajectories[0]._scatteringEvents))
simulation_results = file.getResultsFirstSimulation().getSimulationResults()
self.assertEqual(1, simulation_results.BE_Intensity_Size)
self.assertEqual(3.950000000000E-02, simulation_results.BE_Intensity[0])
element = simulation_results._elementIntensityList[0]
self.assertEqual("B", element.Name)
self.assertAlmostEqual(3.444919288026E+02, element.IntensityK[0])
element = simulation_results._elementIntensityList[1]
self.assertEqual("C", element.Name)
self.assertAlmostEqual(4.687551040349E+01, element.IntensityK[0])
self.assertEqual(1000, simulation_results.NbPointDZMax)
self.assertEqual(500, simulation_results.NbPointDENR)
self.assertEqual(500, simulation_results.NbPointDENT)
self.assertEqual(500, simulation_results.NbPointDRSR)
# self.assertEqual(0, simulationResults.NbPointDNCR)
self.assertEqual(50, simulation_results.NbPointDEpos_X)
self.assertEqual(50, simulation_results.NbPointDEpos_Y)
self.assertEqual(50, simulation_results.NbPointDEpos_Z)
self.assertAlmostEqual(1.608165461510E-02, simulation_results.DEpos_maxE)
self.assertEqual(91, simulation_results.NbPointDBANG)
self.assertEqual(91, simulation_results.NbPointDAngleVSEnergie)
def test_read(self):
if is_bad_file(self.filepathSim):
raise SkipTest
file = File.File()
file.readFromFilepath(self.filepathSim)
self.assertEqual(self.filepathSim, file._filepath)
self.assertEqual(0, file._numberSimulations)
file = File.File()
file.readFromFilepath(self.filepathCas)
self.assertEqual(self.filepathCas, file._filepath)
self.assertEqual(1, file._numberSimulations)
self.assertEqual(1, len(file._resultSimulationDataList))
def test_read(self):
options = SimulationOptions.SimulationOptions()
options._optionsDist.DEpos_Type = OptionsDist.DIST_DEPOS_TYPE_CARTESIAN
results = EnergyMatrix.EnergyMatrix(options, None)
if is_bad_file(self.filepathCas):
raise SkipTest
file = open(self.filepathCas, 'rb')
file.seek(4042541)
error = results.read(file)
self.assertEqual(None, error)
self.assertEqual(125000, results._numberElements)
self.assertEqual(4042541, results._startPosition)
self.assertEqual(4042541 + 125000 * 8, results._endPosition)
def test_read(self):
options = SimulationOptions.SimulationOptions()
options._optionsDist.DEpos_Type = OptionsDist.DIST_DEPOS_TYPE_CARTESIAN
results = DiffusedEnergyMatrix.DiffusedEnergyMatrix(options, None)
if is_bad_file(self.filepathCas):
raise SkipTest
file = open(self.filepathCas, 'rb')
file.seek(1012742)
error = results.read(file)
self.assertEqual(None, error)
self.assertEqual(30107000, results._version)
self.assertEqual(125000, results._numberElements)
self.assertEqual(1012762, results._startPosition)
self.assertEqual(2012806, results._endPosition)
def test_read(self):
if is_bad_file(self.filepathCas):
raise SkipTest
file = open(self.filepathCas, 'rb')
file.seek(4042617)
results = TrajectoryCollision.TrajectoryCollision()
error = results.read(file)
self.assertEqual(None, error)
self.assertAlmostEqual(-9.168622881064E-02, results._positionX)
self.assertAlmostEqual(-4.931083223782E-01, results._positionY)
self.assertAlmostEqual(-1.049980000000E+05, results._positionZ)
self.assertAlmostEqual(8.000000000000E-01, results._energy)
self.assertAlmostEqual(1.000000000000E+04, results._segmentLength)
self.assertEqual(3, results._collisionType)
self.assertEqual(-1, results._regionID)
def test_read(self):
if is_bad_file(self.filepathSim):
raise SkipTest
file = open(self.filepathSim, 'rb')
reader = OptionsAdvBackSet.OptionsAdvBackSet()
error = reader.read(file)
self.assertEqual(None, error)
self.assertEqual(30107002, reader._version)
self.assertEqual(False, reader.UseEnBack)
self.assertAlmostEqual(10.0, reader.WorkDist)
self.assertAlmostEqual(1.0, reader.DetectScaleX)
self.assertAlmostEqual(1.0, reader.DetectScaleY)
self.assertEqual(False, reader.ValidMatrix)
self.assertAlmostEqual(0.0, reader.BEMin_Angle)
self.assertAlmostEqual(0.0, reader.BEMax_Angle)
self.assertAlmostEqual(0.0, reader.EFilterMax)
self.assertAlmostEqual(0.0, reader.EFilterMin)
for i in range(101):
self.assertAlmostEqual(1.0, reader.EFilterVal[i])
self.assertEqual(0, reader.FEFilter)
reader = OptionsAdvBackSet.OptionsAdvBackSet()
file = open(self.filepathCas, 'rb')
error = reader.read(file)
self.assertEqual(None, error)
self.assertEqual(30107002, reader._version)
self.assertEqual(False, reader.UseEnBack)
self.assertAlmostEqual(10.0, reader.WorkDist)
self.assertAlmostEqual(1.0, reader.DetectScaleX)
self.assertAlmostEqual(1.0, reader.DetectScaleY)
self.assertEqual(False, reader.ValidMatrix)
self.assertAlmostEqual(0.0, reader.BEMin_Angle)
self.assertAlmostEqual(0.0, reader.BEMax_Angle)
self.assertAlmostEqual(0.0, reader.EFilterMax)
self.assertAlmostEqual(0.0, reader.EFilterMin)
for i in range(101):
self.assertAlmostEqual(1.0, reader.EFilterVal[i])
self.assertEqual(0, reader.FEFilter)
def test_read(self):
if is_bad_file(self.filepathCas):
raise SkipTest
file = open(self.filepathCas, 'rb')
file.seek(2013179)
results = GraphData.GraphData(file)
self.assertEqual(30105020, results._version)
self.assertEqual(1000, results._size)
self.assertAlmostEqual(0.0, results._borneInf)
self.assertAlmostEqual(8.900000000000E+01, results._borneSup)
self.assertEqual(0, results._isLog)
self.assertEqual(0, results._isUneven)
self.assertEqual("Z Max", results._title)
self.assertEqual("Depth (nm)", results._xTitle)
self.assertEqual("Hits (Normalized)", results._yTitle)
values = results.getValues()
self.assertAlmostEqual(1.0, values[0])
self.assertAlmostEqual(0.0, values[-1])
def test_read_StringIO(self):
# sim
if is_bad_file(self.filepathSim):
raise SkipTest
f = open(self.filepathSim, 'rb')
buf = BytesIO(f.read())
buf.mode = 'rb'
f.close()
file = File.File()
file.readFromFileObject(buf)
self.assertEqual(0, file._numberSimulations)
# cas
f = open(self.filepathCas, 'rb')
buf = BytesIO(f.read())
buf.mode = 'rb'
f.close()
file = File.File()
file.readFromFileObject(buf)
self.assertEqual(1, file._numberSimulations)
self.assertEqual(1, len(file._resultSimulationDataList))
def test_read(self):
if is_bad_file(self.filepathCas):
raise SkipTest
file = open(self.filepathCas, 'rb')
options = SimulationOptions.SimulationOptions()
options.read(file)
file.close()
del file
results = SimulationResults.SimulationResults()
file = open(self.filepathCas, 'rb')
file.seek(12648)
error = results.read(file, options)
self.assertEqual(None, error)
self.assertEqual(1, results._numberSimulations)
self.assertEqual(20031202, results._version)
self.assertAlmostEqual(0.8, results._initialEnergy_keV)
self.assertEqual(0.0, results._rkoMax)
self.assertEqual(30107002, results._versionSimulationResults)
self.assertTrue(results._isTotalEnergyDensitySaved)
def test_extract_version(self):
"""
Test extract_version method.
"""
if is_bad_file(self.filepathSim):
raise SkipTest
file_paths = []
file_paths.append((self.filepathSim, VERSION_2_45))
file_paths.append((self.filepathCas, VERSION_2_45))
file_paths.append((self.filepathStd, VERSION_2_50))
file_paths.append((self.filepathSim_v242, VERSION_2_42))
file_paths.append((self.filepathCas_v242, VERSION_2_42))
file_paths.append((self.filepathCas_nicr, VERSION_2_46))
file_paths.append((self.filepath_sim_v250, VERSION_2_50))
file_paths.append((self.filepath_cas_v250, VERSION_2_50))
file_paths.append((self.filepath_problem_sim_v250, VERSION_2_50))
file_paths.append((self.filepath_problem_pymontecarlo_sim_v250, VERSION_2_50))
file_paths.append((self.filepath_good_sim_v251, VERSION_2_51))
for file_path, version_ref in file_paths:
casino_file = File.File()
version = casino_file.extract_version(file_path)
self.assertEqual(version_ref, version, msg=file_path)
def test_extractVersionString(self):
if is_bad_file(self.filepathSim):
raise SkipTest
casinoFile = File.File(self.filepathSim)
version = File.V30103040
versionStrRef = "3.1.3.40"
versionStr = casinoFile._extractVersionString(version)
self.assertEqual(versionStrRef, versionStr)
version = File.V30103070
versionStrRef = "3.1.3.70"
versionStr = casinoFile._extractVersionString(version)
self.assertEqual(versionStrRef, versionStr)
version = File.V30104060
versionStrRef = "3.1.4.60"
versionStr = casinoFile._extractVersionString(version)
self.assertEqual(versionStrRef, versionStr)
version = File.V30107002
versionStrRef = "3.1.7.2"
versionStr = casinoFile._extractVersionString(version)
self.assertEqual(versionStrRef, versionStr)
def test_read(self):
if is_bad_file(self.filepathSim):
raise SkipTest
with open(self.filepathSim, 'rb') as file:
self._read_tests(file, self.version_2_45)
def test_read(self):
if is_bad_file(self.filepathCas):
raise SkipTest
file = open(self.filepathCas, 'rb')
options = SimulationOptions.SimulationOptions()
options.read(file)
file.close()
del file
results = ScanPointResults.ScanPointResults()
file = open(self.filepathCas, 'rb')
#file.seek(12648)
error = results.read(file, options)
self.assertEqual(None, error)
self.assertEqual(30107002, results._version)
self.assertAlmostEqual(0.8, results._initialEnergy_keV)
self.assertAlmostEqual(0.0, results._rkoMax)
self.assertAlmostEqual(24.04826155663, results._rkoMaxW)
self.assertEqual(1000000, results._numberSimulatedTrajectories)
self.assertEqual(2, results._beingProcessed)
self.assertAlmostEqual(5.468900000000E-02, results._backscatteredCoefficient)
self.assertAlmostEqual(0.0, results._backscatteredDetectedCoefficient)
self.assertAlmostEqual(0.0, results._secondaryCoefficient)
self.assertAlmostEqual(0.0, results._transmittedCoefficient)
self.assertAlmostEqual(0.0, results._transmittedDetectedCoefficient)
self.assertEqual(54689, results._numberBackscatteredElectrons)
self.assertAlmostEqual(0.0, results._numberBackscatteredElectronsDetected)
self.assertEqual(0, results._numberSecondaryElectrons)
self.assertEqual(8, results._numberResults)
for i in range(1, 8 + 1):
self.assertEqual(i, results._regionIntensityInfos[i - 1]._regionID)
# DZMax distribution results.
self.assertEqual(True, results._isDZMax)
self.assertEqual(30105020, results.dzMax._version)
self.assertEqual(1000, results.dzMax._size)
self.assertAlmostEqual(0.0, results.dzMax._borneInf)
self.assertAlmostEqual(8.900000000000E+01, results.dzMax._borneSup)
self.assertEqual(0, results.dzMax._isLog)
self.assertEqual(0, results.dzMax._isUneven)
self.assertEqual("Z Max", results.dzMax._title)
self.assertEqual("Depth (nm)", results.dzMax._xTitle)
self.assertEqual("Hits (Normalized)", results.dzMax._yTitle)
values = results.dzMax.getValues()
self.assertAlmostEqual(1.0, values[0])
self.assertAlmostEqual(0.0, values[-1])
self.assertEqual(True, results._isDEnergy_Density)
self.assertAlmostEqual(1.518294795870E-01, results.DEnergy_Density_Max_Energy)
self.assertEqual(199, results.getNumberSavedTrajectories())
def test_read(self):
if is_bad_file(self.filepathCas):
raise SkipTest
with open(self.filepathCas, 'rb') as file:
self._read_tests(file)
def test_read(self):
for filepath in [self.filepathSim, self.filepathCas]:
if is_bad_file(filepath):
raise SkipTest
file = open(filepath, 'rb')
simulationOptions = SimulationOptions.SimulationOptions()
error = simulationOptions.read(file)
self.assertEqual(None, error)
self.assertEqual(30107002, simulationOptions._version)
# ADF
self.assertEqual(30107002, simulationOptions._optionsADF._version)
self.assertAlmostEqual(1.0, simulationOptions._optionsADF.DQE)
self.assertEqual(1, simulationOptions._optionsADF.Enabled)
self.assertEqual(0, simulationOptions._optionsADF.keepData)
self.assertAlmostEqual(0.5, simulationOptions._optionsADF.MaxAngle)
self.assertAlmostEqual(0.2, simulationOptions._optionsADF.MinAngle)
self.assertEqual(0, simulationOptions._optionsADF.MaxPoints)
# AdvBackSet
self.assertEqual(30107002,
simulationOptions._optionsAdvBackSet._version)
self.assertEqual(False,
simulationOptions._optionsAdvBackSet.UseEnBack)
self.assertAlmostEqual(
10.0, simulationOptions._optionsAdvBackSet.WorkDist)
self.assertAlmostEqual(
1.0, simulationOptions._optionsAdvBackSet.DetectScaleX)
self.assertAlmostEqual(
1.0, simulationOptions._optionsAdvBackSet.DetectScaleY)
self.assertEqual(False,
simulationOptions._optionsAdvBackSet.ValidMatrix)
self.assertAlmostEqual(
0.0, simulationOptions._optionsAdvBackSet.BEMin_Angle)
self.assertAlmostEqual(
0.0, simulationOptions._optionsAdvBackSet.BEMax_Angle)
self.assertAlmostEqual(
0.0, simulationOptions._optionsAdvBackSet.EFilterMax)
self.assertAlmostEqual(
0.0, simulationOptions._optionsAdvBackSet.EFilterMin)
for i in range(101):
self.assertAlmostEqual(
1.0, simulationOptions._optionsAdvBackSet.EFilterVal[i])
self.assertEqual(0, simulationOptions._optionsAdvBackSet.FEFilter)
# Dist
self.assertEqual(30107002, simulationOptions._optionsDist._version)
self.assertAlmostEqual(
1.0,
simulationOptions._optionsDist.DenrMax / OptionsDist.autoFlag)
self.assertAlmostEqual(1000.0,
simulationOptions._optionsDist.DEposCyl_Z)
self.assertEqual(0, simulationOptions._optionsDist.DEposCyl_Z_Log)
self.assertEqual(OptionsDist.DIST_DEPOS_POSITION_ABSOLUTE,
simulationOptions._optionsDist.DEpos_Position)
# EnergyByPos
self.assertEqual(30107002,
simulationOptions._optionsEnergyByPos._version)
self.assertEqual(0, simulationOptions._optionsEnergyByPos.Diffuse)
self.assertEqual(
1, simulationOptions._optionsEnergyByPos.Depos_Summation)
self.assertAlmostEqual(
0.1, simulationOptions._optionsEnergyByPos.DEpos_IsoLevel)
self.assertAlmostEqual(
-1.0, simulationOptions._optionsEnergyByPos.
CarrierSurfaceRecombination)
self.assertEqual(1,
simulationOptions._optionsEnergyByPos.normalize)
# Micro
self.assertEqual(30107002,
simulationOptions._optionsMicro._version)
self.assertEqual(0, simulationOptions._optionsMicro.scanning_mode)
self.assertAlmostEqual(
0.0, simulationOptions._optionsMicro.X_plane_position)
self.assertAlmostEqual(1.0,
simulationOptions._optionsMicro.scanPtDist)
self.assertEqual(
1, simulationOptions._optionsMicro.keep_simulation_data)
# Physic
self.assertEqual(30107002,
simulationOptions._optionsPhysic._version)
self.assertEqual(3, simulationOptions._optionsPhysic.FRan)
self.assertEqual(1, simulationOptions._optionsPhysic.FDeds)
self.assertEqual(5, simulationOptions._optionsPhysic.FTotalCross)
self.assertEqual(5, simulationOptions._optionsPhysic.FPartialCross)
self.assertEqual(1, simulationOptions._optionsPhysic.FCosDirect)
self.assertEqual(3, simulationOptions._optionsPhysic.FSecIon)
self.assertEqual(0, simulationOptions._optionsPhysic.FPotMoy)
self.assertEqual(
10, simulationOptions._optionsPhysic.max_secondary_order)
self.assertAlmostEqual(
0.05, simulationOptions._optionsPhysic.Min_Energy_Nosec)
self.assertAlmostEqual(
0.0004, simulationOptions._optionsPhysic.Residual_Energy_Loss)
self.assertAlmostEqual(
-1, simulationOptions._optionsPhysic.Min_Energy_With_Sec)
self.assertAlmostEqual(
-1, simulationOptions._optionsPhysic.Min_Gen_Secondary_Energy)
# Xray
self.assertEqual(30107002, simulationOptions._optionsXray._version)
self.assertAlmostEqual(40.0, simulationOptions._optionsXray.TOA)
self.assertAlmostEqual(0.0, simulationOptions._optionsXray.PhieRX)
def test_modifyRotationYZ_deg(self):
testDataPath = get_current_module_path(__file__, "../../../test_data")
sourceFilepath = os.path.join(testDataPath, "casino3.x/NoRotationY.sim")
if is_bad_file(sourceFilepath):
raise SkipTest
if not os.path.isdir(self.temporaryDir):
raise SkipTest
rotationYRef_deg = 10.0
filename = "RotationY10.sim"
destinationFilepath = os.path.join(self.temporaryDir, filename)
shutil.copy2(sourceFilepath, destinationFilepath)
casinoFile = CasinoFile.File(destinationFilepath, isModifiable=True)
sample = casinoFile.getFirstSimulation().getSample()
rotationY_deg = sample.getRotationY_deg()
self.assertAlmostEqual(0.0, rotationY_deg)
rotationZ_deg = sample.getRotationZ_deg()
self.assertAlmostEqual(0.0, rotationZ_deg)
sample.modifyRotationY_deg(rotationYRef_deg)
del casinoFile
casinoFile = CasinoFile.File(destinationFilepath, isModifiable=False)
sample = casinoFile.getFirstSimulation().getSample()
rotationY_deg = sample.getRotationY_deg()
self.assertAlmostEqual(rotationYRef_deg, rotationY_deg)
rotationZ_deg = sample.getRotationZ_deg()
self.assertAlmostEqual(0.0, rotationZ_deg)
del casinoFile
rotationZRef_deg = 15.0
filename = "RotationZ15.sim"
destinationFilepath = os.path.join(self.temporaryDir, filename)
shutil.copy2(sourceFilepath, destinationFilepath)
casinoFile = CasinoFile.File(destinationFilepath, isModifiable=True)
sample = casinoFile.getFirstSimulation().getSample()
rotationY_deg = sample.getRotationY_deg()
self.assertAlmostEqual(0.0, rotationY_deg)
rotationZ_deg = sample.getRotationZ_deg()
self.assertAlmostEqual(0.0, rotationZ_deg)
sample.modifyRotationZ_deg(rotationZRef_deg)
del casinoFile
casinoFile = CasinoFile.File(destinationFilepath, isModifiable=False)
sample = casinoFile.getFirstSimulation().getSample()
rotationY_deg = sample.getRotationY_deg()
self.assertAlmostEqual(0.0, rotationY_deg)
rotationZ_deg = sample.getRotationZ_deg()
self.assertAlmostEqual(rotationZRef_deg, rotationZ_deg)
del casinoFile
rotationYRef_deg = 20.0
rotationZRef_deg = 35.0
filename = "RotationY20Z35.sim"
destinationFilepath = os.path.join(self.temporaryDir, filename)
shutil.copy2(sourceFilepath, destinationFilepath)
casinoFile = CasinoFile.File(destinationFilepath, isModifiable=True)
sample = casinoFile.getFirstSimulation().getSample()
rotationY_deg = sample.getRotationY_deg()
self.assertAlmostEqual(0.0, rotationY_deg)
rotationZ_deg = sample.getRotationZ_deg()
self.assertAlmostEqual(0.0, rotationZ_deg)
sample.modifyRotationY_deg(rotationYRef_deg)
sample.modifyRotationZ_deg(rotationZRef_deg)
del casinoFile
casinoFile = CasinoFile.File(destinationFilepath, isModifiable=False)
sample = casinoFile.getFirstSimulation().getSample()
rotationY_deg = sample.getRotationY_deg()
self.assertAlmostEqual(rotationYRef_deg, rotationY_deg)
rotationZ_deg = sample.getRotationZ_deg()
self.assertAlmostEqual(rotationZRef_deg, rotationZ_deg)
del casinoFile
def test_read_v242(self):
if is_bad_file(self.filepathSim_v242):
raise SkipTest
if is_bad_file(self.filepathCas_v242):
raise SkipTest
# .sim
file = File.File()
file.readFromFilepath(self.filepathSim_v242)
self.assertEqual(self.filepathSim_v242, file._filepath)
self.assertEqual(0, file._numberSimulations)
option_simulation_data = file.getOptionSimulationData()
version = option_simulation_data.getVersion()
self.assertEqual(Version.VERSION_2_42, version)
simulation_options = option_simulation_data.getSimulationOptions()
number_electrons = simulation_options.getNumberElectrons()
self.assertEqual(10000, number_electrons)
incident_energy_keV = simulation_options.getIncidentEnergy_keV()
self.assertAlmostEqual(3.0, incident_energy_keV)
toa_deg = simulation_options.getTOA_deg()
self.assertAlmostEqual(40.0, toa_deg)
number_xray_layers = simulation_options.getNumberXRayLayers()
self.assertEqual(500, number_xray_layers)
# .cas
file = File.File()
file.readFromFilepath(self.filepathCas_v242)
self.assertEqual(self.filepathCas_v242, file._filepath)
self.assertEqual(1, file._numberSimulations)
self.assertEqual(1, len(file._resultSimulationDataList))
option_simulation_data = file.getOptionSimulationData()
version = option_simulation_data.getVersion()
self.assertEqual(Version.VERSION_2_42, version)
simulation_options = option_simulation_data.getSimulationOptions()
number_electrons = simulation_options.getNumberElectrons()
self.assertEqual(10000, number_electrons)
incident_energy_keV = simulation_options.getIncidentEnergy_keV()
self.assertAlmostEqual(3.0, incident_energy_keV)
toa_deg = simulation_options.getTOA_deg()
self.assertAlmostEqual(40.0, toa_deg)
number_xray_layers = simulation_options.getNumberXRayLayers()
self.assertEqual(500, number_xray_layers)
result_simulation_data = file.getResultsSimulation(0)
region_options = result_simulation_data.getRegionOptions()
region = region_options.getRegion(0)
element = region.getElement(0)
intensities = element.getTotalXrayIntensities()
self.assertAlmostEqual(2164.75, intensities[LINE_K][GENERATED], 2)
self.assertAlmostEqual(415.81, intensities[LINE_K][EMITTED], 2)
atomic_number = element.getAtomicNumber()
self.assertEqual(5, atomic_number)
