def arnoldiMCGeneral(geo, xs, histories, iterations, Chart=None):
"""
"""
uni = scipy.ones(geo.bins)
point = scipy.zeros(geo.bins)
point[2] = 1
uSource = fissionSource.histogramSource(uni,geo)
pSource = fissionSource.histogramSource(point,geo)
uSource = uSource/scipy.linalg.norm(uSource,2)
print "uSource: %s" %uSource
# mark = Markov.Markov(geo,xs, histories)
amc = arnoldiMC.arnoldiMC(geo, xs, histories)
Values, Vectors = amc.arnoldi(uSource, iterations)
data = {}
n = len(Vectors[0])-1
for i in xrange(5):
vectData = Gnuplot.Data(Vectors[:,n-i], with='lines',
title="vector %i" %i)
Chart.replot(vectData)
data['Vector%i' %i] = (amc.geo.centers,Vectors[:,n-i])
Chart.title('Eigenvector, %i particles per iteration' %histories)
# Chart.ylabel('Residual')
# Chart.xlabel('Iteration')
# Chart('set logscale y')
# print "Histories = %s, eValue = %s" %(amc.histories, amc.eValue)
if len(sys.argv) > 1:
gFile = gnuplotFile.gnuplotFile(sys.argv[1], data)
return Chart
def ERAM(self, q, R, inactiveR, Iterations):
"""
ERAM is Explicitly Restarted Arnoldi's Method. It is similar to
self.arnoldi() except it calculates a new starting source after a few
iterations. ERAM returns the estimated eigenvalues and eigenvectors.
q: fissionSource object, starting source vector
R: How many Arnoldi Restarts
inactiveR: The number of Restarts to throw away
Iterations: How many Arnoldi Iterations between restarts
"""
self.eValues = []
self.mean = []
self.std = []
start = time.time()
# Inactive Restarts
for i in xrange(inactiveR):
Values, Vectors = self.arnoldi(q, Iterations)
q = fissionSource.histogramSource(abs(Vectors[:, -1]), self.geo)
for self.r in xrange(1, R + 1):
Values, Vectors = self.arnoldi(q, Iterations)
self.eValues.append(Values)
self.mean.append(scipy.mean(self.eValues, 0)[-1])
self.std.append(
(1 / math.sqrt(self.r)) * scipy.std(self.eValues, 0)[-1])
self.histList.append(self.resHist)
if isinstance(self.vectorStorage, list):
v = Vectors[:, -1] / sum(Vectors[:, -1])
self.vectorStorage.append(v)
totaltime = time.time() - start
if self.verbose:
print "Restart #: %4i, eValue = %8.5f, std.dev. = %6.4f," % (
self.r, self.mean[-1], self.std[-1]),
print " residual = %8.4E, time: %8.3f sec" % (
self.residual[-1], totaltime)
if self.residual[-1] < 1e-12:
print "I'm stopping restarting because residual is too small"
break
elif self.H[self.k, self.k - 1] < 1e-12:
print "I finished because H[%i,%i] = %8.4E < 1E-12" % (
self.k + 1, self.k, self.H[self.k, self.k - 1])
break
else:
q = fissionSource.histogramSource(abs(Vectors[:, -1]),
self.geo)
return Values, Vectors
def ERAM(self, q, R, inactiveR, Iterations):
"""
ERAM is Explicitly Restarted Arnoldi's Method. It is similar to
self.arnoldi() except it calculates a new starting source after a few
iterations. ERAM returns the estimated eigenvalues and eigenvectors.
q: fissionSource object, starting source vector
R: How many Arnoldi Restarts
inactiveR: The number of Restarts to throw away
Iterations: How many Arnoldi Iterations between restarts
"""
self.eValues = []
self.mean = []
self.std = []
start = time.time()
# Inactive Restarts
for i in xrange(inactiveR):
Values, Vectors = self.arnoldi(q, Iterations)
q = fissionSource.histogramSource(abs(Vectors[:,-1]), self.geo)
for self.r in xrange(1, R+1):
Values, Vectors = self.arnoldi(q, Iterations)
self.eValues.append(Values)
self.mean.append(scipy.mean(self.eValues,0)[-1])
self.std.append((1/math.sqrt(self.r))*scipy.std(self.eValues,0)[-1])
self.histList.append(self.resHist)
if isinstance(self.vectorStorage, list):
v = Vectors[:,-1]/sum(Vectors[:,-1])
self.vectorStorage.append(v)
totaltime = time.time()-start
if self.verbose:
print "Restart #: %4i, eValue = %8.5f, std.dev. = %6.4f," %(
self.r, self.mean[-1], self.std[-1]),
print " residual = %8.4E, time: %8.3f sec" %(
self.residual[-1], totaltime)
if self.residual[-1] < 1e-12:
print "I'm stopping restarting because residual is too small"
break
elif self.H[self.k, self.k-1] < 1e-12:
print "I finished because H[%i,%i] = %8.4E < 1E-12" %(self.k+1,
self.k, self.H[self.k,self.k-1])
break
else:
q = fissionSource.histogramSource(abs(Vectors[:,-1]), self.geo)
return Values, Vectors
def main():
halfwidth = 0.5
iterations = 100
xs = CrossSection.CrossSection(xS=0.5, nu=1.0, xF=0.5, xG=0)
print "Cross Section: %s" %xs
Chart = Gnuplot.Gnuplot()
title = "100 iterations max"
Chart.title(title)
Chart.xlabel("Number of Bins (length of vectors)")
Chart.ylabel("Dominant eigenvalue")
Chart("set yrange[0.35:]")
Histories = [500, 1000, 5000, 10000]
Zones = [5, 10, 20, 30, 50, 75, 100, 200, 500]
for h in Histories:
eValues = []
for z in Zones:
geo = Geometry.Geometry(z, [[-halfwidth, halfwidth]])
print "geoL %s\nHistories per iteration = %i" %(geo, h)
uni = scipy.ones(geo.bins)
uSource = fissionSource.histogramSource(uni, geo)
mark = Markov.Markov(geo, xs, h)
amc = arnoldiMC.arnoldiMC(mark)
amc.arnoldi(uSource, iterations)
eValues.append(amc.eValue)
eData = Gnuplot.Data(Zones, eValues, with="lines", title="# histories: %i" %h)
Chart.replot(eData)
def main(self):
bins = 50
halfwidth=0.5
histories = 10000
iterations = 50
restarts = 5
geo = Geometry.Geometry(bins, [[-halfwidth,halfwidth]])
xs = CrossSection.CrossSection(xS=0.5,nu=1.0,xF=0.5,xG=0)
self.mark = Markov.Markov(geo, xs, histories)
self.mark.score = self.score
self.Q = scipy.zeros((bins,0))
for i in xrange(bins):
print "I am at %i" %i
point = scipy.zeros((bins))
point[i] = 1
pSource = fissionSource.histogramSource(point,geo)
self.response = fissionBank.fissionBank()
self.mark.transport(pSource)
q = fissionSource.histogramSource(self.response,geo)
q = q*(1.0/self.mark.histories)
self.printVector(q)
self.Q = scipy.column_stack((self.Q,q))
q = scipy.ones(bins)
q = q/scipy.linalg.norm(q,2)
print "Calling Deterministic Arnoldi"
adtm = ArnoldiDtm.Arnoldi(self.Q, iterations, restarts)
eValues, eVectors = adtm.Arnoldi(q)
print "Eigenvalues: "
self.printVector(eValues)
print "Dominant eigenvector: "
self.printVector(eVectors[:,-1])
print "\nAll eigenvectors: "
self.printM(eVectors)
Chart = Gnuplot.Gnuplot()
Chart.title("Histories per 'vector': %i, bins = %i" %(histories, bins))
length = len(eValues)-1
for i in xrange(5):
data = Gnuplot.Data(eVectors[:,length-i],with='lines',
title='vector %i' %i)
Chart.replot(data)
def main():
histories = 10000
iterations = 10
xs = CrossSection.CrossSection(xS=0.5, nu=1.0, xF=0.5, xG=0)
geo = Geometry.Geometry(10,[[-0.5, 0.5]])
uni = scipy.ones(geo.bins)
point = scipy.zeros(geo.bins)
point[0] = 1
uSource = fissionSource.histogramSource(uni,geo)
pSource = fissionSource.histogramSource(point,geo)
uSource = uSource/scipy.linalg.norm(uSource,2)
mark = Markov.Markov(geo,xs, histories)
amc = arnoldiMC.arnoldiMC(mark)
# calc_eVector(amc)
EigenPairs(amc)
def main():
histories = 10000
iterations = 10
xs = CrossSection.CrossSection(xS=0.5, nu=1.0, xF=0.5, xG=0)
geo = Geometry.Geometry(10, [[-0.5, 0.5]])
uni = scipy.ones(geo.bins)
point = scipy.zeros(geo.bins)
point[0] = 1
uSource = fissionSource.histogramSource(uni, geo)
pSource = fissionSource.histogramSource(point, geo)
uSource = uSource / scipy.linalg.norm(uSource, 2)
mark = Markov.Markov(geo, xs, histories)
amc = arnoldiMC.arnoldiMC(mark)
# calc_eVector(amc)
EigenPairs(amc)
def makeFSource(geo):
"""
"""
pSource = scipy.zeros(geo.bins)
mid = int(geo.bins/2)
pSource[mid] = 1
hs = fissionSource.histogramSource(pSource, geo)
return hs
def __init__(self, usage=None, version=None):
"""
__init__ will create all the necessary information you need to run the code.
It parses the command line to understand all your options.
"""
if not usage:
usage = 'usage: %prog [options] args'
optparse.OptionParser.__init__(self, usage=usage, version=version)
self.add_option("-f", "--file", dest="filename", type='string',
default=None, help="gnuplot data filename")
self.add_option("-b", "--bins", dest="bins", type="int", default="50",
help="Number of spatial bins.")
self.add_option("-w", "--width", dest="width", type="float", default="20",
help="Width of slab.")
self.add_option("-I", "--iterations", dest="I", type="string",
default='[3, 5, 7, 10, 15, 20]',
help="How many Arnoldi Iterations per trial.")
self.add_option("-T", "--trials", dest="Trials", type="float", default=100,
help="How many independent trials.")
self.add_option("-r", "--run", dest="run", action="store_true", default=False,
help="Perform calculation.")
self.add_option("-s", "--source", dest="source", type="string",
default='uniform',
help="""Defines source distribution. Available sources:
'uniform' --- uniform distrbution
'pleft' --- point source in left most bin
'pright' --- point source in right most bin
'pcenter' --- point source in center bin""")
self.options, self.args = self.parse_args()
self.geo = Geometry.Geometry(self.options.bins, [[0,self.options.width]])
self.xs = CrossSection.CrossSection(xS=0.5, nu=1.0, xF=0.5, xG=0)
if self.options.source == 'uniform':
s = scipy.ones(self.options.bins)
elif self.options.source == 'pleft':
s = scipy.zeros(self.options.bins)
s[0] = 1
elif self.options.source == 'pright':
s = scipy.zeros(self.options.bins)
s[-1] = 1
elif self.options.source == 'pcenter':
mid = int(self.options.bins/2.0)
s = scipy.zeros(self.options.bins)
s[mid] = 1
else:
s = eval(self.options.source)
try:
self.source = fissionSource.histogramSource(s, self.geo)
except:
raise ValueError, "Unsupported source distribution: %s" %self.options.source
self.options.I = eval(self.options.I)
def main():
N = int(1E6)
geo = Geometry.Geometry(10, [[-0.5, 0, 5]])
uni = scipy.ones(10)
uSource = fissionSource.histogramSource(uni, geo)
start = time.time()
uSource.sample(N)
end = time.time()
elapsedTime = end - start
print "Elapsedtime to sample %i neutrons: %s" % (N, elapsedTime)
def main():
N = int(1E6)
geo = Geometry.Geometry(10,[[-0.5,0,5]])
uni = scipy.ones(10)
uSource = fissionSource.histogramSource(uni, geo)
start = time.time()
uSource.sample(N)
end = time.time()
elapsedTime = end - start
print "Elapsedtime to sample %i neutrons: %s" %(N, elapsedTime)
def main():
xs = CrossSection.CrossSection(xS=0.5, nu=1.0, xF=0.5, xG=0)
halfWidth = [0.5, 1.0, 5.0, 10.0, 30.0]
# xs = CrossSection.CrossSection(xS=0)
# halfWidth=[300]
c = [1.615379, 1.277102, 1.024879, 1.007135, 1.0]
histories = 1000
in_cycles = 5
a_cycles = 50
# n = particle.neutron()
# bank = fissionBank.fissionBank()
# bank.append(n,histories)
# for part in bank:
# part.setRandDirection()
chart = Gnuplot.Gnuplot()
chart.xlabel("Cycles")
chart.ylabel("k-effective")
chart.title("Histories = %i, Inactive Cycles = %i, Active Cycles = %i"
%(histories, in_cycles, a_cycles))
chart("set key right bottom")
chart("set yrange [0:*]")
for i in xrange(len(halfWidth)):
geo = Geometry.Geometry(10,[[-halfWidth[i], halfWidth[i]]])
print "xs: %s" %xs
print "geo: %s" %geo
print "Histories = %i" %histories
source = makeFBank(histories)
source = makeFSource(geo)
pmc = powerMC.powerMC(geo, xs, in_cycles, a_cycles, histories)
pmc.power(source)
kbench = 1/(2*c[i] - 1)
print "halfWidth: %s, k-benchmark: %8.6f" %(halfWidth[i], kbench)
print "k-estimate = %8.6f, std.dev-est = %8.6E" %(pmc.k, math.sqrt(pmc.vark))
print "left-leakage: %i, right-leakage: %i, weight-killed: %i" %(
pmc.minLeakage, pmc.maxLeakage, pmc.wgtKilled)
data = Gnuplot.Data((pmc.k_inactive+pmc.convergence), with="lines",
title="kest=%.6f, kvarest=%.2E, kcalc=%.6f" %(pmc.k,
pmc.vark, kbench))
cycleData = Gnuplot.Data((pmc.k_inactive+pmc.cycle_k), with="points",
title="cycle estimates")
chart.replot(data, cycleData)
srcChart = Gnuplot.Gnuplot()
hs = fissionSource.histogramSource(pmc.source, pmc.geo)
sourceData = Gnuplot.Data(hs, with='lines')
def Aq(self, Q):
"""
Aq will operate on Q by the linear operator A.
In Monte Carlo, this is just solving the transport equation.
Q: Fission source
"""
# Transport Bank
qPos = copy.deepcopy(Q)
qNeg = copy.deepcopy(Q)
for i in xrange(len(qPos)):
if qPos[i] < 0:
qPos[i] = 0
qNeg = qPos - qNeg
if sum(qPos) > 0:
self.Bank = fissionSource.histogramSource(
scipy.zeros(self.geo.bins), self.geo)
self.transport(qPos)
nextPos = self.Bank*sum(qPos)/self.histories
else:
nextPos = fissionSource.histogramSource(
scipy.zeros(self.geo.bins), self.geo)
if sum(qNeg) > 0:
self.Bank = fissionSource.histogramSource(
scipy.zeros(self.geo.bins), self.geo)
self.transport(qNeg)
nextNeg = self.Bank*sum(qNeg)/self.histories
else:
print "No negative sources."
nextNeg = fissionSource.histogramSource(
scipy.zeros(self.geo.bins), self.geo)
q = (nextPos - nextNeg)
self.oQ.append(q)
return q
def Aq(self, Q):
"""
Aq will operate on Q by the linear operator A.
In Monte Carlo, this is just solving the transport equation.
Q: Fission source
"""
# Transport Bank
qPos = copy.deepcopy(Q)
qNeg = copy.deepcopy(Q)
for i in xrange(len(qPos)):
if qPos[i] < 0:
qPos[i] = 0
qNeg = qPos - qNeg
if sum(qPos) > 0:
self.Bank = fissionSource.histogramSource(
scipy.zeros(self.geo.bins), self.geo)
self.transport(qPos)
nextPos = self.Bank * sum(qPos) / self.histories
else:
nextPos = fissionSource.histogramSource(scipy.zeros(self.geo.bins),
self.geo)
if sum(qNeg) > 0:
self.Bank = fissionSource.histogramSource(
scipy.zeros(self.geo.bins), self.geo)
self.transport(qNeg)
nextNeg = self.Bank * sum(qNeg) / self.histories
else:
print "No negative sources."
nextNeg = fissionSource.histogramSource(scipy.zeros(self.geo.bins),
self.geo)
q = (nextPos - nextNeg)
self.oQ.append(q)
return q
def power(self, source):
"""
power is the main method for this algorithm
source: Initial guess of fission source
"""
# Initialize
self.k = 1
self.cycle_k = [] # list of eigenvalues per iteration
self.convergence = []
self.sd = [] # list of standard deviaiton per iterations
self.k_inactive = []
self.vectorStorage = []
self.source = source
start = time.time()
elapsed = 0
totaltime = 0
for i in xrange(1, self.inactive + 1):
self.nextBank = fissionBank.fissionBank()
self.transport(self.source)
self.k = self.k * len(self.nextBank) / float(self.histories)
self.k_inactive.append(self.k)
totaltime = time.time() - start
print "iteration: %5i, eigenvalue = %8.6f," % (i, self.k),
print " time: %8.3f sec" % (totaltime)
self.source = self.nextBank
print "------- Starting active cycles -------"
for self.i in xrange(1, self.active + 1):
self.nextBank = fissionBank.fissionBank()
self.transport(self.source)
self.k = (self.k * len(self.nextBank) / float(self.histories))
self.cycle_k.append(self.k)
self.convergence.append(scipy.mean(self.cycle_k))
self.sd.append((1 / math.sqrt(self.i)) * scipy.std(self.cycle_k))
totaltime = time.time() - start
print "iteration: %5i, eigenvalue = %8.6f," % (self.i, self.k),
print " std.dev = %6.4f, time: %8.3f sec" % (scipy.std(
self.convergence), totaltime)
self.source = self.nextBank
Y = fissionSource.histogramSource(self.source, self.geo)
Y = Y / sum(Y)
self.vectorStorage.append(Y)
def Aq_OneSource(self, Q):
"""
This is just like Aq, but it passes one source (both positive and
negative to be transported, instead of doing two sepaate runs.
Aq will operate on Q by the linear operator A.
In Monte Carlo, this is just solving the transport equation.
Q: Fission source
"""
# Transport Bank
self.Bank = fissionSource.histogramSource(
scipy.zeros(self.geo.bins), self.geo)
self.transport(Q)
# Make fissionSource
Qsum = sum(abs(Q))
q = self.Bank*(Qsum/self.histories)
self.oQ.append(q)
return q
def Aq_OneSource(self, Q):
"""
This is just like Aq, but it passes one source (both positive and
negative to be transported, instead of doing two sepaate runs.
Aq will operate on Q by the linear operator A.
In Monte Carlo, this is just solving the transport equation.
Q: Fission source
"""
# Transport Bank
self.Bank = fissionSource.histogramSource(scipy.zeros(self.geo.bins),
self.geo)
self.transport(Q)
# Make fissionSource
Qsum = sum(abs(Q))
q = self.Bank * (Qsum / self.histories)
self.oQ.append(q)
return q
def dummy(self, hw, Chart, title='None'):
"""
hw: Halfwidth of geometry
Chart: Gnuplot object where plotting occurs.
title: Title of plot, if None, title will be eigenvalue
"""
valuesvsBins = []
for bin in self.Bins:
print "Bins = %i" %bin
geo = Geometry.Geometry(bin, [[-hw,hw]])
mark = Markov.Markov(geo, self.xs, self.histories)
amc = arnoldiMC.arnoldiMC(mark)
uSource = fissionSource.histogramSource(scipy.ones(bin))
Values, Vectors = amc.arnoldi(uSource, self.iterations)
valuesvsBins.append(Values[-1])
title = 'hw = %.2f' %hw
kData = Gnuplot.Data(self.Bins, valuesvsBins, with='lines',
title=title)
Chart.replot(kData)
return Chart
def Orthogonal(self, hw, bins):
"""
Orthogonal will run Arnoldi's method and determine if the basis vectors
are orthogonal.
hw: halfwidth of geometry
bins: number of spatial bins
"""
geo = Geometry.Geometry(bins, [[-hw, hw]])
mark = Markov.Markov(geo, self.xs, self.histories)
amc = arnoldiMC.arnoldiMC(mark)
uSource = fissionSource.histogramSource(scipy.ones(bins))
Values, Vectors = amc.ERAM(uSource, 5, self.iterations)
# Values, Vectors = amc.arnoldi(uSource, self.iterations)
n = len(amc.Q)
O = scipy.zeros((n, n))
for i in xrange(n):
for j in xrange(n):
O[i, j] = scipy.dot(amc.Q[i], amc.Q[j])
print "Orthogonality:"
amc.printM(O)
def Orthogonal(self, hw, bins):
"""
Orthogonal will run Arnoldi's method and determine if the basis vectors
are orthogonal.
hw: halfwidth of geometry
bins: number of spatial bins
"""
geo = Geometry.Geometry(bins, [[-hw,hw]])
mark = Markov.Markov(geo, self.xs, self.histories)
amc = arnoldiMC.arnoldiMC(mark)
uSource = fissionSource.histogramSource(scipy.ones(bins))
Values, Vectors = amc.ERAM(uSource, 5, self.iterations)
# Values, Vectors = amc.arnoldi(uSource, self.iterations)
n = len(amc.Q)
O = scipy.zeros((n,n))
for i in xrange(n):
for j in xrange(n):
O[i,j] = scipy.dot(amc.Q[i], amc.Q[j])
print "Orthogonality:"
amc.printM(O)
def main():
histories = 1000
iterations = 50
trials = 50
halfWidth = 0.5
xs = CrossSection.CrossSection(xS=0.5, nu=1.0, xF=0.5, xG=0)
print "Cross Section: %s" %xs
geo = Geometry.Geometry(100, [[-halfWidth, halfWidth]])
mark = Markov.Markov(geo,xs, histories)
uni = scipy.ones(geo.bins)
uSource = fissionSource.histogramSource(uni, geo)
Chart = Gnuplot.Gnuplot()
Chart.xlabel('Iteration')
Chart.ylabel('Eigenvalue estimate')
Chart.title('histories per Arnoldi iteration: %i' %histories)
for j in xrange(5):
eValues = []
for i in xrange(trials):
amc = arnoldiMC.arnoldiMC(mark)
amc.arnoldi(uSource, iterations)
print "eValue = %s" %amc.eValue
eValues.append(amc.eValue)
average_eValue = sum(eValues)/trials
# Calculate Variance
var_eValue = 0
for value in eValues:
var_eValue += math.pow((value - average_eValue),2)
var_eValue = var_eValue/(trials - 1)
eData = Gnuplot.Data(eValues, with='lines',
title="%6.4f, %6.4f" %(average_eValue, math.sqrt(var_eValue)))
Chart.replot(eData)
def sampleTest():
geo = Geometry.Geometry(10,[[0,1]])
histories = 100000
HSX = []
HSErrors = []
source = scipy.ones(10)
source[3:7] = source[3:7]*-1
source[2] = 3
source[5] = -3
HS = fissionSource.histogramSource(source, geo)
HS = HS/scipy.linalg.norm(HS,2)
for i in xrange(len(HS)):
HSX.append(i)
HSErrors.append(math.sqrt(abs(HS[i]))/math.sqrt(histories/geo.bins))
F1 = HS.sample(histories)
F2 = HS.sample(histories)
F3 = HS.sample(histories)
F4 = HS.sample(histories)
F5 = HS.sample(histories)
H1 = fissionSource.histogramSource(F1, geo)
H2 = fissionSource.histogramSource(F2, geo)
H3 = fissionSource.histogramSource(F3, geo)
H4 = fissionSource.histogramSource(F4, geo)
H5 = fissionSource.histogramSource(F5, geo)
H1 = H1/scipy.linalg.norm(H1,2)
H2 = H2/scipy.linalg.norm(H2,2)
H3 = H3/scipy.linalg.norm(H3,2)
H4 = H4/scipy.linalg.norm(H4,2)
H5 = H5/scipy.linalg.norm(H5,2)
Chart = prinths(HS,HSX)
printsample(H1, Chart)
printsample(H2, Chart)
printsample(H3, Chart)
printsample(H4, Chart)
printsample(H5, Chart)
printErrors(HS, HSX, HSErrors, Chart)
if __name__ == "__main__":
Chart = Gnuplot.Gnuplot()
Chart.xlabel("iteration")
Chart.ylabel("RMS Error")
Chart("set logscale y")
Chart.title("3 Restarts, 10 Iterations each")
histories = [1000, 5000, 10000, 50000, 100000]
bins = 50
halfwidth = 0.5
iterations = 3
restarts = 10
geo = Geometry.Geometry(bins, [[0, 2*halfwidth]])
xs = CrossSection.CrossSection(xS=0.5, nu=1.0, xF=0.5, xG=0)
uSource = fissionSource.histogramSource(scipy.ones(bins), geo)
# Deterministic
sn3 = procOUTSN.procOutsn(sys.argv[1])
csHeight, csCenters = sn3.coursenSNFS(geo)
snSource = fissionSource.histogramSource(csHeight, geo)
gnuData = {}
for h in histories:
print "\nHistories %i" %h
amc = arnoldiMC.arnoldiMC(geo, xs, h, storeVectors=True)
# Values, Vectors = amc.arnoldi(uSource, iterations)
Values, Vectors = amc.ERAM(uSource, restarts, iterations)
# Values, Vectors = amc.ERAM(snSource, restarts, iterations)
vAMprime = []
import procOUTSN
import gnuplotFile
if __name__ == "__main__":
Chart = Gnuplot.Gnuplot()
histories = 10000
bins = 50
iterations = 3
restarts = 10
halfwidth = 0.5
gnuData = {}
geo = Geometry.Geometry(bins, [[0, 2*halfwidth]])
xs = CrossSection.CrossSection(xS=0.5, nu=1.0, xF=0.5, xG=0)
uSource = fissionSource.histogramSource(scipy.ones(bins), geo)
amc = arnoldiMC.arnoldiMC(geo, xs, histories, storeVectors=True)
Values, Vectors = amc.ERAM(uSource, restarts, iterations)
meanVector = scipy.stats.mean(amc.vectorStorage)
vAM = abs(meanVector)/sum(abs(meanVector))
vData = Gnuplot.Data(amc.geo.centers, vAM, with='histeps',
title='Arnoldi')
v1Vect = abs(Vectors[:,-1])/sum(abs(Vectors[:,-1]))
v1Data = Gnuplot.Data(amc.geo.centers, v1Vect, with='histeps',
title = '1st Vector')
# Chart.replot(vData)
gnuData['meanV1'] = (amc.geo.centers, vAM)
# Deterministic
sn3 = procOUTSN.procOutsn("LarsenComparison/HW%.1f.OUTSN" %halfwidth)
s = scipy.rand(options.bin)
elif options.source == 'pleft':
s = scipy.zeros(options.bins)
s[0] = 1
elif options.source == 'pright':
s = scipy.zeros(options.bins)
s[-1] = 1
elif options.source == 'pcenter':
mid = int(options.bins / 2.0)
s = scipy.zeros(options.bins)
s[mid] = 1
else:
s = eval(options.source)
try:
source = fissionSource.histogramSource(s, geo)
except:
raise ValueError, "Unsupported source distribution: %s" % options.source
for key in options.__dict__:
print "%10s: %s" % (key, options.__dict__[key])
print "source %s" % source
if options.run:
# SN3
sn3 = procOUTSN.procOutsn("LarsenComparison/HW%.0f.0.OUTSN" %
(options.width / 2))
csHeight, csCenters = sn3.coursenSNFS(geo)
amc = arnoldiMC.arnoldiMC(geo,
s = scipy.rand(options.bin)
elif options.source == 'pleft':
s = scipy.zeros(options.bins)
s[0] = 1
elif options.source == 'pright':
s = scipy.zeros(options.bins)
s[-1] = 1
elif options.source == 'pcenter':
mid = int(options.bins/2.0)
s = scipy.zeros(options.bins)
s[mid] = 1
else:
s = eval(options.source)
try:
source = fissionSource.histogramSource(s, geo)
except:
raise ValueError, "Unsupported source distribution: %s" %options.source
for key in options.__dict__:
print "%10s: %s" %(key, options.__dict__[key])
print "source %s" %source
if options.run:
# SN3
sn3 = procOUTSN.procOutsn("LarsenComparison/HW%.0f.0.OUTSN" %(options.width/2))
csHeight, csCenters = sn3.coursenSNFS(geo)
amc = arnoldiMC.arnoldiMC(geo, xs, options.H, verbose=options.verbose,
storeVectors=True)