# Immediate evaluation example
import time
start = time.time()
results = pool.map(busybeaver, range(10))
print "Time to queue the jobs:", time.time() - start
start = time.time()
# Casting the ppmap generator to a list forces each result to be
# evaluated. When done immediately after the jobs are submitted,
# our program twiddles its thumbs while the work is finished.
print list(results)
print "Time to get the results:", time.time() - start
# Delayed evaluation example
start = time.time()
results = pool.imap(busybeaver, range(10))
print "Time to queue the jobs:", time.time() - start
# In contrast with the above example, this time we're submitting a
# batch of jobs then going off to do more work while they're
# processing. Maybe "time.sleep" isn't the most exciting example,
# but it illustrates the point that our main program can do work
# before ppmap() is finished. Imagine that you're submitting some
# heavyweight image processing jobs at the beginning of your
# program, going on to do other stuff like fetching more work to
# do from a remote server, then coming back later to handle the
# results.
time.sleep(5)
start = time.time()
print list(results)
print "Time to get the first results:", time.time() - start
def sp_ant_size(
): # this function runs the availability for a single point and shows a complete output
with open('temp\\args.pkl', 'rb') as f:
(site_lat, site_long, sat_long, freq, max_eirp, sat_height, max_bw,
bw_util, modcod, pol, roll_off, ant_eff, lnb_gain, lnb_temp,
aditional_losses, cable_loss, max_depoint, max_ant_size, min_ant_size,
margin, cores) = pickle.load(f)
f.close()
#####################################
##### ground station parameters #####
#####################################
# creating a ground station object
station = GroundStation(site_lat, site_long)
##############################
### satellite parameters ###
##############################
data = pd.read_csv('models\\Modulation_dB.csv', sep=';')
line = data.loc[(data.Modcod) == modcod]
# tech = line['Tech'].values[0]
mod = line['Modulation'].values[0]
fec = line['FEC'].values[0]
# criando o objeto satélite
satellite = Satellite(sat_long, freq, max_eirp, sat_height, max_bw,
bw_util, 0, 0, mod, roll_off, fec)
# atribuindo uma estação terrena à um satélite
satellite.set_grstation(station)
##############################
### reception parametters ####
##############################
polarization_loss = 3 # perda de polarização, em dB
# criando o objeto receptor
reception = Reception(None, ant_eff, aditional_losses, polarization_loss,
lnb_gain, lnb_temp, cable_loss, max_depoint)
# atribuindo uma recepção à um enlace de satélite
satellite.set_reception(
reception) # setando o receptor do link de satélite
###################################
######### OUTPUTS #########
###################################
############ SNR target's calcullation ################
step = 0.2
interp_step = int(round((max_ant_size - min_ant_size) * 100))
ant_size_vector = np.arange(min_ant_size, max_ant_size, step)
ant_size_vector_interp = np.linspace(min_ant_size, max_ant_size,
interp_step)
# parallel loop for each antenna size
pool = ParallelPool(nodes=round(cores / 2)) #ARRUMAR AQUI
availability_vector = list(
pool.imap(loop_graph_ant_size, [(satellite, margin, 1, ant_size)
for ant_size in ant_size_vector]))
pool.clear()
ant_size_vector = np.array(ant_size_vector)
availability_vector = np.array(availability_vector)
ant_size_vector = ant_size_vector[availability_vector > 60]
availability_vector = availability_vector[availability_vector > 60]
# a_BSpline = interpolate.make_interp_spline(ant_size_vector, availability_vector, k=2)
# availability_vector_interp = a_BSpline(ant_size_vector_interp)
availability_vector_interp = 0
with open('temp\\args.pkl', 'wb') as f:
pickle.dump([
ant_size_vector, ant_size_vector_interp, availability_vector,
availability_vector_interp
], f)
f.close()
return
# Immediate evaluation example
import time
start = time.time()
results = pool.map(busybeaver, range(10))
print('Time to queue the jobs: %s' % (time.time() - start))
start = time.time()
# Casting the ppmap generator to a list forces each result to be
# evaluated. When done immediately after the jobs are submitted,
# our program twiddles its thumbs while the work is finished.
print(list(results))
print('Time to get the results: %s' % (time.time() - start))
# Delayed evaluation example
start = time.time()
results = pool.imap(busybeaver, range(10))
print('Time to queue the jobs: %s' % (time.time() - start))
# In contrast with the above example, this time we're submitting a
# batch of jobs then going off to do more work while they're
# processing. Maybe "time.sleep" isn't the most exciting example,
# but it illustrates the point that our main program can do work
# before ppmap() is finished. Imagine that you're submitting some
# heavyweight image processing jobs at the beginning of your
# program, going on to do other stuff like fetching more work to
# do from a remote server, then coming back later to handle the
# results.
time.sleep(5)
start = time.time()
print(list(results))
print('Time to get the first results: %s' % (time.time() - start))
def mp_ant_size():
with open('temp\\args.pkl',
'rb') as f: # opening the input variables in the temp file
(gr_station_path, sat_long, freq, max_eirp, sat_height, max_bw,
bw_util, modcod, pol, roll_off, ant_eff, lnb_gain, lnb_temp,
aditional_losses, cable_loss, max_depoint, availability_target,
snr_relaxation, margin, threads) = pickle.load(f)
f.close()
# reading the input table
# dir = 'models\\'
# file = 'CitiesBrazil'
# cities = pd.read_csv(dir + file + '.csv', sep=';', encoding='latin1')
# cities['availability'] = np.nan # creating an empty results column
point_list = pd.read_csv(
gr_station_path, sep=';',
encoding='latin1') # creating a point dataframe from csv file
data = pd.read_csv('models\\Modulation_dB.csv', sep=';')
line = data.loc[data.Modcod == modcod]
# tech = line['Tech'].values[0]
mod = line['Modulation'].values[0]
fec = line['FEC'].values[0]
# creating the satellite object
sat = Satellite(sat_long, freq, max_eirp, sat_height, max_bw, bw_util, 0,
0, mod, roll_off, fec)
polarization_loss = 3
reception = Reception(None, ant_eff, aditional_losses, polarization_loss,
lnb_gain, lnb_temp, cable_loss,
max_depoint) # creating the receptor object
# ======================== PARALLEL POOL =============================
pool = ParallelPool(nodes=threads) # creating the parallelPoll
sys.stderr = open('temp\\out.txt', 'w') # to print the output dynamically
print('initializing . . .', file=sys.stderr)
# running the parallel pool
data = list(
tqdm.tqdm(pool.imap(point_ant_size,
[(point, sat, reception, margin, snr_relaxation,
availability_target)
for index, point in point_list.iterrows()]),
total=len(point_list)))
pool.clear()
point_list.drop(point_list.index, inplace=True)
point_list = point_list.append(data, ignore_index=True)
# saving the results into a csv file
dir = 'results'
if not os.path.exists(dir):
os.makedirs(dir)
point_list.to_csv(dir + '\\' + 'results_ant ' +
datetime.datetime.now().strftime('%y-%m-%d_%H-%M-%S') +
'.csv',
sep=';',
encoding='latin1')
print('Complete!!!', file=sys.stderr)
sys.stderr.close()
return
