def __get_base_scenario(self, scenario):
scenario_id = -1
try:
db = config.get_db()
try:
query = """
select scenario_id
from scenario
,(
select location
from scenario
inner join footprint
using (scenario_id)
where footprint.name='study_area'
and scenario_id={scenario}
) pb
where is_base=1 and st_equals(pb.location, location)
""".format(scenario=scenario)
db.execute(query)
scenarios = db.fetchall()
scenario_id = scenarios[0][0]
db.close()
return scenario_id
except Exception as e:
LogEvents("An error happend while getting the base scenario",
str(e), -1, sys.argv[1])
db.close()
except Exception as e:
LogEvents("Unknown error", str(e), -1, sys.argv[1])
return scenario_id
def __ModulejobDensity(self, scenario_id, offset=0, limit=0):
try:
error = True
count = 0
while error and count < 3:
self.__Indicator = Indicator(self.__user)
db = self.__Indicator.get_up_calculator_connection()
try:
with transaction.atomic():
query = """select urbper_indicator_job_density({scenario},{offset},{limit})""".format(
scenario=scenario_id, offset=offset, limit=limit)
LogEvents("job density",
"job density module started: " + query,
scenario_id, self.__user)
db.execute(query)
except Exception as e:
error = True
count += 1
LogEvents(
"job density ", "job density module failed " +
str(count) + ": " + str(e), scenario_id, self.__user,
True)
db.close()
else:
error = False
LogEvents("job density ", "job density module finished",
scenario_id, self.__user)
db.close()
except Exception as e:
LogEvents("Running scenarios", "Unknown error " + str(e),
scenario_id, self.__user, True)
def run(self):
try:
error = True
count = 0
while error and count < 3:
self.__Indicator = Indicator(self.__user)
db = self.__Indicator.get_up_calculator_connection()
try:
query = """
select urbper_indicator_potable_water_network({scenario})
""".format(scenario=self.__scenario)
LogEvents("potable water network",
"potable water network module started: " + query,
self.__scenario, self.__user)
with transaction.atomic():
db.execute(query)
except Exception as e:
error = True
count += 1
time.sleep(randint(1, 3))
db.close()
LogEvents(
"potable water network",
"potable water network module failed " + str(count) +
": " + str(e), self.__scenario, self.__user)
else:
error = False
db.close()
LogEvents("potable water network",
"potable water network module finished",
self.__scenario, self.__user)
except Exception as e:
LogEvents("potable water network", "unknown error " + str(e),
self.__scenario, self.__user)
def __getClassess(self, fclass):
try:
query = """select distinct classification.name
from classification
where classification.category='footprint'
and classification.fclass='{fclass}'
""".format(fclass=fclass)
results = classification.objects.filter(
category='footprint',
fclass=fclass).distinct().values_list('name', flat=True)
LogEvents("classes", "classes finished: " + query, self.__scenario,
self.__user)
results_set = [row for row in results]
results = results_set
except Exception as e:
error = True
time.sleep(randint(1, 3))
LogEvents("classes", "classes failed: " + str(e), self.__scenario,
self.__user)
return []
else:
error = False
LogEvents("classes", "classes finished", self.__scenario,
self.__user)
return results
def run(self):
try:
self.__Indicator = Indicator(self.__user)
road_classes=self.__getClassess("road_infrastructure","roads")
road_classes_array="'{"+",".join(road_classes)+"}'"
risk_classes=self.__getClassess("risk","risk")
risk_classes_array="'{"+",".join(risk_classes)+"}'"
error = True
count = 0
while error and count < 3:
print("Entrando\n")
self.__Indicator = Indicator(self.__user)
db = self.__Indicator.get_up_calculator_connection()
try:
query = """
select urbper_indicator_road_infrastructure_in_risk({scenario},'road_risk'::varchar(10),{road_class},{risk_classes})
""".format(
scenario=self.__scenario,
road_class=road_classes_array,
risk_classes=risk_classes_array
)
LogEvents(
"road infrastructure in risk",
"road infrastructure in risk module started: " + query,
self.__scenario,
self.__user
)
with transaction.atomic():
db.execute(query)
except Exception as e:
error = True
count += 1
time.sleep(randint(1, 3))
db.close()
LogEvents(
"road infrastructure in risk",
"road infrastructure in risk module failed " +
str(count) + ": " + str(e),
self.__scenario,
self.__user
)
else:
error = False
db.close()
LogEvents(
"road infrastructure in risk",
"road infrastructure in risk module finished",
self.__scenario,
self.__user
)
except Exception as e:
LogEvents(
"road infrastructure in risk",
"unknown error " +
str(e),
self.__scenario,
self.__user
)
def run(self):
try:
self.__Indicator = Indicator(self.__user)
inadequate_classes=self.__getClassess("inadequate_hu")
inadequate_array="'{"+",".join(inadequate_classes)+"}'"
error = True
count = 0
while error and count < 3:
self.__Indicator = Indicator(self.__user)
db = self.__Indicator.get_up_calculator_connection()
try:
query = """
select urbper_indicator_population_inadequate_housing({scenario},{inadequate})
""".format(
scenario=self.__scenario,
inadequate=inadequate_array
)
LogEvents(
"urbper_indicator population in inadequate housing",
"population in inadequate housing started: " + query,
self.__scenario,
self.__user
)
with transaction.atomic():
db.execute(query)
except Exception as e:
error = True
count += 1
time.sleep(randint(1, 3))
db.close()
LogEvents(
"population in inadequate housing",
"population in inadequate housing module failed " +
str(count) + ": " + str(e),
self.__scenario,
self.__user
)
else:
error = False
db.close()
LogEvents(
"population in inadequate housing",
"population in inadequate housing module finished",
self.__scenario,
self.__user
)
except Exception as e:
LogEvents(
"population in inadequate housing",
"unknown error " +
str(e),
self.__scenario,
self.__user
)
def run(self):
try:
self.__Indicator = Indicator(self.__user)
greenland_classes=green_classes=self.__getClassess("green_land")
greenland_array="'{"+",".join(greenland_classes)+"}'"
error = True
count = 0
while error and count < 3:
self.__Indicator = Indicator(self.__user)
db = self.__Indicator.get_up_calculator_connection()
try:
query = """
select urbper_indicator_green_land_consumption({scenario},'greenland_consumption',{greenland})
""".format(
scenario=self.__scenario,
greenland=greenland_array,
)
LogEvents(
"green land consumption",
"green land consumption module started: " + query,
self.__scenario,
self.__user
)
with transaction.atomic():
db.execute(query)
except Exception as e:
error = True
count += 1
time.sleep(randint(1, 3))
db.close()
LogEvents(
"green land consumption",
"green land consumption module failed " +
str(count) + ": " + str(e),
self.__scenario,
self.__user
)
else:
error = False
db.close()
LogEvents(
"green land consumption",
"green land consumption module finished",
self.__scenario,
self.__user
)
except Exception as e:
LogEvents(
"green land consumption",
"unknown error " +
str(e),
self.__scenario,
self.__user
)
def __evaluateAmenityBuffers(self):
import psycopg2
import psycopg2.extras
try:
error = True
count = 0
while error and count < 3:
try:
query = """
select urbper_buffer_amenities({scenario})
""".format(scenario=self.__scenario)
LogEvents(
"amenity buffers",
"amenity buffer module started: " + query,
self.__scenario,
self.__user
)
conn = psycopg2.connect(self.__Indicator.get_uri())
cursor = conn.cursor(
cursor_factory=psycopg2.extras.DictCursor)
old_isolation_level = conn.isolation_level
conn.set_isolation_level(0)
cursor.execute(query)
conn.commit()
conn.set_isolation_level(old_isolation_level)
except Exception as e:
error = True
count += 1
time.sleep(randint(1, 3))
LogEvents(
"amenity buffers",
"amenity buffers module failed " +
str(count) + ": " + str(e),
self.__scenario,
self.__user
)
else:
error = False
LogEvents(
"amenity buffers",
"amenity buffers module finished",
self.__scenario,
self.__user
)
except Exception as e:
LogEvents(
"amenity buffers",
"unknown error " +
str(e),
self.__scenario,
self.__user
)
def run(self):
try:
error = True
count = 0
dwells_classes= self.__getAmenityClassess()
dwells_array="'{"+",".join(dwells_classes)+"}'"
while error and count < 3:
self.__Indicator = Indicator(self.__user)
db = self.__Indicator.get_up_calculator_connection()
try:
query = """
select urbper_indicator_potable_water_wells({scenario},{fclass_array})
""".format(
scenario=self.__scenario,fclass_array=dwells_array
)
LogEvents(
"potable water wells",
"potable water wells module started: " + query,
self.__scenario,
self.__user
)
with transaction.atomic():
db.execute(query)
except Exception as e:
error = True
count += 1
time.sleep(randint(1, 3))
db.close()
LogEvents(
"potable water wells",
"potable water wells module failed " +
str(count) + ": " + str(e),
self.__scenario,
self.__user
)
else:
error = False
db.close()
LogEvents(
"potable water wells",
"potable water wells module finished",
self.__scenario,
self.__user
)
except Exception as e:
LogEvents(
"potable water wells",
"unknown error " +
str(e),
self.__scenario,
self.__user
)
def __getAmenitiesClassess(self):
try:
error = True
count = 0
while error and count < 3:
try:
with connection.cursor() as cursor:
query="""
select distinct amenities.fclass from amenities
inner join classification on classification.name=amenities.fclass
where classification.category='amenities'
and classification.fclass='educational_infrastructure'
and amenities.scenario_id={}""".format(self.__scenario)
LogEvents(
"amenities fclasses",
"amenities fclasses started: " + query,
self.__scenario,
self.__user
)
cursor.execute(query)
results_set=[list(row)[0] for row in cursor.fetchall()]
results=results_set
except Exception as e:
error = True
count += 1
time.sleep(randint(1, 3))
LogEvents(
"amenities fclasses",
"amenities fclasses failed " +
str(count) + ": " + str(e),
self.__scenario,
self.__user
)
else:
error = False
LogEvents(
"amenities fclasses",
"amenities fclasses finished",
self.__scenario,
self.__user
)
return results
except Exception as e:
LogEvents(
"amenities fclasses",
"unknown error " + str(e),
self.__scenario,
self.__user
)
def __getAmenityClassess(self):
try:
error = True
count = 0
while error and count < 3:
try:
query="""select distinct classification.name
from classification
where classification.category='amenities'
and classification.fclass='dwells'
"""
results = classification.objects.filter(category='amenities',fclass='dwells').distinct().values_list('name',flat=True)
LogEvents(
"dwells",
"dwells classes finished: " + query,
self.__scenario,
self.__user
)
# cursor.execute(query)
results_set=[row for row in results]
results=results_set
except Exception as e:
error = True
count += 1
time.sleep(randint(1, 3))
LogEvents(
"dwells",
"dwells classes failed " +
str(count) + ": " + str(e),
self.__scenario,
self.__user
)
else:
error = False
LogEvents(
"dwells",
"dwells classes finished",
self.__scenario,
self.__user
)
return results
except Exception as e:
LogEvents(
"dwells",
"unknown error " + str(e),
self.__scenario,
self.__user
)
def run(self):
try:
error = True
count = 0
while error and count < 3:
self.__Indicator = Indicator(self.__user)
db = self.__Indicator.get_up_calculator_connection()
try:
amenity_classes = []
amenity_classes.append("elementary_school")
amenity_classes_array="'{"+",".join(amenity_classes)+"}'"
query = """
select urbper_indicator_elementary_school_capacity({scenario},'elementary_capacity'::varchar(30),{fclass_array})
""".format(scenario=self.__scenario, fclass_array=amenity_classes_array)
LogEvents(
"elementary school capacity",
"elementary school capacity module started: " + query,
self.__scenario,
self.__user
)
with transaction.atomic():
db.execute(query)
except Exception as e:
error = True
count += 1
time.sleep(randint(1, 3))
db.close()
LogEvents(
"elementary school capacity",
"elementary school capacity module failed " +
str(count) + ": " + str(e) ,
self.__scenario,
self.__user
)
else:
error = False
db.close()
LogEvents(
"elementary school capacity",
"elementary school capacity module finished",
self.__scenario,
self.__user
)
except Exception as e:
LogEvents(
"elementary school capacity",
"unknown error " +
str(e),
self.__scenario,
self.__user
)
def run(self):
try:
# get agricultural land
agricultural_sus = self.__getClassess("agricultural_sus")
# get sustainable agricultural land
agricultural_sus_array = "'{" + ",".join(agricultural_sus) + "}'"
agricultural = self.__getClassess("agricultural")
agricultural_array = "'{" + ",".join(agricultural) + "}'"
error = True
count = 0
while error and count < 3:
self.__Indicator = Indicator(self.__user)
db = self.__Indicator.get_up_calculator_connection()
try:
query = """
select urbper_indicator_sustainable_agricultural_land({scenario},{agricultural_sus_array},{agricultural_array})
""".format(
scenario=self.__scenario,
agricultural_sus_array=agricultural_sus_array,
agricultural_array=agricultural_array)
LogEvents(
"sustainable agricultural land",
"sustainable agricultural land started: " + query,
self.__scenario, self.__user)
with transaction.atomic():
db.execute(query)
except Exception as e:
error = True
count += 1
time.sleep(randint(1, 3))
db.close()
LogEvents(
"sustainable agricultural land",
"sustainable agricultural land module failed " +
str(count) + ": " + str(e), self.__scenario,
self.__user)
else:
error = False
db.close()
LogEvents("sustainable agricultural land",
"sustainable agricultural land module finished",
self.__scenario, self.__user)
except Exception as e:
LogEvents("sustainable agricultural land",
"unknown error " + str(e), self.__scenario, self.__user)
def run(self):
try:
self.__Indicator = Indicator(self.__user)
heritage_area_classes_set = assumptions.objects.filter(
category='heritage').values("name")
heritage_area_classes = []
for heritage_area in list(heritage_area_classes_set):
heritage_area_classes.append(heritage_area["name"])
heritage_area_array = "'{" + ",".join(heritage_area_classes) + "}'"
error = True
count = 0
while error and count < 3:
self.__Indicator = Indicator(self.__user)
db = self.__Indicator.get_up_calculator_connection()
try:
query = """
select urbper_indicator_solid_waste_management_coverage({scenario},'solidw_coverage')
""".format(
scenario=self.__scenario,
heritage_area=heritage_area_array,
)
LogEvents(
"solid waste management coverage",
"solid waste management coverage module started: " +
query, self.__scenario, self.__user)
with transaction.atomic():
db.execute(query)
except Exception as e:
error = True
count += 1
time.sleep(randint(1, 3))
db.close()
LogEvents(
"solid waste management coverage",
"solid waste management coverage module failed " +
str(count) + ": " + str(e), self.__scenario,
self.__user)
else:
error = False
db.close()
LogEvents(
"solid waste management coverage",
"solid waste management coverage module finished",
self.__scenario, self.__user)
except Exception as e:
LogEvents("solid waste management coverage",
"unknown error " + str(e), self.__scenario, self.__user)
def run(self):
try:
error = True
count = 0
while error and count < 3:
self.__Indicator = Indicator(self.__user)
db = self.__Indicator.get_up_calculator_connection()
try:
query = """
select urbper_indicator_elementary_school_ratio({scenario},'elemax_perc'::varchar(30))
""".format(scenario=self.__scenario)
LogEvents(
"elementary school ratio",
"elementary school ratio module started: " + query,
self.__scenario,
self.__user
)
with transaction.atomic():
db.execute(query)
except Exception as e:
error = True
count += 1
time.sleep(randint(1, 3))
db.close()
LogEvents(
"elementary school ratio",
"elementary school ratio module failed " +
str(count) + ": " + str(e) ,
self.__scenario,
self.__user
)
else:
error = False
db.close()
LogEvents(
"elementary school ratio",
"elementary school ratio module finished",
self.__scenario,
self.__user
)
except Exception as e:
LogEvents(
"elementary school ratio",
"unknown error " +
str(e),
self.__scenario,
self.__user
)
def __init__(self, user, scenarios, indicators):
LogEvents("Start scenario", "Starting all scenarios proccesing", -1, 1)
self.user = user
self.indicator = Indicator(self.user)
if scenarios != "":
self.scenarios = [
int(scenario.strip()) for scenario in scenarios.split('_')
]
self.base_scenario = self.__get_base_scenario(self.scenarios[0])
if self.base_scenario in self.scenarios:
if len(self.scenarios) > 1:
self.scenarios.append(
self.scenarios.pop(
self.scenarios.index(
self.scenarios.index(self.base_scenario))))
if indicators != "":
self.indicators = indicators.split('_')
indicator_param = []
for indicator_set in self.indicators:
indicator_param.append(indicator_set.strip())
order = Modules.objects.filter(
module__in=indicator_param).values("module").order_by('order')
self.indicators = []
for module_in in order:
self.indicators.append(module_in["module"])
self.copiados = dict(buffers=True,
policies=True,
amenities=[],
transit=[],
cycle=[],
footprint=[],
roads=[])
def run(self):
try:
self.__Indicator = Indicator(self.__user)
self.__db = self.__Indicator.get_up_calculator_connection()
vacuum(self.__Indicator.get_uri(), "mmu")
self.__db.close()
amenity_classes_set = self.__getAmentityClassess()
error = True
count = 0
while error and count < 3:
self.__Indicator = Indicator(self.__user)
db = self.__Indicator.get_up_calculator_connection()
try:
for amenity in amenity_classes_set:
amenity_classes = []
amenity_classes.append(amenity)
amenity_classes_array = "'{" + ",".join(
amenity_classes) + "}'"
query = """
select urbper_indicator_pop_amenity_prox({scenario},'pop_prox_{fclass}'::varchar(30),'{fclass}_proximity'::varchar(30),{fclass_array})
""".format(scenario=self.__scenario,
fclass=amenity,
fclass_array=amenity_classes_array)
LogEvents(
amenity + " proximity",
amenity + " proximity module started: " + query,
self.__scenario, self.__user)
with transaction.atomic():
db.execute(query)
except Exception as e:
error = True
count += 1
time.sleep(randint(1, 3))
db.close()
LogEvents(
"amenity proximity",
"amenity proximity module failed " + str(count) +
": " + str(e), self.__scenario, self.__user)
else:
error = False
db.close()
LogEvents("amenity proximity",
"amenity proximity module finished",
self.__scenario, self.__user)
except Exception as e:
LogEvents("amenity proximity", "unknown error " + str(e),
self.__scenario, self.__user)
def __mmu_limit_offset(self):
try:
self.__Indicator = Indicator(self.__user)
db = self.__Indicator.get_up_calculator_connection()
try:
# get the max an min of pk
self.__limits["inferior"] = mmu.objects.filter(
scenario_id=self.__scenario).aggregate(Min('mmu_id'))["mmu_id__min"]
self.__limits["superior"] = mmu.objects.filter(
scenario_id=self.__scenario).aggregate(Max('mmu_id'))["mmu_id__max"]
except Exception as e:
LogEvents("squares max min", "unknown error " +
str(e), self.__scenario, self.__user, True)
db.close()
except Exception as e:
LogEvents("squares max min", "unknown error " +
str(e), self.__scenario, self.__user, True)
def run(self):
try:
self.__Indicator = Indicator(self.__user)
amenity_classes = self.__getAmenitiesClassess()
amenity_classes_array = "'{" + ",".join(amenity_classes) + "}'"
risk_classes = self.__getRiskClassess()
risk_classes_array = "'{" + ",".join(risk_classes) + "}'"
error = True
count = 0
while error and count < 3:
self.__Indicator = Indicator(self.__user)
db = self.__Indicator.get_up_calculator_connection()
try:
query = """
select urbper_indicator_health_infrastructure_in_risk({scenario},'health_risk',{amenity_class},{risk_classes})
""".format(scenario=self.__scenario,
amenity_class=amenity_classes_array,
risk_classes=risk_classes_array)
LogEvents(
"health infrastructure in risk",
"health infrastructure in risk module started: " +
query, self.__scenario, self.__user)
with transaction.atomic():
db.execute(query)
except Exception as e:
error = True
count += 1
time.sleep(randint(1, 3))
db.close()
LogEvents(
"health infrastructure in risk",
"health infrastructure in risk module failed " +
str(count) + ": " + str(e), self.__scenario,
self.__user)
else:
error = False
db.close()
LogEvents("health infrastructure in risk",
"health infrastructure in risk module finished",
self.__scenario, self.__user)
except Exception as e:
LogEvents("health infrastructure in risk",
"unknown error " + str(e), self.__scenario, self.__user)
def __jobs_limit_offset(self):
try:
try:
# get the max an min of pk
self.__limits["inferior"] = jobs.objects.filter(
scenario_id=self.__scenario).aggregate(Min('jobs_id'))["jobs_id__min"]
self.__limits["superior"] = jobs.objects.filter(
scenario_id=self.__scenario).aggregate(Max('jobs_id'))["jobs_id__max"]
except Exception as e:
LogEvents("jobs max min", "unknown error " +
str(e), self.__scenario, self.__user, True)
except Exception as e:
LogEvents("jobs max min", "unknown error " +
str(e), self.__scenario, self.__user, True)
def __ModuleJobsDensity(self, scenario_id, offset=0, limit=0):
import psycopg2
import psycopg2.extras
try:
error = True
count = 0
while error and count < 3:
try:
query = """select urbper_buffer_job_and_job_density({scenario},{offset},{limit})""".format(
scenario=scenario_id, offset=offset, limit=limit)
LogEvents(
"job buffers and density",
"job buffers and density module started: " + query,
scenario_id, self.__user)
conn = psycopg2.connect(self.__Indicator.get_uri())
cursor = conn.cursor(
cursor_factory=psycopg2.extras.DictCursor)
old_isolation_level = conn.isolation_level
conn.set_isolation_level(0)
cursor.execute(query)
conn.commit()
conn.set_isolation_level(old_isolation_level)
except Exception as e:
error = True
count += 1
LogEvents(
"job buffers and density ",
"job buffers and density module failed " +
str(count) + ": " + str(e), scenario_id, self.__user,
True)
else:
error = False
# db.commit()
LogEvents("job buffers and density ",
"job buffers and density module finished",
scenario_id, self.__user)
except Exception as e:
LogEvents("Running scenarios", "Unknown error " + str(e),
scenario_id, self.__user, True)
def __ModuleAreaDensity(self, scenario_id, offset=0, limit=0):
try:
error = True
count = 0
while error and count < 3:
self.__Indicator = Indicator(self.__user)
db = self.__Indicator.get_up_calculator_connection()
try:
query = """select urbper_indicator_area_den_avg({scenario},{offset},{limit})""".format(
scenario=scenario_id, offset=offset, limit=limit)
LogEvents("area density avg",
"area density avg module started: " + query,
scenario_id, self.__user)
conn = psycopg2.connect(self.__Indicator.get_uri())
cursor = conn.cursor(
cursor_factory=psycopg2.extras.DictCursor)
old_isolation_level = conn.isolation_level
conn.set_isolation_level(0)
cursor.execute(query)
conn.commit()
conn.set_isolation_level(old_isolation_level)
except Exception as e:
error = True
count += 1
time.sleep(randint(1, 3))
LogEvents(
"area density avg", "area density avg module failed " +
str(count) + ": " + str(e), scenario_id, self.__user,
True)
conn.close()
else:
error = False
LogEvents("area density avg",
"area density avg module finished", scenario_id,
self.__user)
conn.close()
except Exception as e:
LogEvents("Running scenarios", "Unknown error " + str(e),
scenario_id, self.__user, True)
def __urbper_base_footprint_area(self):
try:
error = True
count = 0
while error and count < 3:
try:
self.__Indicator = Indicator(self.__user)
query = """select urbper_indicator_footprints_area({scenario})""".format(
scenario=self.__scenario)
LogEvents("footprints area",
"footprints area module started: " + query,
self.__scenario, self.__user)
conn = psycopg2.connect(self.__Indicator.get_uri())
cursor = conn.cursor(
cursor_factory=psycopg2.extras.DictCursor)
old_isolation_level = conn.isolation_level
conn.set_isolation_level(0)
cursor.execute(query)
conn.commit()
conn.set_isolation_level(old_isolation_level)
except Exception as e:
conn.rollback()
conn.close()
error = True
count += 1
time.sleep(randint(1, 3))
LogEvents(
"footprints area", "footprints area module failed " +
str(count) + ": " + str(e), self.__scenario,
self.__user, True)
else:
error = False
conn.close()
LogEvents("footprints area",
"footprints area module finished",
self.__scenario, self.__user)
except Exception as e:
LogEvents("footprints area", "unknown error+ " + str(e),
self.__scenario, self.__user, True)
def run(user, scenario, indicators):
import os
import time
my_pid = os.getpid()
print("received: ", user, scenario, indicators)
try:
# evaluate the scenarios
LogEvents("All scenarios are ready to be evaluated",
"This may take a while", -1, user)
evaluate = EvaluateScenario(user, scenario, indicators)
LogEvents("All scenarios are ready to be evaluated",
"This may take a while", -1, user)
evaluate.run_scenarios()
LogEvents("All scenarios have been evaluated",
"You must provide arguments", -1, user)
except Exception as e:
LogEvents("There was an error during scenario evaluation", str(e), -1,
user)
def run(self):
try:
self.__Indicator = Indicator(self.__user)
road_classes = self.__getClassess("allseason")
road_classes_array = "'{" + ",".join(road_classes) + "}'"
error = True
count = 0
while error and count < 3:
self.__Indicator = Indicator(self.__user)
db = self.__Indicator.get_up_calculator_connection()
try:
query = """
select urbper_indicator_road_all_season_proximity({scenario},'pop_prox_allseason','allseason_prox',{road_class})
""".format(scenario=self.__scenario,
road_class=road_classes_array)
LogEvents("all season roads",
"all season roads module started: " + query,
self.__scenario, self.__user)
with transaction.atomic():
db.execute(query)
except Exception as e:
error = True
count += 1
time.sleep(randint(1, 3))
db.close()
LogEvents(
"all season roads", "all season roads module failed " +
str(count) + ": " + str(e), self.__scenario,
self.__user)
else:
error = False
db.close()
LogEvents("all season roads",
"all season roads module finished",
self.__scenario, self.__user)
except Exception as e:
LogEvents("all season roads", "unknown error " + str(e),
self.__scenario, self.__user)
def run(self):
try:
self.__Indicator = Indicator(self.__user)
self.__db = self.__Indicator.get_up_calculator_connection()
vacuum(self.__Indicator.get_uri(), "mmu")
self.__db.close()
error = True
count = 0
while error and count < 3:
self.__Indicator = Indicator(self.__user)
db = self.__Indicator.get_up_calculator_connection()
try:
query = """
select urbper_indicator_pop_transit_prox({scenario},'pop_prox_{fclass}'::varchar(30),'{fclass}_proximity'::varchar(30))
""".format(scenario=self.__scenario, fclass='transit')
LogEvents("transit proximity",
"transit proximity module started: " + query,
self.__scenario, self.__user)
with transaction.atomic():
db.execute(query)
except Exception as e:
error = True
count += 1
time.sleep(randint(1, 3))
db.close()
LogEvents(
"transit proximity",
"transit proximity module failed " + str(count) +
": " + str(e), self.__scenario, self.__user)
else:
error = False
db.close()
LogEvents("transit proximity",
"transit proximity module finished",
self.__scenario, self.__user)
except Exception as e:
LogEvents("transit proximity", "unknown error " + str(e),
self.__scenario, self.__user)
def run_scenarios(self):
try:
LogEvents("Start scenario", "Starting all scenarios proccesing",
self.base_scenario, self.user)
last = 0
# Evaluate the scenario(s)
for scenario in self.scenarios:
last = scenario
LogEvents(
"Start scenario", "The modules to be use are: " +
str(",".join(self.indicators)), scenario, self.user)
##########################################
for module in self.indicators:
module_r = "plup.indicators." + module + "." + module
try:
plugin = importlib.import_module(module_r, ".")
module = plugin.Module(
self.user, scenario,
dict(base_scenario=self.base_scenario))
module.run()
except Exception as e:
print("E", e)
LogEvents("Finish scenario",
"The scenario have been processed", scenario,
self.user)
db = config.get_db()
vacuum(self.indicator.get_uri(), "mmu")
db.close()
db = config.get_db()
vacuum(self.indicator.get_uri(), True)
db.close()
LogEvents("All scenarios Finished",
"All scenarios have been processed", last, self.user)
except Exception as e:
LogEvents("Unknown error", str(e), self.base_scenario, self.user)
def __urbper_base_total_population(self):
try:
error = True
count = 0
while error and count < 3:
self.__Indicator = Indicator(self.__user)
db = self.__Indicator.get_up_calculator_connection()
try:
with transaction.atomic():
self.__Indicator = Indicator(self.__user)
db = self.__Indicator.get_up_calculator_connection()
query = """select urbper_indicator_base_calculus_total_population({scenario},{base_scenario})""".format(
scenario=self.__scenario,
base_scenario=self.__base_scenario)
LogEvents("total population",
"total population module started: " + query,
self.__scenario, self.__user)
db.execute(query)
except Exception as e:
db.close()
error = True
count += 1
time.sleep(randint(1, 3))
LogEvents(
"total population", "total population module failed " +
str(count) + ": " + str(e), self.__scenario,
self.__user, True)
else:
error = False
db.close()
LogEvents("total population",
"total population module finished",
self.__scenario, self.__user)
except Exception as e:
LogEvents("total population", "unknown error " + str(e),
self.__scenario, self.__user, True)
try:
# evaluate the scenarios
LogEvents("All scenarios are ready to be evaluated",
"This may take a while", -1, user)
evaluate = EvaluateScenario(user, scenario, indicators)
LogEvents("All scenarios are ready to be evaluated",
"This may take a while", -1, user)
evaluate.run_scenarios()
LogEvents("All scenarios have been evaluated",
"You must provide arguments", -1, user)
except Exception as e:
LogEvents("There was an error during scenario evaluation", str(e), -1,
user)
if __name__ == '__main__':
# sys.argv[1] user_id
# sys.argv[2] list of scenarios,
# sys.argv[3] list of modules
if len(sys.argv) < 4:
print("Wrong arguments\nExample")
print(
"\tEvaluateScenario user_id[1] scenarios[1_2_3_...] indicators[GeneralCalculus_AmenityProximity]"
)
elif len(sys.argv) <= 2:
LogEvents("Evaluate scenarios", "You must provide arguments", -1,
sys.argv[1])
elif len(sys.argv) == 4:
print("Running")
run(sys.argv[1], sys.argv[2], sys.argv[3])