of the show_area parameter which was derived from the HTTP Request Data
345596
public function &draw_select_box($in_tag, $in_array, $in_value = false)
    {
        $text = "";
        $text .= '<select class="' . $this->query->getBootstrapStyle('design_dropdown') . 'reportico-prepare-drop-select" name="execute_mode">';
        $text .= '<OPTION selected label="MAINTAIN" value="MAINTAIN">Maintain</OPTION>';
        $text .= '<OPTION label="PREPARE" value="PREPARE">Prepare</OPTION>';
        $text .= '</SELECT>';
        return $text;
    }
281340
protected function Area()
    {
        if (!$this->area) {
            $this->area = new Area(Request::GetData('area'));
        }
        return $this->area;
    }
264631
def area(self):
        
        # area of the sides of the extrusion
        area = abs(self.primitive.height *
                   self.primitive.polygon.length)
        # area of the two caps of the extrusion
        area += self.primitive.polygon.area * 2
        return area
310839
def match_ospf_area
      str = config_get('route_map', 'match_ospf_area', @get_args)
      return if str.nil?
      str.empty? ? default_match_ospf_area : str.split
    end
1366787
def as_detail(cls, protocol=Protocol.http, *args, **kwargs):
        '''  '''
        return cls.as_view('detail', protocol, *args, **kwargs)
905753
def get_unit_primitive_area(self):
        

        A_ads = self.surface_area
        A_clean = self.clean_entry.surface_area
        n = (A_ads / A_clean)
        return n
646414
def get_routing_areas():
        
        LOGGER.debug("RoutingAreaService.get_routing_areas")
        args = {'http_operation': 'GET', 'operation_path': ''}
        response = RoutingAreaService.requester.call(args)
        ret = None
        if response.rc == 0:
            ret = []
            for routing_area in response.response_content['routingAreas']:
                ret.append(RoutingArea.json_2_routing_area(routing_area))
        elif response.rc != 404:
            err_msg = 'RoutingAreaService.get_routing_areas - Problem while getting routing areas. ' \
                      'Reason: ' + str(response.response_content) + '-' + str(response.error_message) + \
                      " (" + str(response.rc) + ")"
            LOGGER.warning(err_msg)
        return ret
714058
def lv_load_areas(self):
        
        for lv_load_area in self._grid._graph.nodes():
            if isinstance(lv_load_area, LVLoadAreaDing0):
                if lv_load_area.ring == self:
                    yield lv_load_area
632115
def set_area_geometry(w, src):
    
    assert "areaSource" in src.tag
    geometry_node = src.nodes[get_taglist(src).index("areaGeometry")]
    area_attrs = parse_area_geometry(geometry_node)
    w.poly(parts=[area_attrs["polygon"].tolist()])
933702
def area_fraction_dict(self):
        
        return {hkl: self.miller_area_dict[hkl] / self.surface_area
                for hkl in self.miller_area_dict.keys()}
1299871
def data(self):
        """"""

        # the environment variable CONTENT_LENGTH may be empty or missing
        try:
            request_body_size = int(self.environ.get('CONTENT_LENGTH', 0))
        except (ValueError):
            request_body_size = 0

        data = self.environ['wsgi.input'].read(request_body_size)

        return data
529214
def get_area_def(self, key):
        """"""
        projection = self.nc["goes_imager_projection"]
        a = projection.attrs['semi_major_axis']
        h = projection.attrs['perspective_point_height']
        b = projection.attrs['semi_minor_axis']

        lon_0 = projection.attrs['longitude_of_projection_origin']
        sweep_axis = projection.attrs['sweep_angle_axis'][0]

        # x and y extents in m
        h = float(h)
        x = self['x']
        y = self['y']
        x_l = h * x[0]
        x_r = h * x[-1]
        y_l = h * y[-1]
        y_u = h * y[0]
        x_half = (x_r - x_l) / (self.ncols - 1) / 2.
        y_half = (y_u - y_l) / (self.nlines - 1) / 2.
        area_extent = (x_l - x_half, y_l - y_half, x_r + x_half, y_u + y_half)

        proj_dict = {'a': float(a),
                     'b': float(b),
                     'lon_0': float(lon_0),
                     'h': h,
                     'proj': 'geos',
                     'units': 'm',
                     'sweep': sweep_axis}

        area = geometry.AreaDefinition(
            self.nc.attrs.get('orbital_slot', 'abi_geos'),
            self.nc.attrs.get('spatial_resolution', 'ABI L1B file area'),
            'abi_geos',
            proj_dict,
            self.ncols,
            self.nlines,
            np.asarray(area_extent))

        return area
122641
def soma_surface_area(nrn, neurite_type=NeuriteType.soma):
    '''
    '''
    assert neurite_type == NeuriteType.soma, 'Neurite type must be soma'
    return 4 * math.pi * nrn.soma.radius ** 2
684966
function showUsage(req, res) {
	var egPayload = {
		"username": "soandso",
		"message": "Hello bot",
		"vars": {
			"name": "Soandso"
		}
	};
	res.writeHead(200, {"Content-Type": "text/plain"});
	res.write("Usage: curl -i \\\n");
	res.write("   -H \"Content-Type: application/json\" \\\n");
	res.write("   -X POST -d '" + JSON.stringify(egPayload) + "' \\\n");
	res.write("   http://localhost:2001/reply");
	res.end();
}
164156
function publishAreaVisibility() {
      const showing = visibilityIsChanging ? !$scope.model.areaShowing : $scope.model.areaShowing;
      return visibility.updateAreaVisibility( { [ $scope.features.area.name ]: showing } );
   }
316113
def dinfContributingArea(self,
                             contributing_area_grid,
                             flow_dir_grid,
                             outlet_shapefile=None,
                             weight_grid=None,
                             edge_contamination=False,
                             ):
        
        log("PROCESS: DinfContributingArea")

        # Construct the taudem command line.
        cmd = [os.path.join(self.taudem_exe_path, 'areadinf'),
               '-ang', flow_dir_grid,
               '-sca', contributing_area_grid,
               ]

        if outlet_shapefile:
            cmd += ['-o', outlet_shapefile]
        if weight_grid:
            cmd += ['-wg', weight_grid]
        if not edge_contamination:
            cmd = cmd + ['-nc']

        self._run_mpi_cmd(cmd)

        # create projection file
        self._add_prj_file(flow_dir_grid,
                           contributing_area_grid)
116696
def surface_area(self):
        
        m = self.lattice.matrix
        return np.linalg.norm(np.cross(m[0], m[1]))