Ejemplo n.º 1
0
    def get_plot_data_source_summary(self, ids):
        """
        Get plot counts grouped by data sources and assessment years

        Parameters
        ----------
        ids : str
            comma-delimited list of IDs for plots to include
            (should be PNTID, CCID, FCID or PLTID depending on
            self.summary_level)

        Returns
        -------
        plot_data_sources : numpy.recarray
            ID, DATA_SOURCE, ASSESSMENT_YEAR
        """

        sql = """
            EXEC lemma.GET_PLOT_DATA_SOURCE_SUMMARY
            @ids = '%s',
            @summary_level = '%s'
        """
        sql = sql % (ids, self.summary_level)
        (records, descr) = self.get_data(sql)
        plot_data_sources = utilities.pyodbc2rec(records, descr)
        return plot_data_sources
Ejemplo n.º 2
0
    def get_metadata_codes(self, table_names):
        """
        Get metadata for just the codes in the tables passed in

        Parameters
        ----------
        table_names: str
            comma-delimited list of table names to get metadata for

        Returns
        -------
        metadata_codes: numpy.recarray
            code names and descriptions
        """
        sql = """
            EXEC lemma.GET_METADATA_TABLE_CODES
                @table_names = '%s'
        """
        sql = sql % (table_names)
        try:
            (records, desc) = self.get_data(sql)
        except IndexError:
            # If the query returned no records, return None
            # this means there were no coded fields in the table(s)
            metadata_codes = None
        else:
            metadata_codes = utilities.pyodbc2rec(records, desc)

        return metadata_codes
Ejemplo n.º 3
0
    def get_metadata_code_dictionary(self, field_name):
        """
        Build a dictionary of codes for a given field

        Parameters
        ----------
        table_name : str
            The database object name
        field_name : str
            The field name within the table_name

        Returns
        -------
        code_dict : dict
            A dictionary of all codes associated with this field
        """

        sql = "EXEC lemma.GET_METADATA_CODES '"
        sql += field_name + "'"
        code_dict = {}
        (records, desc) = self.get_data(sql)
        code_table = utilities.pyodbc2rec(records, desc)
        for row in code_table:
            code_value = row.CODE_VALUE
            inner_dict = {}
            for key in row.dtype.names:
                # if key <> 'CODE_VALUE':
                inner_dict[key] = row[key]
            code_dict[code_value] = inner_dict
        return code_dict
Ejemplo n.º 4
0
    def get_plot_image_pairs(self, keyword):
        """
        Query the database to get all plot assessment years and available
        imagery years and crosswalk the returned information using the
        logic associated with each keyword

        Parameters
        ----------
        keyword : str
            Keyword to determine the logic of how to match plot assessment
            years to imagery years. The only keyword implemented now is
            'DEFAULT', which matches plots to the closest year of imagery
            available.

        Returns
        -------
        plot_image_years : numpy.recarray
            PLOT_YEAR, IMAGE_YEAR
        """

        sql = """
            EXEC lemma.GET_PLOT_IMAGE_PAIRS
              @model_region = %d,
              @buffer = %d,
              @image_source = '%s',
              @image_version = %f,
              @keyword = '%s'
        """
        sql = sql % (self.model_region, self.buffer, self.image_source,
                     self.image_version, keyword)
        (records, descr) = self.get_data(sql)
        plot_image_years = utilities.pyodbc2rec(records, descr)
        return plot_image_years
Ejemplo n.º 5
0
    def get_species_names(self, id_str, lump_table):
        """
        Get common names and scientific names for species codes

        Parameters
        ----------
        id_str: str
            comma-delimited list of IDs to include

        Returns
        -------
        species_names : numpy.recarray
            SPP_SYMBOL, SCIENTIFIC_NAME, COMMON_NAME
        """

        sql = """
        EXEC lemma.GET_SPECIES_NAMES
            @ids = '%s',
            @summary_level = '%s',
            @model_type = '%s',
            @lump_table = %d
        """

        sql = sql % (id_str, self.summary_level, self.model_type, lump_table)
        (records, descr) = self.get_data(sql)
        species_info = utilities.pyodbc2rec(records, descr)
        return species_info
Ejemplo n.º 6
0
    def get_structure_metadata(self, project_id):
        """
        Get metadata for all of the structure attributes
        
        Parameters
        ----------
        None
            
        Returns
        -------
            fields: numpy.recarray
                field names and definitions
            codes: numpy.recarray
                code names and definitions
        """

        sql = """
            EXEC lemma.GET_STRUCTURE_METADATA_FIELDS
                @model_type = '%s',
                @summary_level = '%s',
                @model_region = %d,
                @project_id = '%s'
        """
        sql = sql % (self.model_type, self.summary_level, \
                     self.model_region, project_id)
        records, descr = self.get_data(sql)
        metadata_fields = utilities.pyodbc2rec(records, descr)

        structure_table = self.get_structure_table_name()
        metadata_codes = self.get_metadata_codes(structure_table)
        return metadata_fields, metadata_codes
Ejemplo n.º 7
0
    def get_attribute_data(self, id_str):
        """
        Get an attribute table which includes both continuous stand
        variables and species by abundance measure (basal area, percent
        cover, etc.) for use in accuracy assessment for NN models.

        Parameters
        ----------
        id_str: str
            Comma-delimited list of IDs to include

        Returns
        -------
        attibute_data: numpy.recarray
            Structure and species attribute data summarized at
                the requested summary level
        """

        sql = """
            EXEC lemma.GET_MODEL_ATTRIBUTES
            @ids = '%s',
            @summary_level = '%s',
            @model_region = %d,
            @model_type = '%s'
        """

        sql = sql % (
            id_str, self.summary_level, self.model_region, self.model_type)
        (records, descr) = self.get_data(sql)
        stand_attribute_data = utilities.pyodbc2rec(records, descr)
        return stand_attribute_data
Ejemplo n.º 8
0
 def get_ordination_variable_descriptions(self, ordination_vars):
     """
     """
     sql = """
         EXEC lemma.GET_ORDINATION_VARIABLE_DESCRIPTIONS
             @ordination_vars = '%s'
         """
     sql = sql % (ordination_vars)
     (records, descr) = self.get_data(sql)
     ordination_vars = utilities.pyodbc2rec(records, descr)
     return ordination_vars
Ejemplo n.º 9
0
    def get_area_estimates(self, comparison_year):
        """
        Get estimates of acres separated into forest, nonforest
        and nonsampled areas

        Parameters
        ----------
        comparison_year : int
            Year for which plot assessment years will be compared.  If more
            than one plot exists at a location, the plot that is temporally
            closer to this parameter will be chosen

        Returns
        -------
        observed_data: numpy.recarray
            structure and species data and # forest hectares
        nf_hectares: float
            # nonforest hectares
        ns_hectares: float
            # nonsampled hectares
        """

        sql_base = """
           EXEC lemma.GET_AREA_EXPANSIONS
            @model_region = %d,
            @model_type = '%s',
            @glc_group = '%s',
            @model_year = %d
        """

        # Forested area
        sql = sql_base % (self.model_region, self.model_type, 'F',
            comparison_year)
        (records, descr) = self.get_data(sql)
        observed_data = utilities.pyodbc2rec(records, descr)

        # Nonforest area
        sql = sql_base % (self.model_region, self.model_type, 'NF',
            comparison_year)
        (records, descr) = self.get_data(sql)
        nf_hectares = records[0][0]

        # Non-sampled area
        sql = sql_base % (self.model_region, self.model_type, 'NS',
            comparison_year)
        (records, descr) = self.get_data(sql)
        ns_hectares = records[0][0]

        return observed_data, nf_hectares, ns_hectares
Ejemplo n.º 10
0
    def get_species_plot_counts(self, id_str):
        sql = """
            EXEC lemma.GET_SPECIES_PLOT_COUNTS
              @ids = '%s',
              @summary_level = '%s',
              @model_region = %d,
              @model_type = '%s'
        """

        sql = sql % (id_str, self.summary_level,
                     self.model_region, self.model_type)

        records, descr = self.get_data(sql)
        species_plot_counts = utilities.pyodbc2rec(records, descr)
        return species_plot_counts
Ejemplo n.º 11
0
    def get_validation_attributes(self):
        """
        Get structure and species attributes for validation plots

        Returns
        -------
            validation_attributes: numpy.recarray
        """

        sql = """
            EXEC lemma.GET_VALIDATION_ATTRIBUTES
                @summary_level = '%s',
                @model_region = %d,
                @model_type = '%s'
        """
        sql = sql % (self.summary_level, self.model_region, self.model_type)
        records, descr = self.get_data(sql)
        validation_attributes = utilities.pyodbc2rec(records, descr)
        return validation_attributes
Ejemplo n.º 12
0
    def get_environmental_matrix(self, id_str, plot_years, image_years,
                                 spatial_vars):
        """
        Get a matrix of plots by environmental variables for use as
        input to NN models

        Parameters
        ----------
        id_str: str
            comma-delimited list of IDs to include
        plot_years: str
            comma-delimited list of plot assessment years
        image_years: str
            comma-delimited list of image years
        spatial_vars: str
            comma-delimited list of spatial variables to return

        Returns
        -------
        env_matrix: numpy.recarray
            **ID: unique plot identifier as specified by summary_level
            ordination variables (names correspond to spatial_vars list)
        """

        sql = """
            EXEC lemma.GET_ENVIRONMENTAL_MATRIX
              @ids = '%s',
              @summary_level = '%s',
              @model_region = %d,
              @model_type = '%s',
              @plot_years = '%s',
              @image_years = '%s',
              @image_source = '%s',
              @image_version = %f,
              @spatial_vars = '%s'
        """
        sql = sql % (id_str, self.summary_level, self.model_region,
                     self.model_type, plot_years, image_years,
                     self.image_source, self.image_version, spatial_vars)
        records, descr = self.get_data(sql)
        env_matrix = utilities.pyodbc2rec(records, descr)
        return env_matrix
Ejemplo n.º 13
0
    def get_species_metadata(self):
        """
        Get metadata for all of the species attributes

        Returns
        -------
            fields: numpy.recarray
                field names and definitions
            codes: numpy.recarray
                code names and definitions
        """
        sql = """
            EXEC lemma.GET_SPECIES_METADATA
              @model_region = %d,
              @model_type = '%s'
        """
        sql = sql % (self.model_region, self.model_type)
        records, descr = self.get_data(sql)
        species_metadata = utilities.pyodbc2rec(records, descr)
        return species_metadata
Ejemplo n.º 14
0
    def get_species_matrix(self, id_str, purpose, lump_table):
        """
        Get a species data in the format of a crosstab table of
        species by abundance measure (basal area, percent cover, etc.)
        for use as input to NN models or for attaching to model output
        or for using in model accuracy assessment

        Parameters
        ----------
        id_str: str
            comma-delimited list of IDs to include
        purpose: str
            ORDINATION: for use as input to model ordination
            ATTRIBUTE: for joining attributes to model output
            ACCURACY: for use in accuracy assessment
        lump_table: bool
            indicates whether to lump species using this model region's
            lump table in the model database

        Returns
        -------
        species_matrix: numpy.recarray
            **ID: unique plot identifier as specified by summary_level
            species abundance (names differ by which species occur in
                model region)
        """

        sql = """
            EXEC lemma.GET_SPECIES_MATRIX
              @ids = '%s',
              @summary_level = '%s',
              @model_region = %d,
              @model_type = '%s',
              @purpose = '%s',
              @lump_table = %d
        """
        sql = sql % (id_str, self.summary_level, self.model_region,
                     self.model_type, purpose, lump_table)
        (records, descr) = self.get_data(sql)
        species_matrix = utilities.pyodbc2rec(records, descr)
        return species_matrix
Ejemplo n.º 15
0
    def get_model_region_window(self):
        """
        Get the bounding coordinates for this model region

        Parameters
        ----------
        None

        Returns
        -------
        mr_bounds : numpy.recarray
            X_MIN, Y_MIN, X_MAX, Y_MAX, BOUNDARY_RASTER (file location)
        """

        sql = """
            EXEC lemma.GET_MODEL_REGION_WINDOW
                @model_region = %d
        """
        sql = sql % (self.model_region)
        (records, descr) = self.get_data(sql)
        bounds = utilities.pyodbc2rec(records, descr)
        return bounds
Ejemplo n.º 16
0
    def get_people_info(self):
        """
        Get information about people associated with this project
        for the accuracy assessment report

        Parameters
        ----------
        None

        Returns
        -------
        model_region_info: numpy.recarray
        """

        sql = """
            EXEC lemma.get_people_info
            @project_id = '%s'
        """
        sql = sql % (self.project_id)
        (records, descr) = self.get_data(sql)
        people_info = utilities.pyodbc2rec(records, descr)
        return people_info
Ejemplo n.º 17
0
    def get_hex_attributes(self, comparison_year, plot_years, image_years):
        """
        Get hexagon IDs and continuous stand attributes for forested
        Annual plots to be used in Riemann accuracy diagnostics

        Parameters
        ----------
        comparison_year: int
            Year for which plot assessment years will be compared.  If more
            than one plot exists at a location, the plot that is temporally
            closer to this parameter will be chosen
        plot_years: str
            comma-delimited list of plot assessment years
        image_years: str
            comma-delimited list of image years

        Returns
        -------
        hex_attributes: numpy.recarray

        """
        sql = """
            EXEC lemma.GET_HEX_ATTRIBUTES
                @model_region = %d,
                @model_type = '%s',
                @model_year = %d,
                @summary_level = '%s',
                @plot_years = '%s',
                @image_years = '%s',
                @image_source = '%s',
                @image_version = %f
        """
        sql = sql % (self.model_region, self.model_type,
                     comparison_year, self.summary_level,
                     plot_years, image_years, self.image_source,
                     self.image_version)
        records, descr = self.get_data(sql)
        hex_attributes = utilities.pyodbc2rec(records, descr)
        return hex_attributes
Ejemplo n.º 18
0
    def get_people_info(self):
        """
        Get information about people associated with this project
        for the accuracy assessment report

        Parameters
        ----------
        None

        Returns
        -------
        model_region_info: numpy.recarray
        """

        sql = """
            EXEC lemma.get_people_info
            @project_id = '%s'
        """
        sql = sql % (self.project_id)
        (records, descr) = self.get_data(sql)
        people_info = utilities.pyodbc2rec(records, descr)
        return people_info
Ejemplo n.º 19
0
    def get_metadata_fields(self, table_names):
        """
        Get metadata for just the fields in the tables passed in

        Parameters
        ----------
        table_names: str
            comma-delimited list of table names to get metadata for

        Returns
        -------
        metadata_fields: numpy.recarray
            field names and descriptions
        """
        sql = """
            EXEC lemma.GET_METADATA_TABLE_FIELDS
                @table_names = '%s'
        """
        sql = sql % (table_names)
        (records, desc) = self.get_data(sql)
        metadata_fields = utilities.pyodbc2rec(records, desc)
        return metadata_fields
Ejemplo n.º 20
0
    def get_ordination_variable_list(self, var_types, variable_filter):
        """
        Query the database to get a list of ordination variables and their
        file locations for this model region

        Parameters
        ----------
        var_types: str
            keyword to specify which variables to return
            Values:
                ALL = all variables that have complete coverage for this MR
                DEFAULT = subset of variables chosen for this MR
        variable_filter: str
            method of filtering ordination variables: RAW or FOCAL
        Returns
        -------
        ordination_table : numpy.recarray
            VARIABLE_NAME, VARIABLE_PATH
        """

        # Create the parameter signature and get the possible ordination
        # variables
        sql = """
            EXEC lemma.GET_ORDINATION_VARIABLE_LIST
              @model_region = %d,
              @model_type = '%s',
              @model_year = %d,
              @buffer = %d,
              @var_types = '%s',
              @image_source = '%s',
              @image_version = %f,
              @variable_filter = '%s'
        """
        sql = sql % (self.model_region, self.model_type, self.model_year,
                     self.buffer, var_types, self.image_source,
                     self.image_version, variable_filter)
        (records, descr) = self.get_data(sql)
        ordination_table = utilities.pyodbc2rec(records, descr)
        return ordination_table
Ejemplo n.º 21
0
    def get_model_region_info(self):
        """
        Get information about this model region for the accuracy
        assessment report

        Parameters
        ----------
        None

        Returns
        -------
        model_region_info: numpy.recarray
        """

        sql = """
            EXEC lemma.get_model_region_info
            @model_region = %d,
            @project_id = '%s'
        """

        sql = sql % (self.model_region, self.project_id)
        (records, descr) = self.get_data(sql)
        model_region_info = utilities.pyodbc2rec(records, descr)
        return model_region_info
Ejemplo n.º 22
0
    def get_model_region_info(self):
        """
        Get information about this model region for the accuracy
        assessment report

        Parameters
        ----------
        None

        Returns
        -------
        model_region_info: numpy.recarray
        """

        sql = """
            EXEC lemma.get_model_region_info
            @model_region = %d,
            @project_id = '%s'
        """

        sql = sql % (self.model_region, self.project_id)
        (records, descr) = self.get_data(sql)
        model_region_info = utilities.pyodbc2rec(records, descr)
        return model_region_info