def test_list_to_element(self):
input_list = [1, 2, 3, 4]
result = functions.list_to_element(input_list)
self.assertEqual(result, 1)
input_tuple = (1, 2, 3, 4)
result = functions.list_to_element(input_tuple)
self.assertEqual(result, 1)
def msg_mpe_10dcum(input_file, output_file):
if len(input_file) > 8:
output_file = functions.list_to_element(output_file)
# Get the number of days of that dekad
basename = os.path.basename(output_file)
mydate = functions.get_date_from_path_filename(basename)
nbr_days_dekad = functions.day_per_dekad(mydate)
factor = 1.0
functions.check_output_dir(os.path.dirname(output_file))
args = {
"input_file": input_file,
"output_file": output_file,
"output_format": 'GTIFF',
"options": "compress=lzw",
"scale_factor": factor,
"input_nodata": -32768
}
raster_image_math.do_cumulate(**args)
else:
logger.warning(
'More than 2 files missing for output {0}: Skip'.format(
os.path.basename(output_file)))
def vgt_ndvi_linearx2(input_files, output_file):
output_file = functions.list_to_element(output_file)
functions.check_output_dir(os.path.dirname(output_file))
args = {"input_file": input_files[1], "before_file":input_files[0], "after_file": input_files[2], "output_file": output_file,
"output_format": 'GTIFF', "options": "compress = lzw", 'threshold': 0.1}
raster_image_math.do_ts_linear_filter(**args)
def msg_mpe_1dcum(input_file, output_file):
#
output_file = functions.list_to_element(output_file)
functions.check_output_dir(os.path.dirname(output_file))
tmpdir = tempfile.mkdtemp(prefix=__name__,
suffix='',
dir=es_constants.base_tmp_dir)
tmp_output_file = tmpdir + os.path.sep + os.path.basename(output_file)
# Divide by 10 to pass from 0.01 to 0.1 as scale factor for 1d cum
factor = 0.1
args = {
"input_file": input_file,
"output_file": tmp_output_file,
"output_format": 'GTIFF',
"options": "compress=lzw",
"scale_factor": factor,
"input_nodata": -32768
}
raster_image_math.do_cumulate(**args)
reproject_output(tmp_output_file, native_mapset, target_mapset)
# Copy the non-reprojected file for validation, only in test_mode
if test_mode:
msg_proj_dir = es_constants.processing_dir + functions.set_path_sub_directory(
prod, '1dcum', 'Derived', version, native_mapset)
functions.check_output_dir(msg_proj_dir)
shutil.copy(tmp_output_file, msg_proj_dir + os.path.sep)
# Copy the non-reprojected file for validation, only in test_mode
shutil.rmtree(tmpdir)
def lsasaf_etp_10dcum(input_file, output_file):
output_file = functions.list_to_element(output_file)
# Get the number of days of that dekad
basename=os.path.basename(output_file)
mydate=functions.get_date_from_path_filename(basename)
nbr_days_dekad = functions.day_per_dekad(mydate)
# Compute the correcting factor: we sum-up all 48 30min cycles and:
# Divide by 2 (mm/h -> mm)
# Multiply by number of days
# Divide by 100, so that the scale factor changes from 0.0001 (30min) to 0.01
factor = float(nbr_days_dekad)*0.005
functions.check_output_dir(os.path.dirname(output_file))
tmpdir = tempfile.mkdtemp(prefix=__name__, suffix='',dir=es_constants.base_tmp_dir)
tmp_output_file = tmpdir+os.path.sep+os.path.basename(output_file)
args = {"input_file": input_file, "output_file": tmp_output_file, "output_format": 'GTIFF',
"options": "compress=lzw", "scale_factor": factor, "input_nodata":-32768}
# See ES2-416: we accept at least 40 files out of the expect 48
if len(input_file) >= 40:
raster_image_math.do_cumulate(**args)
reproject_output(tmp_output_file, native_mapset, target_mapset)
# Do also the house-keeping, by deleting the files older than 6 months
number_months_keep = 6
remove_old_files(prod, "10d30min-et", version, native_mapset, 'Derived', number_months_keep)
# Remove tmp dir (moved out of if-clause - 21.11.19)
shutil.rmtree(tmpdir)
def std_precip_1yearcum(input_file, output_file):
output_file = functions.list_to_element(output_file)
functions.check_output_dir(os.path.dirname(output_file))
args = {"input_file": input_file, "output_file": output_file, "output_format": 'GTIFF', "options": "compress=lzw",\
"scale_factor":scale_factor_conv}
raster_image_math.do_cumulate(**args)
def lsasaf_lst_10dmin(input_file, output_file):
output_file = functions.list_to_element(output_file)
# Get the number of days of that dekad
basename = os.path.basename(output_file)
mydate = functions.get_date_from_path_filename(basename)
functions.check_output_dir(os.path.dirname(output_file))
tmpdir = tempfile.mkdtemp(prefix=__name__,
suffix='',
dir=es_constants.base_tmp_dir)
tmp_output_file = tmpdir + os.path.sep + os.path.basename(output_file)
args = {
"input_file": input_file,
"output_file": tmp_output_file,
"output_format": 'GTIFF',
"options": "compress=lzw",
"input_nodata": -32768
}
raster_image_math.do_min_image(**args)
reproject_output(tmp_output_file, native_mapset, target_mapset)
shutil.rmtree(tmpdir)
# Do also the house-keeping, by deleting the files older than 6 months
number_months_keep = 6
remove_old_files(prod, '10d15min', version, native_mapset, 'Ingest',
number_months_keep)
def sst_shapefile_conversion(input_file, output_file):
output_file = functions.list_to_element(output_file)
# Check if the (final) output file already exists - and delete it
if os.path.isfile(output_file):
files=glob.glob(output_file.replace('.shp','.*'))
for my_file in files:
os.remove(my_file)
# Create a temporary output file (see also ES2-33)
try:
tmpdir = tempfile.mkdtemp(prefix=__name__, suffix='_' + os.path.basename(output_file),
dir=es_constants.base_tmp_dir)
except:
raise NameError('Error in creating tmpdir')
# Convert to shapefile
tmp_output_file = tmpdir+os.path.sep+os.path.basename(output_file)
functions.check_output_dir(os.path.dirname(tmp_output_file))
command=es_constants.es2globals['gdal_polygonize']+' '+ input_file+' '+ tmp_output_file+' -nomask -f "ESRI Shapefile"'
p = os.system(command)
# Check output dir exists (see ES2-285)
functions.check_output_dir(os.path.dirname(output_file))
# Move and remove tmpdir
files=glob.glob(tmp_output_file.replace('.shp','.*'))
for my_file in files:
os.rename(my_file, os.path.dirname(output_file)+os.path.sep+os.path.basename(my_file))
shutil.rmtree(tmpdir)
def modis_chla_monclim(input_file, output_file):
output_file = functions.list_to_element(output_file)
functions.check_output_dir(os.path.dirname(output_file))
args = {"input_file": input_file, "output_file": output_file, "output_format": 'GTIFF', \
"options": "compress=lzw"}
raster_image_math.do_avg_image(**args)
def vgt_ndvi_baresoil_linearx2(input_file, output_file):
output_file = functions.list_to_element(output_file)
functions.check_output_dir(os.path.dirname(output_file))
args = {"input_file": input_file, "output_file": output_file, "output_format": 'GTIFF', "options": "compress = lzw"}
print args
raster_image_math.do_make_baresoil(**args)
def modis_par_monavg(input_file, output_file):
output_file = functions.list_to_element(output_file)
functions.check_output_dir(os.path.dirname(output_file))
args = {"input_file": input_file, "output_file": output_file, "output_format": 'GTIFF', \
"options": "compress=lzw", "input_nodata": in_nodata}
raster_image_math.do_avg_image(**args)
def create_pipeline(starting_sprod):
# ---------------------------------------------------------------------
# Define input files
in_prod_ident = functions.set_path_filename_no_date(prod, starting_sprod, mapset, version, ext)
input_dir = es_constants.processing_dir+ \
functions.set_path_sub_directory(prod, starting_sprod, 'Ingest', version, mapset)
starting_files = input_dir+"*"+in_prod_ident
# Read input product nodata
in_prod_info = querydb.get_product_out_info(productcode=prod, subproductcode=starting_sprod, version=version)
product_info = functions.list_to_element(in_prod_info)
in_nodata = product_info.nodata
print in_nodata
# ---------------------------------------------------------------------
# Monthly Average for a given month
output_sprod="monavg"
out_prod_ident = functions.set_path_filename_no_date(prod, output_sprod, mapset, version, ext)
output_subdir = functions.set_path_sub_directory (prod, output_sprod, 'Derived', version, mapset)
formatter_in="(?P<YYYYMM>[0-9]{6})[0-9]{2}"+in_prod_ident
formatter_out=["{subpath[0][5]}"+os.path.sep+output_subdir+"{YYYYMM[0]}"+out_prod_ident]
@active_if(activate_monavg_comput)
@collate(starting_files, formatter(formatter_in),formatter_out)
def modis_par_monavg(input_file, output_file):
output_file = functions.list_to_element(output_file)
functions.check_output_dir(os.path.dirname(output_file))
args = {"input_file": input_file, "output_file": output_file, "output_format": 'GTIFF', \
"options": "compress=lzw", "input_nodata": in_nodata}
raster_image_math.do_avg_image(**args)
def std_precip_10dmeas(input_file, output_file):
output_file = functions.list_to_element(output_file)
functions.check_output_dir(os.path.dirname(output_file))
# Prepare temporary working directory for intermediate results
tmpdirpath = tempfile.mkdtemp()
# Cumulated but not masked output
tmp_output_file = tmpdirpath + os.path.sep + os.path.basename(
output_file)
# Call the function for cumulating
args = {
"input_file": input_file,
"output_file": tmp_output_file,
"output_format": 'GTIFF',
"options": "compress=lzw"
}
raster_image_math.do_cumulate(**args)
# Call the function for masking
args = {
"input_file": tmp_output_file,
"mask_file": land_mask,
"output_file": output_file,
"output_format": 'GTIFF',
"options": "compress=lzw",
"mask_value": 0,
"out_value": 0
}
raster_image_math.do_mask_image(**args)
# Remove temp directory
shutil.rmtree(tmpdirpath)
def compute_monavg(input_file, output_file):
output_file = functions.list_to_element(output_file)
out_filename = os.path.basename(output_file)
functions.check_output_dir(os.path.dirname(output_file))
no_data = int(sds_meta.get_nodata_value(input_file[0]))
str_date = out_filename[0:6]
today = datetime.date.today()
today_yyyymm = today.strftime('%Y%m')
# expected_ndays=functions.get_number_days_month(str_date)
# current_ndays=len(input_file)
if str_date == today_yyyymm:
logger.info(
'Do not perform computation for current month {0}. Skip'.
format(str_date))
else:
args = {
"input_file": input_file,
"output_file": output_file,
"output_format": 'GTIFF',
"input_nodata": no_data,
"options": "compress=lzw"
}
raster_image_math.do_avg_image(**args)
def compute_3dayavg(input_file, output_file):
no_data = int(sds_meta.get_nodata_value(input_file[0]))
output_file = functions.list_to_element(output_file)
functions.check_output_dir(os.path.dirname(output_file))
args = {"input_file": input_file, "output_file": output_file, "output_format": 'GTIFF', "options": "", "input_nodata":no_data, "output_nodata":no_data}
raster_image_math.do_avg_image(**args)
def cum(input_files, output_file):
# Ensure out subdirectory exists
functions.check_output_dir(os.path.dirname(output_file))
# If output_file it is a list, force to a string
output_file = functions.list_to_element(output_file)
# Prepare temporary working directory for intermediate results
tmpdirpath = tempfile.mkdtemp()
# Cumulated but not masked output
tmp_output_file = tmpdirpath + os.path.sep + os.path.basename(
output_file)
# Call the function for cumulating
args = {
"input_file": input_files,
"output_file": tmp_output_file,
"output_format": 'GTIFF',
"options": "compress=lzw"
}
raster_image_math.do_cumulate(**args)
# Create from the original mask a new one, by using raster_image_math.do_reprojection()
# and save it as a temporary mask
# raster_image_math.do_reproject(agriculture_mask, tmp_reproj_file, 'SPOTV-SADC-1km', mapset)
raster_image_math.do_reproject(tmp_output_file, output_file,
native_mapset, mapset)
# Remove temp directory
shutil.rmtree(tmpdirpath)
def std_yearly_max(input_file, output_file):
output_file = functions.list_to_element(output_file)
reduced_list = exclude_current_year(input_file)
functions.check_output_dir(os.path.dirname(output_file))
args = {"input_file": reduced_list, "output_file": output_file, "output_format": 'GTIFF',
"options": "compress=lzw"}
raster_image_math.do_max_image(**args)
def gradient_computation(input_file, output_file):
no_data = int(sds_meta.get_nodata_value(input_file))
output_file = functions.list_to_element(output_file)
functions.check_output_dir(os.path.dirname(output_file))
args = {"input_file": input_file, "output_file": output_file, "nodata": no_data, "output_format": 'GTIFF', "options": "compress = lzw"}
raster_image_math.do_compute_chla_gradient(**args)
print ('Done with raster')
def lsasaf_lst_10dmax(input_file, output_file):
#
output_file = functions.list_to_element(output_file)
functions.check_output_dir(os.path.dirname(output_file))
args = {"input_file": input_file, "output_file": output_file, "output_format": 'GTIFF',
"options": "compress=lzw", "input_nodata":-32768}
raster_image_math.do_max_image(**args)
def modis_pp_1mon(input_file, output_file):
output_file = functions.list_to_element(output_file)
functions.check_output_dir(os.path.dirname(output_file))
args = {"chla_file": input_file[1], "sst_file": input_file[3], "kd_file": input_file[0],"par_file": input_file[2], \
"sst_nodata": sst_nodata, "kd_nodata": kd_nodata,\
"par_nodata": par_nodata, "output_file": output_file, "output_nodata": -9999, "output_format": 'GTIFF',\
"output_type": None, "options": "compress=lzw"}
raster_image_math.do_compute_primary_production(**args)
def sst_fronts_detection(input_file, output_file):
output_file = functions.list_to_element(output_file)
functions.check_output_dir(os.path.dirname(output_file))
args = {"input_file": input_file, "output_file": output_file, "output_format": 'GTIFF', "options": "compress = lzw",
"parameters": parameters}
raster_image_math.do_detect_sst_fronts(**args)
print 'Done with raster'
def modis_pp_1mon(input_file, output_file):
output_file = functions.list_to_element(output_file)
functions.check_output_dir(os.path.dirname(output_file))
args = {"chla_file": input_file[1], "sst_file": input_file[3], "kd_file": input_file[0],"par_file": input_file[2], \
"sst_nodata": sst_nodata, "kd_nodata": kd_nodata,\
"par_nodata": par_nodata, "output_file": output_file, "output_nodata": -9999, "output_format": 'GTIFF',\
"output_type": None, "options": "compress=lzw"}
raster_image_math.do_compute_primary_production(**args)
def compute_10d_from_1d(input_file, output_file):
output_file = functions.list_to_element(output_file)
functions.check_output_dir(os.path.dirname(output_file))
args = {
"input_file": input_file,
"output_file": output_file,
"output_format": 'GTIFF',
"options": "compress = lzw"
}
raster_image_math.do_avg_image(**args)
def compute_absolute_diff(input_file, output_file):
output_file = functions.list_to_element(output_file)
functions.check_output_dir(os.path.dirname(output_file))
args = {
"input_file": input_file,
"output_file": output_file,
"output_format": 'GTIFF',
"options": "compress=lzw"
}
raster_image_math.do_oper_subtraction(**args)
def lsasaf_etp_1moncum(input_file, output_file):
#
output_file = functions.list_to_element(output_file)
functions.check_output_dir(os.path.dirname(output_file))
args = {"input_file": input_file, "output_file": output_file, "output_format": 'GTIFF',
"options": "compress=lzw", "input_nodata":-32768}
# See ES2-416: we need all 3 files for the monthly cumulate
if len(input_file) >= 3:
raster_image_math.do_cumulate(**args)
def compute_standardized_products(input_file, output_file):
output_file = functions.list_to_element(output_file)
functions.check_output_dir(os.path.dirname(output_file))
args = {
"input_file": input_file,
"output_file": output_file,
"output_format": 'GTIFF',
"options": "compress=lzw"
}
raster_image_math.do_oper_division_perc(**args)
def vgt_ndvi_absol_max_linearx2(input_file, output_file):
output_file = functions.list_to_element(output_file)
functions.check_output_dir(os.path.dirname(output_file))
args = {
"input_file": input_file,
"output_file": output_file,
"output_format": 'GTIFF',
"options": "compress = lzw"
}
raster_image_math.do_max_image(**args)
def std_precip_10dmax(input_file, output_file):
output_file = functions.list_to_element(output_file)
functions.check_output_dir(os.path.dirname(output_file))
args = {
"input_file": input_file,
"output_file": output_file,
"output_format": 'GTIFF',
"options": "compress=lzw"
}
raster_image_math.do_max_image(**args)
def compute_percentage_diff_vs_avg(input_file, output_file):
output_file = functions.list_to_element(output_file)
functions.check_output_dir(os.path.dirname(output_file))
args = {
"input_file": input_file[0],
"avg_file": input_file[1],
"output_file": output_file,
"output_format": 'GTIFF',
"options": "compress=lzw"
}
raster_image_math.do_compute_perc_diff_vs_avg(**args)
def fewsnet_1monmin(input_file, output_file):
output_file = functions.list_to_element(output_file)
functions.check_output_dir(os.path.dirname(output_file))
args = {
"input_file": input_file,
"output_file": output_file,
"output_format": 'GTIFF',
"options": "compress=lzw"
}
raster_image_math.do_min_image(**args)
def compute_normalized_anomaly(input_file, output_file):
output_file = functions.list_to_element(output_file)
functions.check_output_dir(os.path.dirname(output_file))
args = {
"input_file": input_file[0],
"min_file": input_file[1],
"max_file": input_file[2],
"output_file": output_file,
"output_format": 'GTIFF',
"options": "compress=lzw"
}
raster_image_math.do_make_vci(**args)
def lsasaf_lst_10d15min(input_file, output_file):
output_file = functions.list_to_element(output_file)
functions.check_output_dir(os.path.dirname(output_file))
args = {"input_file": input_file, "output_file": output_file, "output_format": 'GTIFF', \
"options": "compress=lzw", "input_nodata":-32768}
raster_image_math.do_max_image(**args)
# Do also the house-keeping, by deleting the files older than 6 months
number_months_keep = 6
remove_old_files(prod, starting_sprod, version, native_mapset, 'Ingest', number_months_keep)
def std_dmp_10dratio(input_file, output_file):
output_file = functions.list_to_element(output_file)
functions.check_output_dir(os.path.dirname(output_file))
args = {
"input_file": input_file,
"output_file": output_file,
"output_format": 'GTIFF',
"options": "compress = lzw"
}
raster_image_math.do_oper_division_perc(**args)
def get_product_out_info(product, subproduct, my_logger):
try:
# Get information from 'product' table
args = {
"productcode": product['productcode'],
"subproductcode": subproduct,
"version": product['version']
}
product_out_info = querydb.get_product_out_info(**args)
product_out_info = functions.list_to_element(product_out_info)
return product_out_info
except:
my_logger.error('Error defining Output product info ')
def std_precip_10davg(input_file, output_file):
output_file = functions.list_to_element(output_file)
functions.check_output_dir(os.path.dirname(output_file))
args = {
"input_file": input_file,
"output_file": output_file,
"output_format": 'GTIFF',
"options": "compress=lzw",
'output_type': 'Float32',
'input_nodata': -32767
}
raster_image_math.do_avg_image(**args)
def modis_chla_monavg(input_file, output_file):
output_file = functions.list_to_element(output_file)
out_filename=os.path.basename(output_file)
str_date=out_filename[0:6]
expected_ndays=functions.get_number_days_month(str_date)
functions.check_output_dir(os.path.dirname(output_file))
current_ndays=len(input_file)
if expected_ndays != current_ndays:
logger.info('Missing days for period: %s. Skip' % str_date)
else:
args = {"input_file": input_file, "output_file": output_file, "output_format": 'GTIFF', \
"options": "compress=lzw", "input_nodata": in_nodata}
raster_image_math.do_avg_image(**args)
def fewsnet_10davg(input_file, output_file):
output_file = functions.list_to_element(output_file)
functions.check_output_dir(os.path.dirname(output_file))
args = {"input_file": input_file, "output_file": output_file, "output_format": 'GTIFF', "options": "compress=lzw"}
raster_image_math.do_avg_image(**args)
def create_pipeline(starting_sprod):
# ---------------------------------------------------------------------
# Define input files
in_prod_ident = functions.set_path_filename_no_date(prod, starting_sprod, mapset, version, ext)
input_dir = es_constants.processing_dir+ \
functions.set_path_sub_directory(prod, starting_sprod, 'Ingest', version, mapset)
starting_files = input_dir+"*"+in_prod_ident
# Read input product nodata
in_prod_info = querydb.get_product_out_info(productcode=prod, subproductcode=starting_sprod, version=version)
product_info = functions.list_to_element(in_prod_info)
in_nodata = product_info.nodata
print in_nodata
# ---------------------------------------------------------------------
# Monthly Average for a given month
output_sprod="monavg"
out_prod_ident = functions.set_path_filename_no_date(prod, output_sprod, mapset, version, ext)
output_subdir = functions.set_path_sub_directory (prod, output_sprod, 'Derived', version, mapset)
formatter_in="(?P<YYYYMM>[0-9]{6})[0-9]{2}"+in_prod_ident
formatter_out=["{subpath[0][5]}"+os.path.sep+output_subdir+"{YYYYMM[0]}"+out_prod_ident]
@active_if(activate_monavg_comput)
@collate(starting_files, formatter(formatter_in),formatter_out)
def modis_chla_monavg(input_file, output_file):
output_file = functions.list_to_element(output_file)
out_filename=os.path.basename(output_file)
str_date=out_filename[0:6]
expected_ndays=functions.get_number_days_month(str_date)
functions.check_output_dir(os.path.dirname(output_file))
current_ndays=len(input_file)
if expected_ndays != current_ndays:
logger.info('Missing days for period: %s. Skip' % str_date)
else:
args = {"input_file": input_file, "output_file": output_file, "output_format": 'GTIFF', \
"options": "compress=lzw", "input_nodata": in_nodata}
raster_image_math.do_avg_image(**args)
# ---------------------------------------------------------------------
# Monthly Climatology for all years
new_input_subprod='monavg'
new_in_prod_ident= functions.set_path_filename_no_date(prod, new_input_subprod, mapset, version, ext)
new_input_dir = es_constants.processing_dir+ \
functions.set_path_sub_directory(prod, new_input_subprod, 'Derived', version, mapset)
new_starting_files = new_input_dir+"*"+new_in_prod_ident
output_sprod="monclim"
out_prod_ident = functions.set_path_filename_no_date(prod, output_sprod, mapset, version, ext)
output_subdir = functions.set_path_sub_directory (prod, output_sprod, 'Derived', version, mapset)
formatter_in="[0-9]{4}(?P<MM>[0-9]{2})"+new_in_prod_ident
formatter_out=["{subpath[0][5]}"+os.path.sep+output_subdir+"{MM[0]}"+out_prod_ident]
@active_if(activate_monclim_comput)
@collate(new_starting_files, formatter(formatter_in),formatter_out)
def modis_chla_monclim(input_file, output_file):
output_file = functions.list_to_element(output_file)
functions.check_output_dir(os.path.dirname(output_file))
args = {"input_file": input_file, "output_file": output_file, "output_format": 'GTIFF', \
"options": "compress=lzw", "input_nodata": in_nodata}
raster_image_math.do_avg_image(**args)
# ---------------------------------------------------------------------
# Monthly Anomaly for a given monthly
output_sprod="monanom"
out_prod_ident = functions.set_path_filename_no_date(prod, output_sprod, mapset,version, ext)
output_subdir = functions.set_path_sub_directory (prod, output_sprod, 'Derived', version, mapset)
# Starting files + avg
formatter_in="(?P<YYYY>[0-9]{4})(?P<MM>[0-9]{2})"+new_in_prod_ident
formatter_out="{subpath[0][5]}"+os.path.sep+output_subdir+"{YYYY[0]}{MM[0]}"+out_prod_ident
ancillary_sprod = "monclim"
ancillary_sprod_ident = functions.set_path_filename_no_date(prod, ancillary_sprod, mapset,version,ext)
ancillary_subdir = functions.set_path_sub_directory(prod, ancillary_sprod, 'Derived',version, mapset)
ancillary_input="{subpath[0][5]}"+os.path.sep+ancillary_subdir+"{MM[0]}"+ancillary_sprod_ident
@active_if(activate_monanom_comput)
@transform(new_starting_files, formatter(formatter_in), add_inputs(ancillary_input), formatter_out)
def modis_chla_mondiff(input_file, output_file):
output_file = functions.list_to_element(output_file)
functions.check_output_dir(os.path.dirname(output_file))
args = {"input_file": input_file, "output_file": output_file, "output_format": 'GTIFF', "options": "compress=lzw"}
raster_image_math.do_oper_subtraction(**args)
def std_precip_1monperc(input_file, output_file):
output_file = functions.list_to_element(output_file)
functions.check_output_dir(os.path.dirname(output_file))
args = {"input_file": input_file[0], "avg_file": input_file[1], "output_file": output_file, "output_format": 'GTIFF', "options": "compress=lzw"}
raster_image_math.do_compute_perc_diff_vs_avg(**args)
def std_precip_1mondiff(input_file, output_file):
output_file = functions.list_to_element(output_file)
functions.check_output_dir(os.path.dirname(output_file))
args = {"input_file": input_file, "output_file": output_file, "output_format": 'GTIFF', "options": "compress=lzw"}
raster_image_math.do_oper_subtraction(**args)
def vgt_ndvi_1monmax(input_file, output_file):
output_file = functions.list_to_element(output_file)
functions.check_output_dir(os.path.dirname(output_file))
args = {"input_file": input_file, "output_file": output_file, "output_format": 'GTIFF', "options": "compress = lzw"}
raster_image_math.do_max_image(**args)
def create_pipeline(starting_sprod):
# ---------------------------------------------------------------------
# Define input files: Chla is the 'driver', sst,kd and par 'ancillary inputs'
chla_prod="modis-chla"
chla_prod_ident = functions.set_path_filename_no_date(chla_prod, starting_sprod, mapset, version, ext)
chla_input_dir = es_constants.processing_dir+ \
functions.set_path_sub_directory(chla_prod, starting_sprod, 'Derived', version, mapset)
#chla_files = chla_input_dir+"2014*"+chla_prod_ident
# ---------------------------------------------------------------------
sst_prod="modis-sst"
sst_prod_ident = functions.set_path_filename_no_date(sst_prod, starting_sprod, mapset, version, ext)
sst_input_dir = es_constants.processing_dir+ \
functions.set_path_sub_directory(sst_prod, starting_sprod, 'Derived', version, mapset)
# ---------------------------------------------------------------------
kd_prod="modis-kd490"
kd_prod_ident = functions.set_path_filename_no_date(kd_prod, starting_sprod, mapset, version, ext)
kd_input_dir = es_constants.processing_dir+ \
functions.set_path_sub_directory(kd_prod, starting_sprod, 'Derived', version, mapset)
kd_files = kd_input_dir+"*"+kd_prod_ident
# ---------------------------------------------------------------------
par_prod="modis-par"
par_prod_ident = functions.set_path_filename_no_date(par_prod, starting_sprod, mapset, version, ext)
par_input_dir = es_constants.processing_dir+ \
functions.set_path_sub_directory(par_prod, starting_sprod, 'Derived', version, mapset)
# Read input product nodata
chla_prod_info = querydb.get_product_out_info(productcode=chla_prod, subproductcode="chla-day", version=version)
chla_product_info = functions.list_to_element(chla_prod_info)
chla_nodata = chla_product_info.nodata
sst_prod_info = querydb.get_product_out_info(productcode=sst_prod, subproductcode="sst-day", version=version)
sst_product_info = functions.list_to_element(sst_prod_info)
sst_nodata = sst_product_info.nodata
kd_prod_info = querydb.get_product_out_info(productcode=kd_prod, subproductcode="kd490-day", version=version)
kd_product_info = functions.list_to_element(kd_prod_info)
kd_nodata = kd_product_info.nodata
par_prod_info = querydb.get_product_out_info(productcode=par_prod, subproductcode="par-day", version=version)
par_product_info = functions.list_to_element(par_prod_info)
par_nodata = par_product_info.nodata
# ---------------------------------------------------------------------
# Monthly Primary Productivity from chl-a, sst, kd490 and par monthly data
output_sprod="1mon"
out_prod_ident = functions.set_path_filename_no_date(prod, output_sprod, mapset,version, ext)
output_subdir = functions.set_path_sub_directory (prod, output_sprod, 'Derived', version, mapset)
# Starting files monthly composites
formatter_kd="(?P<YYYYMM>[0-9]{6})"+kd_prod_ident
formatter_out="{subpath[0][5]}"+os.path.sep+output_subdir+"{YYYYMM[0]}"+out_prod_ident
ancillary_sst = sst_input_dir+"{YYYYMM[0]}"+sst_prod_ident
ancillary_par = par_input_dir+"{YYYYMM[0]}"+par_prod_ident
ancillary_chla = chla_input_dir+"{YYYYMM[0]}"+chla_prod_ident
@active_if(activate_pp_1mon_comput)
@transform(kd_files, formatter(formatter_kd), add_inputs(ancillary_chla, ancillary_par, ancillary_sst), formatter_out)
def modis_pp_1mon(input_file, output_file):
output_file = functions.list_to_element(output_file)
functions.check_output_dir(os.path.dirname(output_file))
args = {"chla_file": input_file[1], "sst_file": input_file[3], "kd_file": input_file[0],"par_file": input_file[2], \
"sst_nodata": sst_nodata, "kd_nodata": kd_nodata,\
"par_nodata": par_nodata, "output_file": output_file, "output_nodata": -9999, "output_format": 'GTIFF',\
"output_type": None, "options": "compress=lzw"}
raster_image_math.do_compute_primary_production(**args)
def std_precip_1monnp(input_file, output_file):
output_file = functions.list_to_element(output_file)
functions.check_output_dir(os.path.dirname(output_file))
args = {"input_file": input_file[0], "min_file": input_file[1],"max_file": input_file[2], "output_file": output_file, "output_format": 'GTIFF', "options": "compress=lzw"}
raster_image_math.do_make_vci(**args)
