Пример #1
0
    def setUp(self):
        TestCase.setUp(self)

        baseops = Options()
        baseops.detectors['xray'] = PhotonIntensityDetector((0, 1), (0, 3))

        self.m = Measurement(baseops)
        self.m.add_kratio(Ka(29), 0.2470, 0.004)
Пример #2
0
    def testfrom_xml(self):
        element = self.m.to_xml()
        m = Measurement.from_xml(element)

        kratios = m.get_kratios()
        self.assertEqual(1, len(kratios))
        self.assertAlmostEqual(0.247, kratios[0], 4)
Пример #3
0
    def testfrom_xml(self):
        element = self.m.to_xml()
        m = Measurement.from_xml(element)

        kratios = m.get_kratios()
        self.assertEqual(1, len(kratios))
        self.assertAlmostEqual(0.247, kratios[0], 4)
Пример #4
0
    def setUp(self):
        TestCase.setUp(self)

        geometry = MultiLayers(pure(29))
        geometry.add_layer(Material("AuPd", {79: 0.5, 46: 0.5}), 100e-9)

        baseops = Options()
        baseops.detectors['xray'] = PhotonIntensityDetector((0, 1), (0, 3))
        meas = Measurement(baseops)
        meas.add_kratio(Ka(29), 0.2470, 0.004)

        getter = lambda geometry: geometry.layers[0].thickness_m
        setter = lambda geometry, val: setattr(geometry.layers[0], 'thickness_m', val)
        param = Parameter(getter, setter, 100e-9, 10e-9, 500e-9)

        self.exp = Experiment(geometry, [meas], [param])
Пример #5
0
    def setUp(self):
        TestCase.setUp(self)

        baseops = Options()
        baseops.detectors["xray"] = PhotonIntensityDetector((0, 1), (0, 3))

        self.m = Measurement(baseops)
        self.m.add_kratio(Ka(29), 0.2470, 0.004)
Пример #6
0
class TestMeasurement(TestCase):
    def setUp(self):
        TestCase.setUp(self)

        baseops = Options()
        baseops.detectors["xray"] = PhotonIntensityDetector((0, 1), (0, 3))

        self.m = Measurement(baseops)
        self.m.add_kratio(Ka(29), 0.2470, 0.004)

    def tearDown(self):
        TestCase.tearDown(self)

    def testskeleton(self):
        self.assertTrue(True)

    def testadd_kratio(self):
        standard = Material("U90", {92: 0.9, 49: 0.1})
        self.m.add_kratio(La(92), 0.5, standard=standard)

        self.assertTrue(self.m.has_kratio(La(92)))
        self.assertAlmostEqual(0.5, self.m.get_kratios()[1], 4)

        self.m.add_kratio(Ka(13), 0.2, unc=0.125)

        self.assertTrue(self.m.has_kratio(Ka(13)))
        self.assertAlmostEqual(0.2, self.m.get_kratios()[0], 4)

        self.assertRaises(ValueError, self.m.add_kratio, La(92), 0.1)
        self.assertRaises(ValueError, self.m.add_kratio, Ka(14), -0.1)

    def testremove_kratio(self):
        self.m.remove_kratio(Ka(29))
        self.assertFalse(self.m.has_kratio(Ka(29)))
        self.assertEqual(0, len(self.m.get_kratios()))

    def testclear_kratios(self):
        self.m.clear_kratios()
        self.assertEqual(0, len(self.m.get_kratios()))

    def testhas_kratio(self):
        self.assertTrue(self.m.has_kratio(Ka(29)))
        self.assertFalse(self.m.has_kratio(La(29)))

    def testget_kratios(self):
        kratios = self.m.get_kratios()

        self.assertEqual(1, len(kratios))
        self.assertAlmostEqual(0.247, kratios[0], 4)

    def testfrom_xml(self):
        element = self.m.to_xml()
        m = Measurement.from_xml(element)

        kratios = m.get_kratios()
        self.assertEqual(1, len(kratios))
        self.assertAlmostEqual(0.247, kratios[0], 4)

    def testto_xml(self):
        element = self.m.to_xml()
        self.assertEqual(1, len(element.findall("kratio")))

    def testcreate_standard_options(self):
        list_options = self.m.create_standard_options("std")
        self.assertEqual(1, len(list_options))

    def testextract_standard_intensities(self):
        list_options = self.m.create_standard_options("std")
        stdoptions = list_options[0]

        intensities = create_intensity_dict(Ka(29), et=(8.0, 0.0))
        results = {"xray": PhotonIntensityResult(intensities)}
        stdresults = Results(stdoptions, results)

        dict_results = {"std+Cu Ka": stdresults}
        stdintensities = self.m.extract_standard_intensities("std", dict_results)

        self.assertEqual(1, len(stdintensities))
        self.assertAlmostEqual(8.0, stdintensities[0], 4)

    def testcreate_unknown_options(self):
        unkgeometry = Substrate(pure(49))
        options = self.m.create_unknown_options("meas", unkgeometry)
        self.assertEqual("meas", options.name)

    def testextract_unknown_intensities(self):
        unkgeometry = Substrate(pure(49))
        options = self.m.create_unknown_options("meas", unkgeometry)

        intensities = create_intensity_dict(Ka(29), et=(4.0, 0.0))
        results = Results(options, {"xray": PhotonIntensityResult(intensities)})

        unkintensities = self.m.extract_unknown_intensities(results)

        self.assertEqual(1, len(unkintensities))
        self.assertAlmostEqual(4.0, unkintensities[0], 4)
Пример #7
0
from pymontecarlo.program.nistmonte.config import program as NISTMonte

from pymontecarlo.reconstruction.experiment import Experiment
from pymontecarlo.reconstruction.measurement import Measurement
from pymontecarlo.reconstruction.parameter import Parameter
from pymontecarlo.reconstruction.reconstructor import Reconstructor

from pymontecarlo.input import Inclusion, pure, Material, Options, ShowersLimit, PhotonIntensityDetector, composition_from_formula

baseops = Options()
baseops.beam.energy_eV = 10e3
baseops.beam.diameter_m = 50e-9
baseops.detectors['xray'] = PhotonIntensityDetector.annular(radians(40.0), radians(5.0))
baseops.limits.add(ShowersLimit(1000))

meas1 = Measurement(baseops)
meas1.add_kratio(Ka(6), 0.5, standard=Material('Fe3C', composition_from_formula('Fe3C')))

def setter1(geometry, val):
    geometry.inclusion_material.composition = {26: val, 6: '?'}
param1 = Parameter(setter1, 0.95, 0.0, 1.0)

def setter2(geometry, val):
    geometry.inclusion_diameter_m = val
param2 = Parameter(setter2, 200e-9, 150e-9, 250e-9)

inclusion_material = Material('CrC', {26: 0.95, 6: 0.05})
geometry = Inclusion(pure(26), inclusion_material, 200e-9)
exp = Experiment(geometry, [meas1], [param1, param2])

runner = LocalRunner(NISTMonte, '/tmp', nbprocesses=1)
Пример #8
0
from pymontecarlo.reconstruction.experiment import Experiment
from pymontecarlo.reconstruction.measurement import Measurement
from pymontecarlo.reconstruction.parameter import Parameter
from pymontecarlo.reconstruction.reconstructor import Reconstructor

from pymontecarlo.input import Inclusion, pure, Material, Options, ShowersLimit, PhotonIntensityDetector, composition_from_formula

baseops = Options()
baseops.beam.energy_eV = 10e3
baseops.beam.diameter_m = 50e-9
baseops.detectors['xray'] = PhotonIntensityDetector.annular(
    radians(40.0), radians(5.0))
baseops.limits.add(ShowersLimit(1000))

meas1 = Measurement(baseops)
meas1.add_kratio(Ka(6),
                 0.5,
                 standard=Material('Fe3C', composition_from_formula('Fe3C')))


def setter1(geometry, val):
    geometry.inclusion_material.composition = {26: val, 6: '?'}


param1 = Parameter(setter1, 0.95, 0.0, 1.0)


def setter2(geometry, val):
    geometry.inclusion_diameter_m = val
Пример #9
0
class TestMeasurement(TestCase):

    def setUp(self):
        TestCase.setUp(self)

        baseops = Options()
        baseops.detectors['xray'] = PhotonIntensityDetector((0, 1), (0, 3))

        self.m = Measurement(baseops)
        self.m.add_kratio(Ka(29), 0.2470, 0.004)

    def tearDown(self):
        TestCase.tearDown(self)

    def testskeleton(self):
        self.assertTrue(True)

    def testadd_kratio(self):
        standard = Material('U90', {92: 0.9, 49: 0.1})
        self.m.add_kratio(La(92), 0.5, standard=standard)

        self.assertTrue(self.m.has_kratio(La(92)))
        self.assertAlmostEqual(0.5, self.m.get_kratios()[1], 4)

        self.m.add_kratio(Ka(13), 0.2, unc=0.125)

        self.assertTrue(self.m.has_kratio(Ka(13)))
        self.assertAlmostEqual(0.2, self.m.get_kratios()[0], 4)

        self.assertRaises(ValueError, self.m.add_kratio, La(92), 0.1)
        self.assertRaises(ValueError, self.m.add_kratio, Ka(14), -0.1)

    def testremove_kratio(self):
        self.m.remove_kratio(Ka(29))
        self.assertFalse(self.m.has_kratio(Ka(29)))
        self.assertEqual(0, len(self.m.get_kratios()))

    def testclear_kratios(self):
        self.m.clear_kratios()
        self.assertEqual(0, len(self.m.get_kratios()))

    def testhas_kratio(self):
        self.assertTrue(self.m.has_kratio(Ka(29)))
        self.assertFalse(self.m.has_kratio(La(29)))

    def testget_kratios(self):
        kratios = self.m.get_kratios()

        self.assertEqual(1, len(kratios))
        self.assertAlmostEqual(0.247, kratios[0], 4)

    def testfrom_xml(self):
        element = self.m.to_xml()
        m = Measurement.from_xml(element)

        kratios = m.get_kratios()
        self.assertEqual(1, len(kratios))
        self.assertAlmostEqual(0.247, kratios[0], 4)

    def testto_xml(self):
        element = self.m.to_xml()
        self.assertEqual(1, len(element.findall('kratio')))

    def testcreate_standard_options(self):
        list_options = self.m.create_standard_options('std')
        self.assertEqual(1, len(list_options))

    def testextract_standard_intensities(self):
        list_options = self.m.create_standard_options('std')
        stdoptions = list_options[0]

        intensities = create_intensity_dict(Ka(29), et=(8.0, 0.0))
        results = {'xray': PhotonIntensityResult(intensities)}
        stdresults = Results(stdoptions, results)

        dict_results = {'std+Cu Ka': stdresults}
        stdintensities = self.m.extract_standard_intensities('std', dict_results)

        self.assertEqual(1, len(stdintensities))
        self.assertAlmostEqual(8.0, stdintensities[0], 4)

    def testcreate_unknown_options(self):
        unkgeometry = Substrate(pure(49))
        options = self.m.create_unknown_options('meas', unkgeometry)
        self.assertEqual('meas', options.name)

    def testextract_unknown_intensities(self):
        unkgeometry = Substrate(pure(49))
        options = self.m.create_unknown_options('meas', unkgeometry)

        intensities = create_intensity_dict(Ka(29), et=(4.0, 0.0))
        results = Results(options, {'xray': PhotonIntensityResult(intensities)})

        unkintensities = self.m.extract_unknown_intensities(results)

        self.assertEqual(1, len(unkintensities))
        self.assertAlmostEqual(4.0, unkintensities[0], 4)