The cell volume.

        Args:
            None

        Returns:
            (float): The cell volume.
507002
def volume( self ):
        
        return np.dot( self.matrix[0], np.cross( self.matrix[1], self.matrix[2] ) )
607882
def GetVolumeByIndex(self, volume_index):
    
    if not self._is_parsed:
      self._Parse()
      self._is_parsed = True

    if volume_index < 0 or volume_index >= len(self._volume_identifiers):
      return None

    volume_identifier = self._volume_identifiers[volume_index]
    return self._volumes[volume_identifier]
33556
def subvolumes(self):
        
        self.SYNC()
        self._getDevices()
        self._getRoots()
        self._getMounts()
        self._getUsage()

        volumes = self.volumes.values()
        volumes.sort(key=(lambda v: v.fullPath))
        return volumes
936190
def length(self, rows=None):
    
    rows = tf.range(self._capacity) if rows is None else rows
    return tf.gather(self._length, rows)
901363
def _convert_volume(self, volume):
        
        data = {
            'host': volume.get('hostPath'),
            'container': volume.get('containerPath'),
            'readonly': volume.get('mode') == 'RO',
        }
        return data
10495
def calculate_pore_volume(self):
        
        self.pore_volume = sphere_volume(self.calculate_pore_diameter() / 2)
        self.properties['pore_volume'] = self.pore_volume
        return self.pore_volume
1013238
public double getVolume() {
		if (volume!=0) {
			return volume;
		}
		volume =  a*b*c*
		Math.sqrt(1-Math.cos(alphaRad)*Math.cos(alphaRad)-Math.cos(betaRad)*Math.cos(betaRad)-Math.cos(gammaRad)*Math.cos(gammaRad)
				+2.0*Math.cos(alphaRad)*Math.cos(betaRad)*Math.cos(gammaRad));

		return volume;
	}
20642
def control_volumes(self):
        
        if self._control_volumes is None:
            #   1/3. * (0.5 * edge_length) * covolume
            # = 1/6 * edge_length**2 * ce_ratio_edge_ratio
            v = self.ei_dot_ei * self.ce_ratios / 6.0
            # Explicitly sum up contributions per cell first. Makes
            # numpy.add.at faster.
            # For every node k (range(4)), check for which edges k appears in
            # local_idx, and sum() up the v's from there.
            idx = self.local_idx
            vals = numpy.array(
                [
                    sum([v[i, j] for i, j in zip(*numpy.where(idx == k)[1:])])
                    for k in range(4)
                ]
            ).T
            #
            self._control_volumes = numpy.zeros(len(self.node_coords))
            numpy.add.at(self._control_volumes, self.cells["nodes"], vals)
        return self._control_volumes
43559
def os_volumes(self):
        
        if not self.__os_volumes:
            self.__os_volumes = OsVolumes(self.__connection)
        return self.__os_volumes
37963
def output_size(self) -> Tuple[Sequence[Shape], Sequence[Shape], Sequence[Shape], int]:
        ''''''
        return self._cell.output_size
69161
def S(self):
        
        S = np.array([[self._plane_width / self._vol_width, 0, 0],
                      [0, self._plane_height / self._vol_height, 0],
                      [0, 0, self._depth_scale / self._vol_depth]])
        return S
185102
def _GetStat(self):
    
    stat_object = super(BDEFileEntry, self)._GetStat()

    stat_object.size = self._bde_volume.get_size()

    return stat_object
989317
def get_cell_length(flow_model):
        
        assert flow_model.lower() in FlowModelConst.d8_lens
        return FlowModelConst.d8_lens.get(flow_model.lower())
965318
def volume(self, value=None):
        """"""
        mass = vtk.vtkMassProperties()
        mass.SetGlobalWarningDisplay(0)
        mass.SetInputData(self.polydata())
        mass.Update()
        v = mass.GetVolume()
        if value is not None:
            if not v:
                colors.printc("~bomb Volume is zero: cannot rescale.", c=1, end="")
                colors.printc(" Consider adding actor.triangle()", c=1)
                return self
            self.scale(value / v)
            return self
        else:
            return v
753085
def _GetStat(self):
    
    stat_object = super(FVDEFileEntry, self)._GetStat()

    stat_object.size = self._fvde_volume.get_size()

    return stat_object
529912
def get_cell(self, coords, cell_mode=CellMode.cooked):
    
    return self.parse_cell(self.get_row(coords[1])[coords[0]], coords, cell_mode)
203467
def _AddVolume(self, volume):
    
    if volume.identifier in self._volumes:
      raise KeyError(
          'Volume object already set for volume identifier: {0:s}'.format(
              volume.identifier))

    self._volumes[volume.identifier] = volume
    self._volume_identifiers.append(volume.identifier)