def optimize(nec_file_input, options):
evaluator = NecFileEvaluator(nec_file_input, options)
ins_sol_vec = None
if options.seed_with_input:
ins_sol_vec = evaluator.x
try:
if not options.local_search:
de_plugin = None
try:
optimizer = DE.differential_evolution_optimizer(
evaluator,
population_size=options.de_np,
f=options.de_f,
cr=options.de_cr,
show_progress=1,
insert_solution_vector=ins_sol_vec,
max_iter=options.max_iter,
dither=options.de_dither)
optimizer.run()
except KeyboardInterrupt:
evaluator.saveRestart(optimizer.population, optimizer.scores)
raise
else:
from nec import simplex
if not options.quiet: printOut("N=%d" % len(evaluator.x))
evaluator.x = simplex.fmin(evaluator,
ftol=options.local_search_tolerance,
xtol=options.local_search_tolerance,
maxfun=options.max_iter)
#evaluator.nec_file.writeNecInput("final.nec")
evaluator.evaluateFinalSolution()
except KeyboardInterrupt:
evaluator.evaluateFinalSolution(1)
finally:
evaluator.join()
def parseLogFile(filename, np, min_distance, min_dif,num_calculated):
f = open(filename,"rt")
lines = f.readlines()
f.close()
i=-1
for j in xrange(len(lines)):
if lines[j].find("Score")!=-1:
i=j
if i==-1:
return ()
printOut( i )
vars = lines[i].split()
lines = lines[i+1:]
for l in range(len(lines)):
try:
lines[l] = map(float, lines[l].split())
except:
lines[l] = lines[l].replace("None", "0")
lines[l] = map(float, lines[l].split())
lines.sort()
population = []
for l in lines:
if isAway(population, l, min_distance, min_dif,num_calculated):
population.append(l)
if len(population) == np:
break
return vars, population
def monitor(self):
while not self.stop:
sleep(1)
try:
self.lock.acquire()
max_time = self.max_time
processes = dict(self.processes)
killed = dict(self.killed)
count = self.count
finally:
self.lock.release()
c = clock()
for p in processes.keys():
diff = c - processes[p]
if ( count > 100 and diff > 10*max_time or diff > self.max_run_time ) and not p in killed:
try:
self.lock.acquire()
self.killed[p] = c
finally:
self.lock.release()
try:
printOut("Killing hanging engine\n")
p.kill()
except:
pass
def __init__(self, nec_file_input, options):
self.process_monitor = None
self.options = options
self.nec_file_input = nec_file_input
self.wire_structure = WireStructure(options)
if options.engine_takes_cmd_args == 'yes' or options.engine_takes_cmd_args == 'auto' and os.name != 'nt':
self.options.engine_takes_cmd_args = 1
else:
self.options.engine_takes_cmd_args = 0
if self.options.input:
self.html_output = HtmlOutput(self.nec_file_input.input)
try:
if self.options.param_values_file:
self.parseParameterValues(self.options.param_values_file)
self.writeParametrized("output.nec")
printOut(
"Using parameters from file: %s (see output.nec)\n" %
self.options.param_values_file)
except (AttributeError, IOError):
pass
self.nec_file_input.autoSegmentation(self.options.auto_segmentation)
self.prepareSweeps()
if self.options.debug:
printOut("Engine jobs:")
pprint.pprint(self.sweeps)
def main():
#default values
try:
options, inputs = optionParser().parse_args()
nec_file_input = NecInputFile(options.input, options.debug)
if "EVAL" in nec_file_input.cmd_options:
import shlex
options, args = optionParser().parse_args(
shlex.split(nec_file_input.cmd_options["EVAL"]))
run(nec_file_input, options)
except InputError as e:
printOut(e)
return
for inp in inputs:
if inp[0] != "-":
options.input = inp
try:
nec_file_input = NecInputFile(options.input, options.debug)
if "EVAL" in nec_file_input.cmd_options:
import shlex
options, args = optionParser().parse_args(
shlex.split(nec_file_input.cmd_options["EVAL"]))
options.input = inp
run(nec_file_input, options)
except:
traceback.print_exc()
pass
def main():
random.seed()
options, inputs = optionParser().parse_args()
try:
nec_file_input = NecInputFile(options.input, options.debug)
if "OPT" in nec_file_input.cmd_options:
import shlex
options, args = optionParser().parse_args(
shlex.split(nec_file_input.cmd_options["OPT"]))
options.agt_correction = not options.noagt_correction
options.angle_step = nec_file_input.angle_step
if options.log_file == "":
options.log_file = options.input + ".opt_log"
if options.profile:
import cProfile
cProfile.runctx('optimize(nec_file_input, options)', globals(),
locals())
else:
optimize(nec_file_input, options)
except InputError as e:
printOut(e)
return
def printFreqs(self, header=1):
lines = []
if not self.options.frequency_data:
if header:
l = " %6s%14s%6s%6s%14s%16s%11s"%(" ", "--- Gain ---", " ", " ", "-- Ratios --", "-- Impedance --", " ")
printOut( l )
lines.append(l)
l = " %6s%7s%7s%6s%6s%7s%7s%8s%8s%5s%6s"%("Freq", "Raw", "Net", "SWR", "BeamW", "F/R", "F/B", "Real", "Imag", "AGT", "corr")
printOut( l )
lines.append(l)
l = "=========================================================================="
printOut( l)
lines.append(l)
#if self.agt!=0:
# printOut( "AGT=%g dB"%self.agt)
for i in self.frequencies:
if not i.valid():
l = "%6.1f - invalid result"%i.freq
printOut( l)
lines.append(l)
else:
rear = "n/a"
back = "n/a"
raw = "n/a"
net = "n/a"
beam_width = "n/a"
if self.options.calc.gain:
raw = i.horizontalRaw(self.options.forward_dir)
net = i.net(raw)
if self.options.calc.f2r:
rear = i.rearGain(self.options.rear_angle,self.options.backward_dir)
rear = "% 7.2f"%(net-rear)
if self.options.calc.f2b:
back = i.backwardGain(self.options.backward_dir)
back = "% 7.2f"%(net-back)
raw = "% 7.2f"%raw
net = "% 7.2f"%net
if self.options.calc.beam_width:
beam_width = "% 6.1f"%i.beamWidth(self.options.forward_dir, self.options.angle_step, self.options.beamwidth_ratio)
l = " % 6.1f% 7s% 7s% 6.2f% 6s% 7s% 7s% 8.2f% 8.2f%5.2f% 6.2f"%(i.freq, raw, net,i.swr(), beam_width, rear, back, i.real, i.imag, i.AGT, i.agt)
printOut( l)
lines.append(l)
else:
if header:
l = " %6s%7s%28s%6s%16s%12s"%(" ", " ", "- - - - - - Gain - - - - - -", " ", "-- Impedance --", " ")
printOut( l )
lines.append(l)
l = " %6s%7s%7s%7s%7s%7s%6s%8s%8s%5s%6s"%("Freq", "Angle", "Goal", "Diff", "Raw", "Net", "SWR", "Real", "Imag", "AGT", "corr")
printOut( l)
lines.append(l)
l = "============================================================================"
printOut( l)
lines.append(l)
for i in self.frequencies:
if not i.valid():
l = " %6.4g - invalid result"%i.freq
printOut( l)
lines.append(l)
else:
target = self.options.frequency_data[i.freq][1]
l = " % 6.1f% 7.1f% 7.2f% 7.2f% 7.2f% 7.2f% 6.2f% 8.2f% 8.2f%5.2f% 6.2f"%(i.freq, i.angle, target, target-i.net(), i.gain, i.net(),i.swr(), i.real, i.imag, i.AGT, i.agt)
printOut( l)
lines.append(l)
return lines
for l in lines:
if isAway(population, l, min_distance, min_dif,num_calculated):
population.append(l)
if len(population) == np:
break
return vars, population
if __name__ == "__main__":
import optparse
options = optparse.OptionParser()
options.add_option("--de-np", default="50", type="int")
options.add_option("-l", "--log-file", default="opt.log")
options.add_option("-d", "--min-distance", default="10", type="int")
options.add_option("-f", "--min-dif", default=".1", type="float")
options.add_option("-n", "--num-calculated", default="8", type="int")
opts, args = options.parse_args()
p = parseLogFile(opts.log_file, opts.de_np, opts.min_distance, opts.min_dif,opts.num_calculated)
if not p:
printOut( "Failed to extract population")
else:
vars, population = p
printOut( ((len(vars))*"%9s ")%tuple(vars) )
for i in range(len(population)):
printOut( ((len(vars))*"%3.5f ")%tuple(population[i]) )
def fmin(evaluator,
xtol=1e-4,
ftol=1e-4,
maxiter=None,
maxfun=None,
full_output=0,
disp=1,
callback=None):
"""Minimize a function using the downhill simplex algorithm.
Parameters
----------
func : callable func(x,*args)
The objective function to be minimized.
x0 : ndarray
Initial guess.
args : tuple
Extra arguments passed to func, i.e. ``f(x,*args)``.
callback : callable
Called after each iteration, as callback(xk), where xk is the
current parameter vector.
Returns
-------
xopt : ndarray
Parameter that minimizes function.
fopt : float
Value of function at minimum: ``fopt = func(xopt)``.
iter : int
Number of iterations performed.
funcalls : int
Number of function calls made.
warnflag : int
1 : Maximum number of function evaluations made.
2 : Maximum number of iterations reached.
allvecs : list
Solution at each iteration.
Other Parameters
----------------
xtol : float
Relative error in xopt acceptable for convergence.
ftol : number
Relative error in func(xopt) acceptable for convergence.
maxiter : int
Maximum number of iterations to perform.
maxfun : number
Maximum number of function evaluations to make.
full_output : bool
Set to True if fval and warnflag outputs are desired.
disp : bool
Set to True to print convergence messages.
Notes
-----
Uses a Nelder-Mead simplex algorithm to find the minimum of
a function of one or more variables.
"""
fcalls, func = wrap_function(evaluator.target)
x0 = evaluator.x
#x0 = asfarray(x0).flatten()
N = len(x0)
if maxiter is None:
maxiter = N * 200
if maxfun is None:
maxfun = N * 200
rho = 1
chi = 2
psi = 0.5
sigma = 0.5
one2np1 = range(1, N + 1)
sim = []
fsim = [.0] * (N + 1)
for i in range(0, N + 1):
sim.append([.0] * (N + 1))
sim[0] = x0
fsim[0] = func(x0)
nonzdelt = 0.05
zdelt = 0.00025
for k in range(0, N):
y = list(x0)
if y[k] != 0:
y[k] = (1 + nonzdelt) * y[k]
else:
y[k] = zdelt
sim[k + 1] = y
f = func(y)
fsim[k + 1] = f
ind = sort_permutation(fsim)
fsim = apply_permutation(fsim, ind)
# sort so sim[0,:] has the lowest function value
sim = apply_permutation(sim, ind)
evaluator.x = sim[0]
iterations = 1
while (fcalls[0] < maxfun and iterations < maxiter):
sim_size = max(
map(lambda x: max(map(abs, map(operator.sub, x, sim[0]))),
sim[1:]))
#print "The simplex size is %.6g(tol=%.6g)"%(sim_size,xtol)
fsim_size = max(map(lambda x: abs(x - fsim[0]), fsim[1:]))
#print "The simplex image size is %.6g(tol=%.6g)"%(fsim_size, ftol)
if ( sim_size <= xtol ) \
and fsim_size <=ftol:
break
# if (max(numpy.ravel(abs(sim[1:]-sim[0]))) <= xtol \
# and max(abs(fsim[0]-fsim[1:])) <= ftol):
# break
xbar = averageArrays(sim[:-1])
xr = linearCombine((1 + rho), xbar, -rho, sim[-1])
fxr = func(xr)
doshrink = 0
if fxr < fsim[0]:
xe = linearCombine((1 + rho * chi), xbar, -rho * chi, sim[-1])
fxe = func(xe)
if fxe < fxr:
sim[-1] = xe
fsim[-1] = fxe
else:
sim[-1] = xr
fsim[-1] = fxr
else: # fsim[0] <= fxr
if fxr < fsim[-2]:
sim[-1] = xr
fsim[-1] = fxr
else: # fxr >= fsim[-2]
# Perform contraction
if fxr < fsim[-1]:
xc = linearCombine((1 + psi * rho), xbar, -psi * rho,
sim[-1])
fxc = func(xc)
if fxc <= fxr:
sim[-1] = xc
fsim[-1] = fxc
else:
doshrink = 1
else:
# Perform an inside contraction
xcc = linearCombine((1 - psi), xbar, psi, sim[-1])
fxcc = func(xcc)
if fxcc < fsim[-1]:
sim[-1] = xcc
fsim[-1] = fxcc
else:
doshrink = 1
if doshrink:
for j in one2np1:
sim[j] = linearCombine((1 - sigma), sim[0], sigma,
sim[j])
fsim[j] = func(sim[j])
ind = sort_permutation(fsim)
sim = apply_permutation(sim, ind)
fsim = apply_permutation(fsim, ind)
evaluator.x = sim[0]
if callback is not None:
callback(sim[0])
iterations += 1
x = sim[0]
fval = min(fsim)
warnflag = 0
if fcalls[0] >= maxfun:
warnflag = 1
if disp:
printOut("Warning: Maximum number of function evaluations has "\
"been exceeded.")
elif iterations >= maxiter:
warnflag = 2
if disp:
printOut("Warning: Maximum number of iterations has been exceeded")
else:
if disp:
printOut("Optimization terminated successfully.")
printOut(" Current function value: %f" % fval)
printOut(" Iterations: %d" % iterations)
printOut(" Function evaluations: %d" % fcalls[0])
if full_output:
retlist = x, fval, iterations, fcalls[0], warnflag
else:
retlist = x
return retlist
crs+=1
cr_stats.append(crs)
population.append(new_gen)
return (vars,scores, population,cr_stats)
if __name__ == "__main__":
import optparse
options = optparse.OptionParser()
options.add_option("--de-np", default="50", type="int")
options.add_option("-l", "--log-file", default="opt.log")
options.add_option("-n", "--number-of-lines", default=0,type="int")
options.add_option("-m", "--member", default=0, type="int")
options.add_option("-s", "--cr-stats", default=False, action="store_true")
opts, args = options.parse_args()
p = parseLogFile(opts.log_file, opts.de_np, opts.member, opts.number_of_lines)
if not p:
printOut( "Failed to extract history")
else:
vars,scores, population, cr_stats = p
printOut( ((len(vars)+1)*"%9s ")%tuple(["Score"]+vars))
for i in range(len(scores)):
if opts.cr_stats:
printOut( ( (len(vars)+1)*"%3.5f "+" cr=%d")%tuple([scores[i]]+population[i]+[cr_stats[i]]))
else:
printOut( ( (len(vars)+1)*"%3.5f ")%tuple([scores[i]]+population[i]) )
def evaluate(self):
NOP = NecOutputParser
results = self.runSweeps() #[[174,6,8],[470,6,40]]
h = {}
v = {}
res = []
res_lines = []
printOut("Input file : %s" % self.options.input)
printOut("Freq sweeps: %s" % str(self.options.sweeps))
if self.nec_file_input.autosegment[0]:
printOut("Autosegmentation: %d per %g" %
self.nec_file_input.autosegment)
else:
printOut("Autosegmentation: NO")
printOut("\n")
self.options.angle_step = self.nec_file_input.angle_step
for r in range(len(results)):
nop = NOP(results[r][0], results[r][2], self.options)
if self.options.debug > 1:
for f in nop.frequencies:
printOut(f.horizontal)
h.update(nop.horizontalPattern())
v.update(nop.verticalPattern())
res_lines = res_lines + nop.printFreqs(r == 0)
res = res + nop.getGainSWRChartData()
if self.options.html:
# if self.options.horizontal_gain:
if not self.options.frequency_data:
self.html_output.addHPattern(self.options.sweeps, h)
# else:
# self.html_output.addVPattern(v)
self.html_output.addResults("\n".join(res_lines))
self.html_output.addNec(self.nec_file_input.parametrizedLines())
if not self.options.frequency_data:
self.html_output.addGainChart(self.options.sweeps, res,
self.options.char_impedance)
self.html_output.writeToFile(self.options.input + ".html",
self.options.publish)
options.add_option("-N",
"--output-line-numbers",
default=False,
action="store_true")
options.add_option("-c", "--generation-count", default=0, type="int")
options.add_option("-r",
"--restart-file",
default=False,
action="store_true")
options.add_option("-s", "--stats", default=False, action="store_true")
opts, args = options.parse_args()
p = parseLogFile(opts.log_file, opts.full, opts.number_of_lines,
opts.generation_count)
if opts.progress_only: exit(0)
if not p:
printOut("Failed to extract population")
else:
vars, scores, population = p
if not opts.restart_file:
if opts.output_line_numbers:
printOut(("Num " + (len(vars) + 1) * "%9s ") %
tuple(["Score"] + vars))
for i in range(len(scores)):
printOut(("[%03d]. " + (len(vars) + 1) * "%3.5f ") %
tuple([i] + [scores[i]] + population[i]))
else:
printOut(((len(vars) + 1) * "%9s ") % tuple(["Score"] + vars))
for i in range(len(scores)):
printOut(((len(vars) + 1) * "%3.5f ") %
tuple([scores[i]] + population[i]))
if opts.restart_file:
def parse_args(self, extra_args=[]):
options, args = ne.OptionParser.parse_args(self, extra_args)
if not options.sweeps: return (options, args)
if options.target_function:
options.target_function = options.target_function.strip('"')
options.target_function = options.target_function.strip("'")
if options.target_levels:
options.target_levels = self.convertToListOfLists(
list(map(eval, options.target_levels)))
options.parameters = options.parameters.replace(',', ' ').split()
if options.output_population:
sys.stderr.write("WARNING: --output-population is IGNORED.\n")
options.output_population = False
if options.quiet and options.verbose:
sys.stderr.write(
"WARNING: Both quite and verbose mode specified. Will use verbose.\n"
)
options.quiet = False
if options.parameters:
if not options.quiet:
printOut("Parameters restricted to " +
str(options.parameters))
if options.output_best == -1:
if options.local_search: options.output_best = 0
else: options.output_best = 1
printOut("Output best set to: %d" % options.output_best)
options.html = ""
if options.sweeps and len(options.sweeps) != len(
options.target_levels) and not options.frequency_data:
if len(options.target_levels) == 0:
options.target_levels = len(options.sweeps) * [[0]]
else:
raise InputError(
"The number of sweep ranges is not matching the number of target options"
)
if options.sweeps:
if options.swr_target:
options.swr_target = self.convertToListOfLists(
list(map(eval, options.swr_target)),
len(options.sweeps), 2)
else:
options.swr_target = self.convertToListOfLists(
[], len(options.sweeps), 2)
if options.f2r_target:
options.f2r_target = self.convertToListOfLists(
list(map(eval, options.f2r_target)),
len(options.sweeps), 15)
else:
options.f2r_target = self.convertToListOfLists(
[], len(options.sweeps), 2)
if options.f2b_target:
options.f2b_target = self.convertToListOfLists(
list(map(eval, options.f2b_target)),
len(options.sweeps), 15)
else:
options.f2b_target = self.convertToListOfLists(
[], len(options.sweeps), 2)
class Calc:
pass
options.calc = Calc()
options.calc.beam_width = (
options.target_function.find("beam_width") != -1)
options.calc.f2r = (options.target_function.find("f2r") != -1)
options.calc.f2b = (options.target_function.find("f2b") != -1)
options.calc.gain = (
options.target_function.find("gain") != -1
) or options.calc.f2r or options.calc.f2b or options.calc.beam_width or options.omni
options.forward = not (options.calc.f2b or options.calc.f2r
or options.omni or options.frequency_data
or options.calc.beam_width)
if not options.quiet:
printOut("Sweeps set to:")
printOut(options.sweeps)
if not options.quiet:
printOut("Target levels set to:")
printOut(options.target_levels)
if not options.quiet:
printOut("SWR target level set to: %s:" %
str(options.swr_target))
if options.calc.f2r:
if not options.quiet:
printOut("F/R target level set to: %s:" %
str(options.f2r_target))
if options.calc.f2b:
if not options.quiet:
printOut("F/B target level set to: %s:" %
str(options.f2b_target))
if not options.quiet:
printOut("Target function set to \"%s\"" %
options.target_function)
if not options.quiet:
if not options.noagt_correction:
printOut("use-agt-correction set to 1")
else:
printOut("use-agt-correction set to 0")
return (options, args)
def __init__(self, nec_file_input, options):
#.input, options.output,options.auto_segmentation, options.sweeps, options.target_levels,options.num_cores, options.log_file, options.target_function
self.log = None
self.options = options
self.char_impedance = options.char_impedance
self.nec_file_input = nec_file_input
self.nec_evaluator = ne.NecEvaluator(nec_file_input, options)
from nec.process_monitor import ProcessMonitor
self.nec_evaluator.process_monitor = ProcessMonitor(
options.engine_kill_time)
#print "calculate_gain set to: %d"%self.options.calc.gain
self.opt_vars = []
self.domain = []
for k in self.nec_file_input.min_max.keys():
if not self.options.parameters or k in self.options.parameters:
self.opt_vars.append(k)
self.domain.append(self.nec_file_input.min_max[k])
self.n = len(self.opt_vars)
# self.domain = self.n*[[-1,1]]
self.enforce_domain_limits = True
self.x = []
self.best_score = 999.0
for i in range(len(self.opt_vars)):
var = self.opt_vars[i]
self.x.append(self.nec_file_input.vars[var])
self.x = self.paramsBackTransform(self.x)
if options.restart:
self.initial_population, self.initial_scores = self.parseInitialPopulation(
options.restart)
else:
self.initial_population = []
self.initial_scores = []
self.comments = [""]
self.comments.append("Input file: " + options.input)
self.comments.append("Sweep ranges: ")
self.errors = 1
for i in range(len(self.options.sweeps)):
self.comments.append("R%d = " % i + str(self.options.sweeps[i]))
if not self.options.frequency_data:
self.comments[-1] += (" with target levels " +
str(self.options.target_levels[i]))
if self.options.frequency_data:
self.comments.append(" Frequency angle/gain data: ")
self.comments.append(str(self.options.frequency_data))
self.comments.append("SWR target: %s" % str(self.options.swr_target))
self.comments.append("Target function: %s" %
self.options.target_function)
if self.nec_file_input.autosegment[0]:
printOut("Autosegmentation: %d per %g" %
self.nec_file_input.autosegment)
self.comments.append("Autosegmentation: %d per %g" %
self.nec_file_input.autosegment)
else:
printOut("Autosegmentation: NO")
self.comments.append("Autosegmentation: NO")
printOut("\n")
self.comments.append("")
self.agt_score_threshold = .0
self.agt_score_threshold_stat1 = .0
self.agt_score_threshold_stat_count1 = 0
self.agt_score_threshold_stat2 = .0
self.agt_score_threshold_stat_count2 = 0
if options.log_file:
self.log = open(options.log_file, "at")
self.log.write("============" * 10 + "\n")
self.log.write("\n".join(self.comments))
self.log.write("============" * 10 + "\n")
range_scores = []
for i in range(len(self.options.sweeps)):
range_scores.append("R%dmg" % i)
range_scores.append("R%dag" % i)
range_scores.append("R%dms" % i)
range_scores.append("R%das" % i)
self.log.write(
self.nec_evaluator.formatName("Score") + "\t" + "\t".join(
map(self.nec_evaluator.formatName, sorted(
self.opt_vars))) + "\t" +
"\t".join(map(self.nec_evaluator.formatName, range_scores)) +
"\n")
self.log.flush()
self.time = time.time()
self.start_time = self.time
def print_status(self, minv, meanv, vector, count, improved):
t = time.time()
t -= self.time
self.time += t
if self.log:
self.log.write("#Total time %d sec., Iteration time %d sec.\n" %
(int(self.time - self.start_time), t))
if self.options.quiet: return
vector = self.paramsTransform(vector)
z = sorted(zip(self.opt_vars, vector))
sorted_vars = [x[0] for x in z]
sorted_vect = [x[1] for x in z]
if self.options.verbose:
printOut(
"====================================================================="
)
else:
sys.stdout.write('\n')
if not improved:
printOut("% 5s. Min score %g, Mean score %g, IterTime(%d sec)" %
(str(count), minv, meanv, int(t)))
else:
printOut(
"% 5s. Min score %g, Mean score %g, Improved %d members, IterTime(%d sec)"
% (str(count), minv, meanv, improved, int(t)))
if self.options.verbose:
printOut("\t".join(map(self.nec_evaluator.formatName,
sorted_vars)))
if self.options.verbose:
printOut("\t".join(
map(self.nec_evaluator.formatNumber, sorted_vect)))
if self.options.verbose:
printOut(
"====================================================================="
)
def printLog(self, vector, res, range_results):
z = sorted(zip(self.opt_vars, vector))
sorted_vars = [x[0] for x in z]
sorted_vect = [x[1] for x in z]
if self.options.verbose:
printOut("\t".join(map(self.nec_evaluator.formatName,
sorted_vars)))
printOut("\t".join(
map(self.nec_evaluator.formatNumber, sorted_vect)))
printOut(res)
printOut("\n")
elif not self.options.quiet:
sys.stdout.write('.')
sys.stdout.flush()
if self.log:
self.logParamVector(sorted_vect, res, range_results)
self.log.flush()
if res < self.best_score:
self.best_score = res
if self.options.output_best:
fn = ("best%.3f" % res)
fn = fn.replace(".-", "-")
fn = fn.replace(".", "_")
fn = fn + ".nec"
self.nec_evaluator.writeParametrized(fn,
comments=self.comments +
["Score %g" % res, ""])
if self.options.quiet:
printOut("Best score : %.5f" % res)
elif self.options.local_search and not self.options.verbose:
printOut("\nBest score : %.5f" % res)
def target_(self, vector, get_agt_score, use_agt, id):
class ExtensibleRangeResult:
def __init__(self):
self.data = {}
def add(self, param, value):
if param not in self.data:
self.data[param] = [value]
else:
self.data[param].append(value)
def max(self, param):
if param not in self.data:
return 1000
return max(self.data[param])
def min(self, param):
if param not in self.data:
return -1000
return min(self.data[param])
def ave(self, param):
if param not in self.data:
return 0
return sum(self.data[param]) / len(self.data[param])
def aveLog(self, param): #for 10*log10 values like gain
if param not in self.data:
return 0
return 10 * math.log10(
sum(map(lambda x: math.pow(10, x / 10), self.data[param]))
/ len(self.data[param]))
def sum(self, param):
if param not in self.data:
return 0
return sum(self.data[param])
def sumPow(self, param): #for 10*log10 values like gain
if param not in self.data:
return 0
return sum(
map(lambda x: math.pow(10, x / 10), self.data[param]))
def size(self, param):
if param not in self.data:
return 0
return len(self.data[param])
range_results = []
for i in range(len(self.options.sweeps)):
range_results.append(ExtensibleRangeResult())
vector = self.paramsTransform(vector)
for i in range(len(self.opt_vars)):
var = self.opt_vars[i]
self.nec_file_input.vars[var] = vector[i]
#print "in target_ : Get agt score = %d"%get_agt_score
results = self.nec_evaluator.runSweeps(get_agt_score, use_agt, id)
res = -1000
agts = {}
if not results:
if self.options.verbose: printOut("writing erroneous file...")
try:
self.nec_evaluator.writeParametrized("error%d.nec" %
self.errors)
if self.options.verbose: printOut("done")
except:
if self.options.verbose: printOut("failed")
if self.options.stop_on_error: sys.exit(1)
else:
#agts = [1.0]*len(results)
NOP = ne.NecOutputParser
try:
for r in results:
nop = NOP(r[0], r[2], self.options)
#print "output parsed"
sweepid = r[1]
agts[r[3]] = r[2]
#print "Freqs # = %d"%len(nop.frequencies)
for freq in nop.frequencies:
freqid = self.freqID(freq.freq, sweepid)
if self.options.frequency_data:
tl = self.options.frequency_data[freq.freq][1]
else:
tl = self.targetLevel(freqid[0], freqid[1],
self.options.target_levels)
if self.options.calc.gain:
raw_gain = freq.forwardRaw(
self.options.forward_dir)
else:
raw_gain = 0
net = freq.net(raw_gain)
gain_diff = tl - net
range_results[freqid[0]].add("gain_diff", gain_diff)
range_results[freqid[0]].add("net_gain", net)
range_results[freqid[0]].add("raw_gain", raw_gain)
swr = freq.swr()
swr_target = self.targetLevel(freqid[0], freqid[1],
self.options.swr_target)
swr_diff = (swr - swr_target)
range_results[freqid[0]].add("swr_diff", swr_diff)
range_results[freqid[0]].add("swr", swr)
if self.options.calc.f2r:
rear = freq.rearGain(self.options.rear_angle,
self.options.backward_dir)
if rear is None:
raise RuntimeError("Failed to calculate F/R")
else:
rear = 0
if self.options.calc.beam_width:
beam = freq.beamWidth(self.options.forward_dir,
self.options.angle_step,
self.options.beamwidth_ratio)
range_results[freqid[0]].add("beam_width", beam)
#print "freq %g, target level %g, net %g, freqno %d, gaindiff %g, swrdiff %g"%(freq.freq, tl, freq.net(),freqid[0], gain_diff, swr_diff)
f2r = (net - rear)
f2r_target = self.targetLevel(freqid[0], freqid[1],
self.options.f2r_target)
f2r_diff = f2r_target - f2r
range_results[freqid[0]].add("f2r_diff", f2r_diff)
range_results[freqid[0]].add("f2r", f2r)
if self.options.calc.f2b:
back = freq.backwardGain(self.options.backward_dir)
if back is None:
raise RuntimeError("Failed to calculate F/B")
else:
back = 0
range_results[freqid[0]].add("back", back)
range_results[freqid[0]].add("rear", rear)
f2b = (net - back)
f2b_target = self.targetLevel(freqid[0], freqid[1],
self.options.f2b_target)
f2b_diff = f2b_target - f2b
range_results[freqid[0]].add("f2b_diff", f2b_diff)
range_results[freqid[0]].add("f2b", f2b)
ml = raw_gain - net
range_results[freqid[0]].add("ml", ml)
range_results[freqid[0]].add("real", freq.real)
range_results[freqid[0]].add("imag", freq.imag)
range_results[freqid[0]].add("agt_correction",
freq.agt)
if self.options.omni:
by_angle_net = [
freq.horizontalRaw(a) - ml
for a in sorted(freq.horizontal.keys())
]
by_angle_gain_diff = [
tl - (freq.horizontalRaw(a) - ml)
for a in sorted(freq.horizontal.keys())
]
range_results[freqid[0]].add(
"by_angle_net", by_angle_net)
range_results[freqid[0]].add(
"by_angle_gain_diff", by_angle_gain_diff)
range_results[freqid[0]].add(
"omni_net", min(by_angle_net))
range_results[freqid[0]].add(
"omni_gain_diff", max(by_angle_gain_diff))
range_results[freqid[0]].add(
"around_net",
sum(by_angle_net) / max(1, len(by_angle_net)))
range_results[freqid[0]].add(
"around_gain_diff",
sum(by_angle_gain_diff) /
max(1, len(by_angle_gain_diff)))
# range_results[freqid[0]].add(gain_diff, swr_diff, f2r_diff)
import pprint
if self.options.debug > 1:
pprint.pprint(map(lambda x: x.data, range_results))
d = {"results": [r.data for r in range_results]}
freq_count = 0
log_keys = [
"gain_diff", "net_gain", "raw_gain", "f2r_diff", "f2r",
"f2b_diff", "back", "rear", "ml"
]
exclude_keys = ["by_angle_net", "by_angle_gain_diff"]
all_keys = []
for i in range(len(self.options.sweeps)):
result = range_results[i]
c = 0
for k in result.data.keys():
if k in exclude_keys: continue
if k not in all_keys: all_keys.append(k)
if k in log_keys:
x = math.pow(10, result.max(k) / 10)
n = math.pow(10, result.min(k) / 10)
s = result.sumPow(k)
else:
x = result.max(k)
n = result.min(k)
s = result.sum(k)
c = result.size(k)
a = s / c
if "max_" + k not in d:
d["max_" + k] = x
d["ave_max_" + k] = x
d["max_ave_" + k] = a
d["ave_" + k] = s
d["min_" + k] = n
d["ave_min_" + k] = n
d["min_ave_" + k] = a
d["ave_ave_" + k] = a
else:
d["max_" + k] = max(x, d["max_" + k])
d["ave_max_" + k] += x
d["max_ave_" + k] = max(a, d["max_ave_" + k])
d["ave_" + k] += s
d["min_" + k] = min(n, d["min_" + k])
d["ave_min_" + k] += n
d["min_ave_" + k] = min(a, d["min_ave_" + k])
d["ave_ave_" + k] += a
freq_count = freq_count + c
for k in all_keys:
ns = len(self.options.sweeps)
if k in log_keys:
d["max_" + k] = 10 * math.log10(d["max_" + k])
d["ave_max_" +
k] = 10 * math.log10(d["ave_max_" + k] / ns)
d["max_ave_" + k] = 10 * math.log10(d["max_ave_" + k])
d["ave_" +
k] = 10 * math.log10(d["ave_" + k] / freq_count)
d["min_" + k] = 10 * math.log10(d["min_" + k])
d["ave_min_" +
k] = 10 * math.log10(d["ave_min_" + k] / ns)
d["min_ave_" + k] = 10 * math.log10(d["min_ave_" + k])
d["ave_ave_" +
k] = 10 * math.log10(d["ave_ave_" + k] / ns)
else:
d["ave_max_" + k] /= ns
d["ave_" + k] /= freq_count
d["ave_min_" + k] /= ns
d["ave_ave_" + k] /= ns
if self.options.debug > 1: pprint.pprint(d)
d.update(self.nec_file_input.globals)
res = eval(self.options.target_function, d)
except:
if not self.options.verbose: sys.stderr.write('\n')
traceback.print_exc()
if self.options.stop_on_error: sys.exit(1)
res = -1000
if res == -1000:
res = 1000.0
if get_agt_score:
return (res, agts)
self.printLog(vector, res, range_results)
return res
def parseLogFile(filename, full, number_of_lines, population_number):
f = open(filename, "rt")
lines = f.readlines()
f.close()
i = -1
for j in range(len(lines)):
if lines[j].find("Score") != -1:
i = j
if i == -1:
return ()
vars = lines[i].split()[1:]
lines = lines[i + 1:]
i = -1
for j in range(len(lines)):
if lines[j].find("#Total time") != -1:
i = j
break
if i == -1:
return ()
np = int(j / 2)
scores = []
population = []
for i in range(np):
ln = lines[i].split()
scores.append(float(ln[0]))
population.append(list(map(floatOrNone, ln[1:])))
lines = lines[np:]
count = 1
while len(lines):
k = []
i = 0
while i < np and i < len(lines):
if lines[i] and lines[i][0] == '#':
del lines[i]
continue
ln = lines[i].split()
s = float(ln[0])
if s < scores[i]:
k.append((i, "%.4g" % s))
scores[i] = s
population[i] = list(map(floatOrNone, ln[1:]))
i += 1
lines = lines[i:]
if not number_of_lines or len(lines) < number_of_lines * np:
if i == np:
printOut(
"Iteration %d [%.6g:%.6g] - %d new offsprings - " %
(count, min_value(scores), mean_value(scores), len(k)) +
str(k).replace("'", ""))
elif not full:
printOut(
"(*%d)Iteration %d [%.6g, %.6g] - %d new offsprings - " %
(i, count, min_value(scores), mean_value(scores), len(k)) +
str(k).replace("'", ""))
count = count + 1
if population_number and count == population_number:
break
return (vars, scores, population)
