コード例 #1
0
 def baffle_s(self):
     """The spacing between baffles."""
     baffle_s = ((self.BAFFLE_K / (
         (2 * self.expansion_h * (self.vel_grad_avg**2) *
          pc.viscosity_kinematic(self.temp))).to_base_units())**(1 / 3) *
                 self.q / self.chan_w).to(u.cm)
     return baffle_s
コード例 #2
0
    def _set_outlet_pipe(self):
        outlet_pipe_q = self.q / self.outlet_pipe_n

        # outlet_pipe_nd = pc.pipe_flow_nd(
        #     outlet_pipe_q,
        #     ut.get_sdr(self.outlet_pipe_spec),
        #     self.outlet_pipe_hl_max,
        #     self.outlet_pipe_l,
        #     pc.viscosity_kinematic(self.temp),
        #     mat.PVC_PIPE_ROUGH,
        #     self.outlet_pipe_k_minor
        # )

        outlet_pipe_nd = pc.pipe_flow_nd(
            outlet_pipe_q,
            ut.get_sdr(self.outlet_pipe_spec),
            self.outlet_pipe_hl_max,
            self.outlet_pipe_l,
            pc.viscosity_kinematic(self.temp),
            mat.PVC_PIPE_ROUGH,
            2 * hl.EL90_K_MINOR + hl.PIPE_ENTRANCE_K_MINOR + \
                 hl.PIPE_EXIT_K_MINOR
        )

        self.outlet_pipe = Pipe(l=self.outlet_pipe_l,
                                q=outlet_pipe_q,
                                size=outlet_pipe_nd,
                                spec=self.outlet_pipe_spec,
                                k_minor=self.outlet_pipe_k_minor)
コード例 #3
0
 def chan_w_min_hs_ratio(self):
     """The minimum channel width."""
     chan_w_min_hs_ratio = (
         (self.HS_RATIO_MIN * self.q / self.end_water_depth) *
         (self.BAFFLE_K /
          (2 * self.end_water_depth * pc.viscosity_kinematic(self.temp) *
           self.vel_grad_avg**2))**(1 / 3)).to(u.cm)
     return chan_w_min_hs_ratio
コード例 #4
0
 def vel_grad_avg(self):
     """Calculate the average velocity gradient (G-bar) of water flowing
     through the flocculator.
     :returns: Average velocity gradient (G-bar)
     :rtype: float * 1 / second
     """
     return ((u.standard_gravity * self.HL) /
            (pc.viscosity_kinematic(self.temp) * self.Gt)).to(u.s ** -1)
コード例 #5
0
 def _inlet_depth_hl_min(self):
     """Minimum depth of the inlet channel to stay within acceptable head
     loss.
     """
     inlet_chan_hl_depth = pc.horiz_chan_h(
         self.q, self.inlet_w_pre_weir, self.inlet_hl_max, self.l,
         pc.viscosity_kinematic(self.temp), mat.CONCRETE_PIPE_ROUGH, False)
     return inlet_chan_hl_depth
コード例 #6
0
 def inlet_w_post_weir(self):
     """Width of the inlet channel (post-weir)"""
     inlet_w_post_weir = max(
         self.w_min,
         pc.horiz_chan_w(self.q, self.inlet_h, self.inlet_h, self.l,
                         pc.viscosity_kinematic(self.temp),
                         mat.CONCRETE_PIPE_ROUGH, 1, 0))
     return inlet_w_post_weir
コード例 #7
0
def vel_term_floc(ConcAl, ConcClay, coag, material, DIM_FRACTAL, DiamTarget,
                  Temp):
    """Calculate floc terminal velocity."""
    WaterDensity = pc.density_water(Temp).magnitude
    return (((pc.gravity.magnitude * material.Diameter**2) /
             (18 * PHI_FLOC * pc.viscosity_kinematic(Temp).magnitude)) *
            ((dens_floc_init(ConcAl, ConcClay, coag, material).magnitude -
              WaterDensity) / WaterDensity) *
            (DiamTarget / material.Diameter)**(DIM_FRACTAL - 1))
コード例 #8
0
 def baffle_S(self):
     """Return the spacing between baffles.
     :returns: Spacing between baffles
     :rtype: int
     """
     return ((self.BAFFLE_K /
             ((2 * self.expansion_H * (self.vel_grad_avg ** 2) *
              pc.viscosity_kinematic(self.temp))).to_base_units()) ** (1/3) *
            self.Q / self.channel_W).to(u.cm)
コード例 #9
0
 def _inlet_w_pre_weir_hl_min(self):
     """Minimum width of the inlet channel (pre-weir) that doesn't exceed
     the permissible head loss.
     """
     inlet_w_pre_weir_hl_min = pc.horiz_chan_w(
         self.q, self.inlet_depth_max, self.inlet_hl_max, self.l,
         pc.viscosity_kinematic(self.temp), mat.CONCRETE_PIPE_ROUGH, False,
         0)
     return inlet_w_pre_weir_hl_min
コード例 #10
0
 def expansion_h_max(self):
     """"The maximum distance between expansions for the largest
     allowable H/S ratio.
     """
     expansion_h_max = (
         ((self.BAFFLE_K / (2 * pc.viscosity_kinematic(self.temp) *
                            (self.vel_grad_avg**2))) *
          (self.q * self.HS_RATIO_MAX / self.chan_w)**3)**(1 / 4)).to(u.m)
     return expansion_h_max
コード例 #11
0
def diam_floc_vel_term(ConcAl, ConcClay, coag, material, DIM_FRACTAL, VelTerm,
                       Temp):
    """Calculate floc diamter as a function of terminal velocity."""
    WaterDensity = pc.density_water(Temp).magnitude
    return (material.Diameter * (
        ((18 * VelTerm * PHI_FLOC * pc.viscosity_kinematic(Temp).magnitude) /
         (pc.gravity.magnitude * material.Diameter**2)) *
        (WaterDensity /
         (dens_floc_init(ConcAl, ConcClay, coag, material).magnitude -
          WaterDensity)))**(1 / (DIM_FRACTAL - 1)))
コード例 #12
0
 def outlet_pipe_q_max(self):
     """Maximum flow through the outlet pipe."""
     outlet_pipe_q_max = pc.flow_pipe(
         pipe.ID_SDR(self.outlet_pipe_nd_max,
                     ut.get_sdr(self.outlet_pipe_spec)),
         self.outlet_pipe_hl_max, self.outlet_pipe_l,
         pc.viscosity_kinematic(self.temp), mat.PVC_PIPE_ROUGH,
         self.outlet_pipe_k_minor)
     return ut.round_step(outlet_pipe_q_max.to(u.L / u.s),
                          step=0.0001 * u.L / u.s)
コード例 #13
0
 def W_min_HS_ratio(self):
     """Calculate the minimum flocculator channel width, given the minimum
     ratio between expansion height (H) and baffle spacing (S).
     :returns: Minimum channel width given H_e/S
     :rtype: float * centimeter
     """
     return ((self.HS_RATIO_MIN * self.Q / self.downstream_H) *
            (self.BAFFLE_K /
             (2 * self.downstream_H * pc.viscosity_kinematic(self.temp) * self.vel_grad_avg ** 2)) ** (1/3)
            ).to(u.cm)
コード例 #14
0
ファイル: sed_tank.py プロジェクト: es859/aguaclara
 def outlet_man_nd(self):
     """The nominal diameter of the outlet manifold."""
     outlet_man_nd = pc.manifold_nd(self.q_tank, self.OUTLET_MAN_HL,
                                    self.l_inner,
                                    self.outlet_man_orifice_q_ratio_max,
                                    pc.viscosity_kinematic(self.temp),
                                    mat.PVC_PIPE_ROUGH.to(u.m),
                                    hl.PIPE_EXIT_K_MINOR,
                                    self.outlet_man_orifice_n_est,
                                    self.outlet_man_sdr)
     return outlet_man_nd
コード例 #15
0
def pc_viscous(EnergyDis, Temp, Time, DiamTube, ConcClay, ConcAl,
               ConcNatOrgMat, NatOrgMat, coag, material, FittingParam,
               RatioHeightDiameter):
    """"""
    return ((3 / 2) * np.log10(
        (2 / 3) * np.pi * FittingParam * Time *
        np.sqrt(EnergyDis / (pc.viscosity_kinematic(Temp).magnitude)) *
        alpha(DiamTube, ConcClay, ConcAl, ConcNatOrgMat, NatOrgMat, coag,
              material, RatioHeightDiameter) * (np.pi / 6)**(2 / 3) *
        (material.Diameter / sep_dist_clay(ConcClay, material).magnitude)**2 +
        1))
コード例 #16
0
ファイル: pipeline.py プロジェクト: es859/aguaclara
 def nu(self):
     """The kinematic viscosity of the fluid passing through the pipeline
     component.
     """
     if self.fluid_type == 'water':
         return pc.viscosity_kinematic(self.temp)
     elif self.fluid_type == 'pacl':
         print('unimplemented')
         pass
     elif self.fluid_type == 'alum':
         print('unimplemented')
         pass
コード例 #17
0
 def expansion_max_H(self):
     """"Return the maximum distance between expansions for the largest
     allowable H/S ratio.
     :returns: Maximum expansion distance
     :rtype: float * meter
     Examples
     --------
     exp_dist_max(20*u.L/u.s, 40*u.cm, 37000, 25*u.degC, 2*u.m)
     0.375 meter
     """
     return (((self.BAFFLE_K / (2 * pc.viscosity_kinematic(self.temp) * (self.vel_grad_avg ** 2))) *
             (self.Q * self.RATIO_MAX_HS / self.channel_W) ** 3) ** (1/4)).to(u.m)
コード例 #18
0
def viscosity_kinematic_pacl(conc_pacl, temp):
    """Return the dynamic viscosity of water at a given temperature.

    If given units, the function will automatically convert to Kelvin.
    If not given units, the function will assume Kelvin.
    This function assumes that the temperature dependence can be explained
    based on the effect on water and that there is no confounding effect from
    the coagulant.
    """
    nu = (1 + (2.383 * 10**-5) *
          conc_pacl**1.893) * pc.viscosity_kinematic(temp).magnitude
    return nu
コード例 #19
0
ファイル: cdc.py プロジェクト: es859/aguaclara
    def _alum_nu(self, coag_conc):
        """Return the dynamic viscosity of water at a given temperature.

        If given units, the function will automatically convert to Kelvin.
        If not given units, the function will assume Kelvin.
        This function assumes that the temperature dependence can be explained
        based on the effect on water and that there is no confounding effect from
        the coagulant.
        """
        alum_nu = \
            (1 + (4.255 * 10 ** -6) * coag_conc.magnitude ** 2.289) * \
            pc.viscosity_kinematic(self.temp)
        return alum_nu
コード例 #20
0
ファイル: ent.py プロジェクト: es859/aguaclara
    def _set_drain_pipe(self):
        """The inner diameter of the entrance tank drain pipe."""
        drain_pipe_k_minor = \
            hl.PIPE_ENTRANCE_K_MINOR + hl.PIPE_EXIT_K_MINOR + hl.EL90_K_MINOR

        nu = pc.viscosity_kinematic(self.temp)
        drain_id = pc.diam_pipe(self.q, self.floc_end_depth,
                                self.floc_end_depth, nu, mat.PVC_PIPE_ROUGH,
                                drain_pipe_k_minor)

        self.drain_pipe = Pipe(id=drain_id,
                               k_minor=drain_pipe_k_minor,
                               spec=self.spec)
コード例 #21
0
def viscosity_kinematic_chem(conc_chem, temp, en_chem):
    """Return the dynamic viscosity of water at a given temperature.

    If given units, the function will automatically convert to Kelvin.
    If not given units, the function will assume Kelvin.
    """
    if en_chem == 0:
        nu = viscosity_kinematic_alum(conc_chem, temp).magnitude
    if en_chem == 1:
        nu = viscosity_kinematic_pacl(conc_chem, temp).magnitude
    if en_chem not in [0, 1]:
        nu = pc.viscosity_kinematic(temp).magnitude
    return nu
コード例 #22
0
    def _set_drain_pipe(self):
        drain_k_minor = hl.PIPE_ENTRANCE_K_MINOR + hl.PIPE_EXIT_K_MINOR + hl.EL90_K_MINOR
        drain_nd = pc.pipe_flow_nd(self.q, ut.get_sdr(self.drain_spec),
                                   self.SED_DEPTH_EST,
                                   self.SED_DEPTH_EST + self.inlet_w,
                                   pc.viscosity_kinematic(self.temp),
                                   mat.PVC_PIPE_ROUGH, drain_k_minor)

        self.drain_pipe = Pipe(
            size=drain_nd,
            spec=self.drain_spec,
            k_minor=drain_k_minor,
        )
コード例 #23
0
def time_col_laminar(EnergyDis, Temp, ConcAl, ConcClay, coag, material,
                     DiamTarget, DiamTube, DIM_FRACTAL, RatioHeightDiameter):
    """Calculate single collision time for laminar flow mediated collisions.

    Calculated as a function of floc size.
    """
    return ((
        (1 / 6) * ((6 / np.pi)**(1 / 3)) *
        frac_vol_floc_initial(ConcAl, ConcClay, coag, material)**(-2 / 3) *
        (pc.viscosity_kinematic(Temp).magnitude / EnergyDis)**(1 / 2) *
        (DiamTarget / material.Diameter)**(2 * DIM_FRACTAL / 3 - 2)
    )  # End of the numerator
            / (gamma_coag(ConcClay, ConcAl, coag, material, DiamTube,
                          RatioHeightDiameter))  # End of the denominator
            )
コード例 #24
0
 def outlet_post_weir_w(self):
     """Width of the outlet channel (post-weir)."""
     outlet_post_weir_w = max(
         #need self.outlet_to_filter_nd
         self.fitting_s + pipe.fitting_od(self.outlet_pipe.size),
         self.fitting_s + pipe.fitting_od(self.drain_pipe.size),
         self.w_min,
         pc.horiz_chan_w(
             self.q,
             self.outlet_weir_depth -
             self.outlet_free_h,  #what is outlet_free_h
             self.outlet_weir_depth,
             self.l,
             pc.viscosity_kinematic(self.temp),
             mat.PVC_PIPE_ROUGH,
             1,
             hl.PIPE_ENTRANCE_K_MINOR + hl.PIPE_EXIT_K_MINOR +
             hl.EL90_K_MINOR))
     return outlet_post_weir_w
コード例 #25
0
def eta_kolmogorov(EnergyDis, Temp):
    return ((pc.viscosity_kinematic(Temp).magnitude**3) / EnergyDis)**(1 / 4)
コード例 #26
0
def reynolds_rapid_mix(PlantFlow, IDTube, Temp):
    return (4 * PlantFlow /
            (np.pi * IDTube * pc.viscosity_kinematic(Temp).magnitude))
コード例 #27
0
 def vel_grad_avg(self):
     """The average velocity gradient of water."""
     vel_grad_avg = ((u.standard_gravity * self.hl) /
                     (pc.viscosity_kinematic(self.temp) * self.gt)).to(
                         u.s**-1)
     return vel_grad_avg