예제 #1
0
def backscatter(mat, e0, nTraj=100000, buildSample=buildBulk, params={}):
   """backscatter(mat, e0, nTraj=100000, buildSample=buildBulk)
   Simulate backscatter from the specified material at the specified beam energy."""
   defOut = (dtsa2.DefaultOutput if dtsa2.DefaultOutput else dtsa2.reportPath())
   monte = nm.MonteCarloSS()
   monte.setBeamEnergy(epq.ToSI.keV(e0))
   p = params.copy()
   p["Material"] = mat
   buildSample(monte, (0.0, 0.0, 0.0), p)
   bs0 = nm.BackscatterStats(monte, 100)
   monte.addActionListener(bs0)
   ann = nm.AnnularDetector(1.0e-3, 10, (0.0, 0.0, -1.0e-3), (0.0, 0.0, 1.0)) 
   monte.addActionListener(ann)
   monte.runMultipleTrajectories(nTraj)
   tmpFile = jio.File.createTempFile("Backscatter", ".csv", jio.File(defOut))
   print u"Results -> %s" % tmpFile
   fos = jio.FileOutputStream(tmpFile)
   try:
      osw = jio.OutputStreamWriter(fos)
      osw.append("Parameters:\n")
      osw.append("E0\t%g keV\n" % e0)
      for k, v in p.iteritems():
         osw.append("%s\t%s\n" % (k, v))
      ann.dump(osw)
      osw.flush()
      bs0.dump(fos)
   finally:    
      fos.close()
   return (bs0.backscatterFraction(), bs0.forwardscatterFraction())
예제 #2
0
 def build(monte, chamber, origin, buildParams):
     p1Mat, p1Radius = buildParams["P1"]
     p2Mat, p2Radius = buildParams["P2"]
     separation = buildParams["Separation"]
     substrate = buildParams["Substrate"]
     sphere1 = nm.Sphere(epu.Math2.plus(origin, [0.0, 0.0, p1Radius]), p1Radius)
     monte.addSubRegion(chamber, p1Mat, sphere1)
     sphere2 = nm.Sphere(epu.Math2.plus(origin, [separation, 0.0, 2.0 * p1Radius - p2Radius]), p2Radius)
     monte.addSubRegion(chamber, p2Mat, sphere2)
     if substrate:
        monte.addSubRegion(chamber, substrate, nm.MultiPlaneShape.createSubstrate([0.0, 0.0, -1.0], epu.Math2.plus(origin, [0.0, 0.0, 2.0 * p1Radius])))
예제 #3
0
 def buildSphere(monte, chamber, origin, buildParams):
    radius = buildParams["Radius"]
    subMat = buildParams["Substrate"]
    mat = buildParams["Material"]
    coating = buildParams["Coating"]
    thickness = buildParams["Thickness"]
    coatSphere = nm.Sphere(epu.Math2.plus(origin, [0.0, 0.0, radius + thickness]), radius + thickness)
    srC = monte.addSubRegion(chamber, coating, coatSphere)
    sphere = nm.Sphere(epu.Math2.plus(origin, [0.0, 0.0, radius + thickness]), radius)
    monte.addSubRegion(srC, mat, sphere)
    if subMat:
       monte.addSubRegion(chamber, subMat, nm.MultiPlaneShape.createSubstrate([0.0, 0.0, -1.0], epu.Math2.plus(origin, [0.0, 0.0, 2.0 * radius])))
예제 #4
0
 def buildEmbeddedSphere(monte, chamber, origin, buildParams):
    mat = buildParams["Material"]
    radius = buildParams["Radius"]
    subMat = buildParams["Substrate"]
    depth = buildParams["Depth"]
    sr = monte.addSubRegion(chamber, subMat, nm.MultiPlaneShape.createSubstrate([0.0, 0.0, -1.0], origin))
    monte.addSubRegion(sr, mat, nm.Sphere(epu.Math2.plus(origin, [0.0, 0.0, depth + radius]), radius))
예제 #5
0
 def buildSphere(monte, chamber, origin, buildParams):
    radius = buildParams["Radius"]
    subMat = buildParams["Substrate"]
    mat = buildParams["Material"]
    sphere = nm.Sphere(epu.Math2.plus(origin, [0.0, 0.0, radius]), radius)
    monte.addSubRegion(chamber, mat, sphere)
    if subMat:
       monte.addSubRegion(chamber, subMat, nm.MultiPlaneShape.createSubstrate([0.0, 0.0, -1.0], epu.Math2.plus(origin, [0.0, 0.0, 2.0 * radius])))
예제 #6
0
 def buildSphere(monte, chamber, origin, buildParams):
     mat = buildParams["Material"]
     radius = buildParams["Radius"]
     coating = buildParams["Coating"]
     cThick = buildParams["Coating Thickness"]
     film = buildParams["Film"]
     fThick = buildParams["Film Thickness"]
     coatSphere = nm.Sphere(
         epu.Math2.plus(origin, [0.0, 0.0, radius + cThick]),
         radius + cThick)
     srC = monte.addSubRegion(chamber, coating, coatSphere)
     sphere = nm.Sphere(epu.Math2.plus(origin, [0.0, 0.0, radius + cThick]),
                        radius)
     monte.addSubRegion(srC, mat, sphere)
     monte.addSubRegion(
         chamber, film,
         nm.MultiPlaneShape.createFilm(
             [0.0, 0.0, -1.0],
             epu.Math2.plus(origin, [0.0, 0.0, 2.0 * radius]), fThick))
예제 #7
0
 def buildEmbeddedCylinder(monte, chamber, origin, buildParams):
     mat = buildParams["Material"]
     subMat = buildParams["Substrate"]
     radius = buildParams["Radius"]
     depth = buildParams["Depth"]
     if subMat:
         sr = monte.addSubRegion(chamber, subMat, nm.MultiPlaneShape.createSubstrate([0.0, 0.0, -1.0], origin))
     else:
         sr = chamber
     end1 = epu.Math2.plus(origin, [0.0, 0.0, depth])
     cyl = nm.CylindricalShape(origin, end1, radius);
     monte.addSubRegion(sr, mat, cyl)
예제 #8
0
def stemCell(h2oThickness,
             objMat,
             objDiameter,
             objDepth,
             e0,
             beamOffset=0.0,
             detectorDistance=0.008,
             detectorRadius=0.02,
             detRingCount=100,
             nTraj=10000):
    """stemCell(h2oThickness, objMat, objDiameter, objDepth, e0, [beamOffset=0.0], [detectorDistance=0.008], [detectorRadius=0.02], [detRingCount=100], [nTraj=10000]):
	Model scattering from a spherical object embedded in a suspended water film.
	Example: 
		> import dtsa2.stemCell as sc
		> sc.stemCell(1.0e-6, material("Au",10.0), 2.0e-7, 4.0e-7, 100.0,nTraj=1000)"""
    monte = nm.MonteCarloSS()
    monte.setBeamEnergy(epq.ToSI.keV(e0))
    beam = nm.GaussianBeam(1.0e-10)
    beam.setCenter((beamOffset, 0.0, -0.01))
    monte.setElectronGun(beam)
    h2o = d2.material("H2O", 1.0)
    h2oThickness = max(h2oThickness, objDiameter)
    objDepth = max(0.5 * objDiameter,
                   min(h2oThickness - 0.5 * objDiameter, objDepth))
    h2oSr = monte.addSubRegion(
        monte.getChamber(), h2o,
        nm.MultiPlaneShape.createFilm((0.0, 0.0, -1.0), (0.0, 0.0, 0.0),
                                      h2oThickness))
    monte.addSubRegion(h2oSr, objMat,
                       nm.Sphere((0.0, 0.0, objDepth), 0.5 * objDiameter))
    ann = nm.AnnularDetector(detectorRadius, detRingCount,
                             (0.0, 0.0, detectorDistance), (0.0, 0.0, -1.0))
    monte.addActionListener(ann)
    monte.runMultipleTrajectories(nTraj)
    header = "Parameters:\nWater thickness\t%g nm\nSphere material\t%s\nSphere diameter\t%g nm\nSphere center depth\t%g nm\nBeam offset\t%g nm\nDetector distance\t%g mm\nDetector radius\t%g mm\nE0\t%g keV" % (
        1.0e9 * h2oThickness, objMat.descriptiveString(False),
        1.0e9 * objDiameter, 1.0e9 * objDepth, 1.0e9 * beamOffset,
        1.0e3 * detectorDistance, 1.0e3 * detectorRadius, e0)
    print header
    return (header, ann)
예제 #9
0
 def doMonte(cc):
    monte = nm.MonteCarloSS()
    monte.setBeamEnergy(epq.ToSI.keV(e0))
    monte.addSubRegion(chamber, cc, nm.MultiPlaneShape.createSubstrate([0.0, 0.0, -1.0], origin))
    # Add event listeners to model characteristic radiation
    chXR = nm3.CharacteristicXRayGeneration3.create(monte)
    chTr = nm3.XRayTransport3.create(monte, det, chXR)
    xrel = nm3.XRayAccumulator3(xrts, "Characteristic")
    chTr.addXRayListener(xrel)
    fxg3 = nm3.FluorescenceXRayGeneration3.create(monte, chXR)
    chSFTr = nm3.XRayTransport3.create(monte, det, fxg3)
    chSF = nm3.XRayAccumulator3(xrts, "Secondary")
    chSFTr.addXRayListener(chSF)
    det.reset()
    monte.runMultipleTrajectories(nTraj)
    return (xrel, chSF)
예제 #10
0
def simLineInMatrix(lin,
                    linMat,
                    blk,
                    blkMat,
                    nmLinWid,
                    umBlock,
                    nPts,
                    trs,
                    outDir,
                    hdr,
                    det,
                    e0,
                    lt,
                    pc,
                    withPoisson=True,
                    nTraj=100,
                    sf=True,
                    bf=True,
                    iDigits=5,
                    bVerbose=False,
                    xtraParams={}):
    """simLineInMatrix(lin, linMat, blk, blkMat, nmLinWid, umBlock, nPts,
	trs, outDir, hdr, det, e0, lt, pc, withPoisson=True, nTraj=nTraj,
	sf=True, bf=True, iDigits=5, bVerbose=False, xtraParams={})
	Simulate a line of width `nmLinWid' nm at the center of a block of
	`umBlock' microns. The line is of material `lin' with a name `linMat'.
	The block is of material `blk' with a name `blkMat'.
	We analyze an list `trs' of transitions, writing the K-ratios to a
	.csv file with a header `hdr'. We use the detector `det', voltage `e0'
	(kV) and live time `lt' sec and probe current  `pc' nA. This will
	compute the standard spectra, compute the spectra for nPts+1 from
	-nPts/2 ... 0 ...nPts/2 times the block size. It will then compute the
	K-ratios for each spectrum and write them to a file `name' in outDir
	with a header `hdr' that matches the transition order.
	"""
    # order is order of trs..
    sc = 1.0e-6  # scale from microns to meters for positions
    lX = []  # an array for postions
    lKlin = []  # an array for the K-ratio of the line
    lKblk = [
    ]  # an array for the K-ratio of the block. Title correspond to hdr string
    # start clean
    dt2.DataManager.clearSpectrumList()
    # create the standards
    linStd = simulateBulkStandard(lin,
                                  linMat,
                                  det,
                                  e0,
                                  lt,
                                  pc,
                                  withPoisson=True,
                                  nTraj=nTraj,
                                  sf=True,
                                  bf=True,
                                  xtraParams={})
    dt2.display(linStd)
    blkStd = simulateBulkStandard(blk,
                                  blkMat,
                                  det,
                                  e0,
                                  lt,
                                  pc,
                                  withPoisson=True,
                                  nTraj=nTraj,
                                  sf=True,
                                  bf=True,
                                  xtraParams={})
    dt2.display(blkStd)
    lStd = {"El": dt2.element(linMat), "Spc": linStd}
    bStd = {"El": dt2.element(blkMat), "Spc": blkStd}
    stds = [lStd, bStd]  # note: put the transitions in this order
    iCount = 0
    for x in range(-nPts / 2, (nPts / 2) + 1, 1):
        xv = sc * x * umBlock / nPts
        lX.append(round(x * umBlock / nPts, iDigits))
        monte = nm.MonteCarloSS()
        monte.setBeamEnergy(epq.ToSI.keV(e0))
        # use a 1 nm probe
        beam = nm.GaussianBeam(1.0e-9)
        monte.setElectronGun(beam)
        beam.setCenter([xv, 0.0, -0.05])
        # createBlock(double[] dims, double[] point, double phi, double theta, double psi)
        # createBlock - Create a block of:
        #		  dimensions specified in dims,
        #		  centered at point,
        #		  then rotated by the euler angles phi, theta, psi.
        block = nm.MultiPlaneShape.createBlock(
            [umBlock * 1.0e-6, umBlock * 1.0e-6, umBlock * 1.0e-6],
            [0.0, 0.0, 0.5 * umBlock * 1.0e-6], 0.0, 0.0, 0.0)
        matrix = monte.addSubRegion(monte.getChamber(), blk, block)
        monte.addSubRegion(
            matrix, lin,
            nm.MultiPlaneShape.createBlock(
                [1.0e-9 * nmLinWid, umBlock * 1.0e-6, umBlock * 1.0e-6],
                [0.0, 0.0, 0.5 * umBlock * 1.0e-6], 0.0, 0.0, 0.0))
        det.reset()
        # Add event listeners to model characteristic radiation
        chXR = nm3.CharacteristicXRayGeneration3.create(monte)
        xrel = nm3.XRayTransport3.create(monte, det, chXR)
        brXR = nm3.BremsstrahlungXRayGeneration3.create(monte)
        brem = nm3.XRayTransport3.create(monte, det, brXR)
        fxg3 = nm3.FluorescenceXRayGeneration3.create(monte, chXR)
        chSF = nm3.XRayTransport3.create(monte, det, fxg3)
        brSF = nm3.XRayTransport3.create(
            monte, det, nm3.FluorescenceXRayGeneration3.create(monte, brXR))
        # here is where we run the simulation
        monte.runMultipleTrajectories(nTraj)
        spec = det.getSpectrum((lt * pc * 1.0e-9) /
                               (nTraj * epq.PhysicalConstants.ElectronCharge))
        props = spec.getProperties()
        props.setNumericProperty(epq.SpectrumProperties.LiveTime, lt)
        props.setNumericProperty(epq.SpectrumProperties.FaradayBegin, pc)
        props.setNumericProperty(epq.SpectrumProperties.FaradayEnd, pc)
        props.setNumericProperty(epq.SpectrumProperties.BeamEnergy, e0)
        spcName = "x = %.3f um" % x
        epq.SpectrumUtils.rename(spec, spcName)
        spec = epq.SpectrumUtils.addNoiseToSpectrum(spec, 1.0)
        # display(spec)
        a = jmg.compKRs(spec, stds, trs, det, e0)
        iCount += 1
        print(iCount)
        lKlin.append(round(a[0], iDigits))
        lKblk.append(round(a[1], iDigits))

    basFile = "%gnm-%s-in-%gum-%s-%gkV-%g-Traj.csv" % (
        nmLinWid, linMat, umBlock, blkMat, e0, nTraj)
    strOutFile = outDir + "/" + basFile
    f = open(strOutFile, 'w')
    strLine = hdr + '\n'
    f.write(strLine)
    for i in range(iCount):
        strLine = "%.5f" % lX[i] + ","
        strLine = strLine + "%.5f" % lKlin[i] + ","
        strLine = strLine + "%.5f" % lKblk[i] + "\n"
        f.write(strLine)
    f.close()
예제 #11
0
def base(det, e0, withPoisson, nTraj, dose, sf, bf, name, buildSample, buildParams, xtraParams):
   """base(det, e0, withPoisson, nTraj, dose, sf, bf, name, buildSample, buildParams) represents \
   a generic mechanism for Monte Carlo simulation of x-ray spectra.  The argument buildSample \
   is a method buildSample(monte,origin,buildParams) taking an instance of MonteCarloSS, the \
   position of the origin and a dictionary of build parameters.  This method should construct \
   the sample geometry.  The other arguments are the detector, the beam energy (keV), whether \
   to add Poisson noise, the number of electron trajectories to simulate, whether to simulate \
   characteristic secondary fluorescence and Bremsstrahlung secondary fluorescence, the name \
   to assign to the resulting spectrum."""
   if e0 < 0.1:
       raise "The beam energy must be larger than 0.1 keV."
   if nTraj < 1:
       raise "The number of electron trajectories must be larger than or equal to 1."
   if dose <= 0.0:
       raise "The electron dose must be larger than zero."
   name = name.strip()
   if xtraParams.has_key("Postfix"):
      name = "%s - %s" % (name, xtraParams["Postfix"])
   # Place the sample at the optimal location for the detector
   origin = epq.SpectrumUtils.getSamplePosition(det.getProperties())
   # Create a simulator and initialize it
   monte = nm.MonteCarloSS()
   if xtraParams.has_key("Gun"):
      gun = xtraParams["Gun"]
      gun.setCenter([0.0, 0.0, -0.099])
      monte.setElectronGun(gun)
   if xtraParams.has_key("PosX"):
      beamX  = xtraParams["PosX"]
      beamY  = xtraParams["PosY"]
      beamZ  = xtraParams["PosZ"]
      beamNM = xtraParams["nmSize"]
      beam=nm.GaussianBeam(beamNM*1.0e-9)
      beam.setCenter([beamX, beamY, beamZ]) 
      monte.setElectronGun(beam)
   chamber = monte.getChamber()
   if xtraParams.has_key("VP"):
       pathLength, gas = xtraParams["VP"]
       dim = 0.5 * nm.MonteCarloSS.ChamberRadius;
       dims = epu.Math2.plus(epu.Math2.v3(dim, dim, dim), epu.Math2.z3(2.0 * pathLength))
       pt = epu.Math2.plus(origin, epu.Math2.z3(0.5 * dim));
       shape = nm.MultiPlaneShape.createBlock(dims, pt, 0.0, 0.0, 0.0);
       msm = nm.BasicMaterialModel(gas);
       chamber = monte.addSubRegion(chamber, msm, shape);
   monte.setBeamEnergy(epq.ToSI.keV(e0))
   buildSample(monte, chamber, origin, buildParams)
   # Add event listeners to model characteristic radiation
   chXR = nm3.CharacteristicXRayGeneration3.create(monte)
   xrel = nm3.XRayTransport3.create(monte, det, chXR)
   brXR = nm3.BremsstrahlungXRayGeneration3.create(monte)
   brem = nm3.XRayTransport3.create(monte, det, brXR)
   chSF, brSF, bremFluor, charFluor  = None, None, None, None
   hasCharAcc = xtraParams.has_key('Characteristic Accumulator') and xtraParams['Characteristic Accumulator']
   if sf or hasCharAcc or xtraParams.has_key("Compton"):
      charFluor = nm3.FluorescenceXRayGeneration3.create(monte, chXR)
      if xtraParams.has_key("Compton"):
         charFluor.setIncludeCompton(True)
      chSF = nm3.XRayTransport3.create(monte, det, charFluor)
   hasBremFluorAcc = xtraParams.has_key('Brem Fluor Accumulator') and xtraParams['Brem Fluor Accumulator']
   if bf or hasBremFluorAcc:    
      bremFluor = nm3.FluorescenceXRayGeneration3.create(monte, brXR)       
      brSF = nm3.XRayTransport3.create(monte, det, bremFluor)
   hasTrans = xtraParams.has_key("Transitions")
   if hasTrans:
       if xtraParams.has_key("Emission Images"):
           eis = []
           dim = xtraParams["Emission Images"]
           for xrt in xtraParams["Transitions"]:
               size = xtraParams["Emission Size"]
               ei = nm3.EmissionImage3(size, size, xrt)
               xrel.addXRayListener(ei)
               if chSF:
                   chSF.addXRayListener(ei)
               if brSF:
                   brSF.addXRayListener(ei)
               ei.setXRange(origin[0] - 0.5 * dim, origin[0] + 0.5 * dim)
               ei.setYRange(origin[2] - 0.1 * dim, origin[2] + 0.9 * dim)
               eis.append(ei)
       if hasCharAcc:
           cxra = nm3.XRayAccumulator3(xtraParams["Transitions"], "Characteristic", dose * 1.0e-9)
           xrel.addXRayListener(cxra)
       hasCharFluorAcc = xtraParams.has_key('Char Fluor Accumulator') and xtraParams['Char Fluor Accumulator']
       if hasCharFluorAcc or chSF or sf:
           cfxra = nm3.XRayAccumulator3(xtraParams["Transitions"], "Characteristic Fluorescence", dose * 1.0e-9)
           chSF.addXRayListener(cfxra) 
       if hasBremFluorAcc or brSF or bf:
           bfxra = nm3.XRayAccumulator3(xtraParams["Transitions"], "Continuum Fluorescence", dose * 1.0e-9)
           brSF.addXRayListener(bfxra)
   contImgs = []
   if xtraParams.has_key('Continuum Images'):
       dim = xtraParams['Continuum Images']
       size = xtraParams['Continuum Size']
       energies = xtraParams['Continuum Energies']
       for eMin, eMax in energies:
           ci3 = nm3.ContinuumImage3(size, size, epq.ToSI.keV(eMin), epq.ToSI.keV(eMax))
           ci3.setXRange(origin[0] - 0.5 * dim, origin[0] + 0.5 * dim)
           ci3.setYRange(origin[2] - 0.1 * dim, origin[2] + 0.9 * dim)
           brem.addXRayListener(ci3)
           contImgs.append(ci3)
   doPRZ = xtraParams.has_key("PhiRhoZ")
   if doPRZ:
      depth = xtraParams["PhiRhoZ"]
      prz = nm3.PhiRhoZ3(xrel, origin[2] - 0.1 * depth, origin[2] + 1.1 * depth, 110)
      xrel.addXRayListener(prz)
   voxelated = xtraParams.has_key('Voxelated')
   vox = None
   if voxelated:
      dim = xtraParams['Voxelated']
      gen = xtraParams['GeneratedV']
      size = xtraParams['SizeV']
      vox = nm3.VoxelatedDetector((origin[0], origin[1], origin[2] - 0.1 * size), (size, size, size), (dim, dim, dim), gen)
      xrel.addXRayListener(vox)
   doTraj = xtraParams.has_key('Trajectories')
   if doTraj:
      dim = xtraParams['Trajectories']
      size = xtraParams['TrajSize']
      ti = nm.TrajectoryImage(size, size, dim)
      ti.setXRange(origin[0] - 0.5 * dim, origin[0] + 0.5 * dim)
      ti.setYRange(origin[2] - 0.1 * dim, origin[2] + 0.9 * dim)
      monte.addActionListener(ti)
   defOut = (dtsa2.DefaultOutput if dtsa2.DefaultOutput else dtsa2.reportPath())
   do = ("%s\\%s" % (xtraParams["Output"], dtsa2.normalizeFilename(name)) if xtraParams.has_key("Output") else "%s/%s" % (defOut, dtsa2.normalizeFilename(name)))
   do = do.replace("\\", "/")
   fdo = jio.File(do)
   fdo.mkdirs()
   doVRML = xtraParams.has_key('VRML')
   vrmlWr = None
   if doVRML:
      vrmlFile = jio.File.createTempFile("vrml", ".wrl", fdo)
      print "VRML in " + str(vrmlFile)
      vrmlWr = jio.FileWriter(vrmlFile)
      vrml = nm.TrajectoryVRML(monte, vrmlWr)
      vrml.setDisplayBackscatter(False)
      vrml.setDisplayXRayEvent(True)
      vrml.setMaxTrajectories(xtraParams['VRML'])
      vrml.setTrajectoryWidth(1.0e-9)
      vrml.setMaxRadius(1.0)
      vrml.setEmissive(True)
      vrml.addView("Y-Axis", epu.Math2.plus(origin, (0.0, 5.0e-6, 0.0)), origin)
      vrml.addView("Gun", epu.Math2.plus(origin, (0.0, 0.0, -5.0e-6)), origin)
      vrml.addView("X-Axis", epu.Math2.plus(origin, (-5.0e-6, 0.0, 0.0)), origin)
      vrml.renderSample()
      monte.addActionListener(vrml)
   scatter = None
   if xtraParams.has_key("Scatter"):
      scatter = nm.ScatterStats(epq.ToSI.eV(50.0))
      monte.addActionListener(scatter)
   # Reset the detector and run the electrons
   det.reset()
   monte.runMultipleTrajectories(nTraj)
   # Get the spectrum and assign properties
   spec = det.getSpectrum((dose * 1.0e-9) / (nTraj * epq.PhysicalConstants.ElectronCharge))
   props = spec.getProperties()
   props.setNumericProperty(epq.SpectrumProperties.LiveTime, dose)
   props.setNumericProperty(epq.SpectrumProperties.FaradayBegin, 1.0)
   props.setNumericProperty(epq.SpectrumProperties.BeamEnergy, e0)
   epq.SpectrumUtils.rename(spec, name)
   if withPoisson:
      spec = epq.SpectrumUtils.addNoiseToSpectrum(spec, 1.0)
   printAcc = xtraParams.has_key('Print Accumulators') and xtraParams['Print Accumulators']
   if printAcc:
      sw0 = jio.StringWriter()
      sw = jio.PrintWriter(sw0)
   if hasTrans or scatter:
      pw = None
      if hasCharAcc or (hasBremFluorAcc and bf) or (hasCharFluorAcc and sf) or scatter:
         jio.File(do).mkdirs()
         pw = jio.PrintWriter("%s/Intensity.csv" % do)
         pw.println(name)
      if hasCharAcc:
         pw.println("Characteristic") 
         cxra.dump(pw)
         if printAcc:
             sw.println("Characteristic") 
             cxra.dump(sw)
      if hasBremFluorAcc and brSF and bf:
         pw.println("Bremsstrahlung Fluorescence")
         bfxra.dump(pw)
         if printAcc:
             sw.println("Bremsstrahlung Fluorescence") 
             bfxra.dump(sw)
      if hasCharFluorAcc and chSF and sf:
         pw.println("Characteristic Fluorescence")
         cfxra.dump(pw)
         if printAcc:
             sw.println("Characteristic Fluorescence")
             cfxra.dump(sw)
      if printAcc:
          print sw0.toString()
          sw.close()
          sw0.close()
      if scatter:
         scatter.header(pw)
         scatter.dump(pw)
      if pw:
         pw.close()
      imgs = []
      if xtraParams.has_key("Emission Images"):
         nm3.EmissionImageBase.scaleEmissionImages(eis)
         print eis
         print do          
         nm3.EmissionImage3.dumpToFiles(eis, do)
         print u"Writing emission images to %s" % do
         imgs.extend(eis)
      if xtraParams.has_key("Continuum Images"):
         imgs.extend(contImgs)      
         nm3.EmissionImageBase.scaleEmissionImages(imgs)
         print contImgs
         print do          
         nm3.ContinuumImage3.dumpToFiles(contImgs, do)
         print u"Writing continuum images to %s" % do
   if doPRZ:
       jio.File(do).mkdirs()
       pw = jio.PrintWriter(u"%s/PhiRhoZ.csv" % do)
       prz.write(pw)
       pw.close()
       print u"Writing emission images to %s" % do
   if doTraj:
      ti.dumpToFile(do)
      print u"Writing trajectory images to %s" % do
   if vrmlWr:
       vrmlWr.close()
   if vox:
      jio.File(do).mkdirs()
      objs = list(vox.getAccumulatorObjects())
      xx = {}
      for obj in objs:
          iio.write(vox.createXZSum(400, obj), "png", jio.File(do, "Voxelated[XZ,Sum][%s].png" % obj))
          iio.write(vox.createXYSum(400, obj), "png", jio.File(do, "Voxelated[XY,Sum][%s].png" % obj))
          iio.write(vox.createXZView(400, obj), "png", jio.File(do, "Voxelated[XZ, Max][%s].png" % obj))
          iio.write(vox.createXYView(400, obj), "png", jio.File(do, "Voxelated[XY, Max][%s].png" % obj))
          vox.writeXZPlanar(400, obj, jio.File(do, "Voxilated[XZ,planar,%s].tif" % obj))
          vox.writeXYPlanar(400, obj, jio.File(do, "Voxilated[XY,planar,%s].tif" % obj))
          for f in (0.1, 0.5, 0.8, 0.9):
              iio.write(vox.createXZFraction(400, obj, f), "png", jio.File(do, "Voxelated[XZ,f=%g][%s].png" % (f, obj)))
          xx[obj] = vox.createRadialCDF(origin, obj)
      hdr = "Radius"
      for obj in objs:
          hdr = "%s\t%s" % (hdr, obj)
      print hdr
      first = xx[objs[0]]
      for i, (d, f) in enumerate(first):
          ln = "%g" % d
          for obj in objs:
              rcdf = xx[obj][i]
              ln = "%s\t%g" % (ln, rcdf[1])
          print ln
   #if bremFluor:
       #print "Stats[Scale] = %s" % bremFluor.getScaleStats()         
   return dtsa2.wrap(spec)