parser.add_option("-t", "--tag", default="", type="string")
parser.add_option("-g", "--grid", default=False, action="store_true")
opts, args = parser.parse_args()
if opts.tag:
opts.tag = "."+opts.tag
if not (opts.hist or opts.dt_time):
raise StandardError, "nothing to do..."
#=================================================
### read in outfiles, get dt
if opts.verbose: print "reading data from ", opts.outfilename
t_P, q, N_m, dt = nmu.load_out(opts.outfilename, tmin=opts.tmin, tmax=opts.tmax, downsample=opts.downsample, timing=True)
if not len(dt):
raise StandardError, "could not find any integration timing information in ", opts.outfilename
#=================================================
### generate plots
### histogram dt
if opts.hist:
if opts.verbose: print "\thist"
fig = nmp.plt.figure()
ax = nmp.plt.subplot(1,1,1)
num_bin = len(dt)/opts.n_per_bin+1
if opts.log_bin:
opts.tag = "." + opts.tag
# if not opts.num_k:
# opts.num_k = np.arange(1, 25, 1)
# if not opts.Ethr:
# opts.Ethr = np.logspace(-21, -15, 100)
# if not opts.collE:
# opts.collE = np.logspace(-21, -15, 100)
# =================================================
### load data
# =================================================
if opts.verbose:
print "loading data from", opts.outfilename
t_P, q, N_m = nmu.load_out(opts.outfilename, tmin=opts.time_xmin, tmax=opts.time_xmax, downsample=opts.downsample)
if opts.verbose:
print "loading system from", opts.logfilename
system = nmu.load_log(opts.logfilename)
network = system.network
if opts.verbose:
print "decomposing network into generations"
gens, coups = network.gens()
# =================================================
### define subsets of modes
# =================================================
### pull apart by number of couplings
sys.exit("must supply exactly 2 outfilenames as arguments")
### flags for control sequences later on
stats = (opts.liapunov or opts.sum_sqr_err or opts.chi2 or opts.inner_product or opts.cross_correlation)
plots = (opts.res or opts.amp_res)
##################################################
#
# load data
#
##################################################
filename1, filename2 = args
if opts.verbose: print "loading data from", filename1
t_P1, q1, N_m1 = nmu.load_out(filename1, tmin=opts.tmin, tmax=opts.tmax, downsample=opts.downsample1)
if opts.logfilename1:
if opts.verbose: print "loading system information from", opts.logfilename1
system1 = nmu.load_log(opts.logfilename1)
if opts.verbose: print "loading data from ", filename2
t_P2, q2, N_m2 = nmu.load_out(filename2, tmin=opts.tmin, tmax=opts.tmax, downsample=opts.downsample2)
if opts.logfilename2:
if opts.verbose: print "loading system information from", opts.logfilename2
system2 = nmu.load_log(opts.logfilename2)
##################################################
#
if children.has_key("max_frac_w"):
daughter_max_frac_w = float(children["max_frac_w"])
else:
daughter_max_frac_w = 0.9
if opts.verbose: print "using DEFAULT daughter_max_frac_w=%.3f"%daughter_max_frac_w
parent_forcing = config.getboolean("inclusion","parent_forcing")
daughter_forcing = config.getboolean("inclusion","daughter_forcing")
intercouple = config.getboolean("inclusion","intercouple")
to_unique_couplings = config.getboolean("inclusion","to_unique_couplings")
### compute the threshold energies only once.
if daughter_selection == "collective":
if opts.verbose: print "reading in integration data from %s and computing energies" % opts.outfilename
E = [np.mean(a)**2 for a in nm_s.compute_A(nm_u.load_out(opts.outfilename)[1], Eo=1.0)] # growth rate depends on amplitude, so that's what we should average (not energy)
new_systems = [copy.deepcopy(system) for npairs in num_pairs]
# iterate over new parents
n_modes = len(modes)
for n_m, (O, mode) in enumerate(modes):
n, l, m, w, y = mode.get_nlmwy()
if opts.verbose: print "%d / %d :finding daughter modes\n\tfor mode: %s\n\toscillating at %fe-5 rad/%s\n\tusing %s" % (n_m+1, n_modes, mode.to_str_nlmwy(), O*1e5, nm_u.units['time'], daughter_selection)
absO = abs(O)
signO = O/absO
min_w = daughter_min_frac_w*absO
max_w = daughter_max_frac_w*absO
if daughter_selection == "collective": ### collective modes
# orbital semi-major axis
aorb, these_units = nm_u.aorb(system)
# orbital energy
Eorb, these_units = nm_u.Eorb(system)
####################################################################################################
#
#
# time domain
#
#
####################################################################################################
if time_domain:
if opts.verbose: print "loading time-domain data from %s" % opts.filename
t_P, q, N_m = nm_u.load_out(opts.filename, tmin=opts.tmin, tmax=opts.tmax, downsample=opts.tdownsample)
if not len(t_P):
raise ValueError, "no data loaded from "+opts.filename
if opts.amplitude:
if opts.verbose: print "computing mode amplitudes"
x = nm_s.compute_A(q, Eo=1.)
mA = []
sA = []
lA = []
for A in x:
mA.append( nm_s.sample_mean(A) )
sA.append( nm_s.sample_var(A, xo=mA[-1])**0.5 )
lA.append( A[-1] )
del x
if opts.convert and (not opts.target):
opts.target = raw_input("target = ")
if opts.convert and (not opts.logfilename):
opts.logfilename = raw_input("logfilename = ")
####################################################################################################
#
#
# load data
#
#
####################################################################################################
### load data
if opts.verbose: print "loading data from %s" % opts.input_filename
t_P, q, N_m = nm_u.load_out(opts.input_filename, tmin=opts.min, tmax=opts.max, downsample=opts.downsample)
if opts.convert:
if opts.verbose: print "loading network from %s" % opts.logfilename
system = nm_u.load_log(opts.logfilename)
network = system.network
####################################################################################################
#
#
# convert current -> target
#
#
####################################################################################################
if opts.convert:
if opts.verbose: print "converting variable types in time domain : %s -> %s"%(opts.current, opts.target)
#
# network downselection based on integration data
#
#
####################################################################################################
if opts.verbose: print "downselecting a subset of modes based on integration data"
if opts.verbose: print "reading in network parameters from %s" % opts.logfilename
system = nm_u.load_log(opts.logfilename)
network = system.network
Oorb = system.Oorb
Porb = 2*np.pi/Oorb
if opts.verbose: print "reading time-domain data from %s" % opts.filename
t_P, q, N_m = nm_u.load_out(opts.filename, tmin=opts.min_t_Porb, tmax=opts.max_t_Porb, downsample=opts.file_downsample)
remove = []
for Athr, method in zip(Athrs, downselection_methods):
if opts.verbose: _athr, _athrexp = nm_u.float_to_scientific(Athr)
if method == "Alast":
if opts.verbose: print "downselecting modes using %s and Athr=%fe%d" % (method, _athr, _athrexp)
remove += pn.downselect_Alast(q, Athr, network)[1]
elif method == "Amean":
if opts.verbose: print "downselecting modes using %s and Athr=%fe%d" % (method, _athr, _athrexp)
remove += pn.downselect_Amean(q, Athr, network)[1]
elif method == "Afit":
if opts.verbose: print "downselecting modes using %s and Athr=%fe%d" % (method, _athr, _athrexp)
remove += pn.downselect_Afit(q, Athr, network, t_P=t_P)[1]
else:
raise ValueError, "unknown downselection method: %s\nplease supply at last one downselection method from the following:\n\tAlst\n\tAmean\n\tAfit"
