Ejemplo n.º 1
0
def main():

    po().prog_title('1.0.0')
    start_time = time.time()

    COUNTER = P['COUNTER']
    DEL_T = P['DEL_T']
    DSTEP = P['DSTEP']
    TSTEP = P['TSTEP']
    T = [DEL_T*i for i in xrange(COUNTER)]
    RHO = P['RHO']
    RE = P['RE']

    SwiP = PC.SwimmerParameters(P['CE'], P['DELTA_CORE'], P['SW_KUTTA'])
    GeoP = PC.GeoVDVParameters(P['N_BODY'], P['S'], P['C'], P['K'], P['EPSILON'])
    MotP1 = PC.MotionParameters(0., 0., P['V0'], P['THETA_MAX'], P['F'], P['PHI'])

    S1 = Swimmer(SwiP, GeoP, MotP1, COUNTER)
    Swimmers = [S1]

    po().calc_input(MotP1.THETA_MAX/np.pi*180.,RE,MotP1.THETA_MAX/np.pi*180.,DEL_T)

    # Data points per cycle == 1/(F*DEL_T)
    for i in xrange(COUNTER):
        if i == 0:
            po().initialize_output(T[i])
        else:
            if np.fmod(i,P['VERBOSITY']) == 0:
                po().timestep_header(i,T[i])

        for Swim in Swimmers:
                Swim.Body.panel_positions(DSTEP, T[i])
                Swim.Body.surface_kinematics(DSTEP, TSTEP, DEL_T, T[i], i)
                Swim.edge_shed(DEL_T, i)
                Swim.wake_shed(DEL_T, i)
        quilt(Swimmers, RHO, DEL_T, i)
        wake_rollup(Swimmers, DEL_T, i)
        archive(S1.Body.AF.x_mid)
        archive(S1.Body.AF.z_mid)

        if np.fmod(i,P['VERBOSITY']) == 0:
            po().solution_output(0,0,0,0,0,0)
            po().solution_complete_output(i/float(COUNTER-1)*100.)

    total_time = time.time()-start_time
    print "Simulation time:", np.round(total_time, 3), "seconds"

    graph.body_wake_plot(Swimmers)
Ejemplo n.º 2
0
    def wake_shed(self, DEL_T, i):
        """Updates the positions of the Wake panels.

        This should only be done once each time step for a swimmer.

        Args:
            DEL_T: Time step length.
            i: Time step number.
            Edge: Edge panel of separation.
            Wake: Wake panels.
            V0: Free-stream velocity.
        """
        Edge = self.Edge
        Wake = self.Wake
        V0 = self.V0

        # Initialize wake coordinates when i==1
        if i == 1:

            Wake.x[0, :] = Edge.x[-1, :]
            Wake.y[0, :] = Edge.y[-1, :]
            Wake.z[0, :] = Edge.z[-1, :]

            #            Wake.x[1:,:] = Wake.x[0,:] + np.arange(1,np.size(Wake.x))*(-V0)*DEL_T
            #            Wake.y[1:,:] = Wake.y[0,:] + np.arange(1,np.size(Wake.y))*(-V0)*DEL_T
            Wake.x[1:, :] = Wake.x[0, :] + np.arange(
                1, Wake.x.shape[1] + 1) * (-V0) * DEL_T
            Wake.y[1:, :] = Wake.y[0, :]
            Wake.z[1:, :] = Wake.z[0, :]

        else:
            archive(Wake.x, axis=0)
            archive(Wake.y, axis=0)
            archive(Wake.z, axis=0)
            archive(Wake.mu, axis=0)

            Wake.x[0, :] = Edge.x[-1, :]
            Wake.y[0, :] = Edge.y[-1, :]
            Wake.z[0, :] = Edge.z[-1, :]
            Wake.mu[0, :] = Edge.mu

            Wake.gamma[0, :] = -Wake.mu[0, :]
            Wake.gamma[1:-1, :] = Wake.mu[:-1] - Wake.mu[1:, :]
            Wake.gamma[-1, :] = Wake.mu[-1, :]
Ejemplo n.º 3
0
    def wake_shed(self, DEL_T, i):
        """Updates the positions of the Wake panels.

        This should only be done once each time step for a swimmer.

        Args:
            DEL_T: Time step length.
            i: Time step number.
            Edge: Edge panel of separation.
            Wake: Wake panels.
            V0: Free-stream velocity.
        """
        Edge = self.Edge
        Wake = self.Wake
        V0 = self.V0

        # Initialize wake coordinates when i==1
        if i == 1:

            Wake.x[0,:] = Edge.x[-1,:]
            Wake.y[0,:] = Edge.y[-1,:]
            Wake.z[0,:] = Edge.z[-1,:]

#            Wake.x[1:,:] = Wake.x[0,:] + np.arange(1,np.size(Wake.x))*(-V0)*DEL_T
#            Wake.y[1:,:] = Wake.y[0,:] + np.arange(1,np.size(Wake.y))*(-V0)*DEL_T
            Wake.x[1:,:] = Wake.x[0,:] + np.arange(1,Wake.x.shape[1]+1)*(-V0)*DEL_T
            Wake.y[1:,:] = Wake.y[0,:]
            Wake.z[1:,:] = Wake.z[0,:]

        else:
            archive(Wake.x, axis=0)
            archive(Wake.y, axis=0)
            archive(Wake.z, axis=0)
            archive(Wake.mu, axis=0)

            Wake.x[0,:] = Edge.x[-1,:]
            Wake.y[0,:] = Edge.y[-1,:]
            Wake.z[0,:] = Edge.z[-1,:]
            Wake.mu[0,:] = Edge.mu

            Wake.gamma[0,:] = -Wake.mu[0,:]
            Wake.gamma[1:-1,:] = Wake.mu[:-1]-Wake.mu[1:,:]
            Wake.gamma[-1,:] = Wake.mu[-1,:]
Ejemplo n.º 4
0
    def wake_shed(self, DEL_T, i):
        """Updates the positions of the Wake panels.

        This should only be done once each time step for a swimmer.

        Args:
            DEL_T: Time step length.
            i: Time step number.
            Edge: Edge panel of separation.
            Wake: Wake panels.
            V0: Free-stream velocity.
        """
        Edge = self.Edge
        Wake = self.Wake
        V0 = self.V0

        if i == 0:
            pass

        elif i == 1:
            # Initialize wake coordinates
            Wake.x[0] = Edge.x[-1]
            Wake.z[0] = Edge.z[-1]

            Wake.x[1:] = Wake.x[0] + np.arange(1,np.size(Wake.x))*(-V0)*DEL_T
            Wake.z[1:] = Wake.z[0]

        elif i > 1:
            archive(Wake.x)
            archive(Wake.z)
            archive(Wake.mu)

            Wake.x[0] = Edge.x[-1]
            Wake.z[0] = Edge.z[-1]
            Wake.mu[0] = Edge.mu

            Wake.gamma[0] = -Wake.mu[0]
            Wake.gamma[1:-1] = Wake.mu[:-1]-Wake.mu[1:]
            Wake.gamma[-1] = Wake.mu[-1]
Ejemplo n.º 5
0
po().calc_input(MotL[0].THETA_MAX/np.pi*180.,RE,MotL[0].THETA_MAX/np.pi*180.,DEL_T)
po().initialize_output(T[START_COUNTER])
outerCorr = 1

for i in xrange(START_COUNTER, COUNTER):
    if i == 0:
        for Swim in Swimmers:
                Swim.Body.panel_positions(P, i)
                Swim.Body.surface_kinematics(P, i)
                Swim.edge_shed(DEL_T, i)
                Swim.wake_shed(DEL_T, i)
        solve_phi(Swimmers, P, i, outerCorr)
        for Swim in Swimmers:
            Swim.Body.force(P, i)
            Swim.Body.free_swimming(P, i)
            archive(Swim.Body.AF.x_mid)
            archive(Swim.Body.AF.z_mid)
        graph.plot_n_go(Swimmers, i, P)
        DIO.write_data(P, i, DEL_T, SwiL, GeoL, MotL, Swimmers)

    else:
        if np.fmod(i, VERBOSITY) == 0:
            po().timestep_header(i,T[i])

        for Swim in Swimmers:
            Swim.Body.panel_positions(P, i)
            Swim.Body.surface_kinematics(P, i)
            Swim.edge_shed(DEL_T, i)
            Swim.wake_shed(DEL_T, i)
        solve_phi(Swimmers, P, i, outerCorr)
        wake_rollup(Swimmers, DEL_T, i, P)
Ejemplo n.º 6
0
for i in xrange(START_COUNTER, COUNTER):
    if i == 0:
        for Swim in Swimmers:
            Swim.Body.panel_positions(DSTEP, T[i], P['THETA'][i],
                                      P['HEAVE'][i])
            Swim.Body.surface_kinematics(DSTEP, TSTEP, P['THETA_MINUS'][i],
                                         P['THETA_PLUS'][i],
                                         P['HEAVE_MINUS'][i],
                                         P['HEAVE_PLUS'][i], DEL_T, T[i], i)
            Swim.edge_shed(DEL_T, i)
            Swim.wake_shed(DEL_T, i)
            Swim.Body.force(P['THETA'][i], RHO, P['V0'], P['C'], 1.0, i)
        solve_phi(Swimmers, RHO, DEL_T, i, outerCorr)
        wake_rollup(Swimmers, DEL_T, i)
        archive(Swimmers[0].Body.AF.x_mid)
        archive(Swimmers[0].Body.AF.z_mid)
        SolidP[0].nodes[:,
                        0] = (SolidP[0].nodesNew[:, 0] -
                              SolidP[0].nodesNew[0, 0]) * np.cos(P['THETA'][i])
        SolidP[0].nodes[:,
                        1] = (SolidP[0].nodesNew[:, 0] -
                              SolidP[0].nodesNew[0, 0]) * np.sin(P['THETA'][i])
        graph.plot_n_go(Swimmers[0].Edge, Swimmers[0].Body, SolidP[0], P['V0'],
                        P['T'][i], P['HEAVE'][i])
        DIO.write_data(P, i, DEL_T, SwiP, GeoP, MotP, Swimmers, SolidP, FSIP,
                       PyFEAP)

    else:
        if np.fmod(i, P['VERBOSITY']) == 0:
            po().timestep_header(i, T[i])
Ejemplo n.º 7
0
po().calc_input(MotP[0].THETA_MAX/np.pi*180.,RE,MotP[0].THETA_MAX/np.pi*180.,DEL_T)
po().initialize_output(P['T'][START_COUNTER])
outerCorr = 2

for i in xrange(START_COUNTER, COUNTER):
    if i == 0:
        for Swim in Swimmers:
            Swim.Body.panel_positions(DSTEP, T[i], P['THETA'][i], P['HEAVE'][i])
            Swim.Body.surface_kinematics(DSTEP, TSTEP, P['THETA_MINUS'][i], P['THETA_PLUS'][i], P['HEAVE_MINUS'][i], P['HEAVE_PLUS'][i], DEL_T, T[i], i)
            Swim.edge_shed(DEL_T, i)
            Swim.wake_shed(DEL_T, i)
            Swim.Body.force(P['THETA'][i], RHO, P['V0'], P['C'], 1.0, i, P['SW_SV_FORCES'])
        solve_phi(Swimmers, RHO, DEL_T, i, outerCorr)
        wake_rollup(Swimmers, DEL_T, i, P)
        archive(Swimmers[0].Body.AF.x_mid)
        archive(Swimmers[0].Body.AF.z_mid)
        SolidP[0].nodes[:,0] = (SolidP[0].nodesNew[:,0] - SolidP[0].nodesNew[0,0])*np.cos(P['THETA'][i])
        SolidP[0].nodes[:,1] = (SolidP[0].nodesNew[:,0] - SolidP[0].nodesNew[0,0])*np.sin(P['THETA'][i])
        graph.plot_n_go(Swimmers, P['V0'], P['T'][i], P['HEAVE'][i], i, P['SW_PLOT_FIG'])
        DIO.write_data(P, i, DEL_T, SwiP, GeoP, MotP, Swimmers, SolidP, FSIP, PyFEAP)
    else:
        if np.fmod(i,P['VERBOSITY']) == 0:
            po().timestep_header(i,T[i])
            po().fsi_header()

        FSIP[0].readFsiControls(P['FIXED_PT_RELAX'], P['N_OUTERCORR_MAX'])       
        FSIP[0].__init__(Swimmers[0].Body, SolidP[0])
        outerCorr = 0
        while True:
            outerCorr += 1
Ejemplo n.º 8
0
    def wake_shed(self, DEL_T, i):
        """Updates the positions of the Wake panels.

        This should only be done once each time step for a swimmer.

        Args:
            DEL_T: Time step length.
            i: Time step number.
            Edge: Edge panel of separation.
            Wake: Wake panels.
            V0: Free-stream velocity.
        """
        Edge = self.Edge
        Wake = self.Wake
        V0 = self.V0

        # Initialize wake coordinates when i==1
        if i == 1:

            Wake.x[0] = Edge.x[-1]
            Wake.z[0] = Edge.z[-1]

            Wake.x[1:] = Wake.x[0] + np.arange(1,np.size(Wake.x))*(-V0)*DEL_T
            Wake.z[1:] = Wake.z[0]

        else:
            archive(Wake.x)
            archive(Wake.z)
            archive(Wake.mu)

            Wake.x[0] = Edge.x[-1]
            Wake.z[0] = Edge.z[-1]
            Wake.mu[0] = Edge.mu

            Wake.gamma[0] = -Wake.mu[0]
            Wake.gamma[1:-1] = Wake.mu[:-1]-Wake.mu[1:]
            Wake.gamma[-1] = Wake.mu[-1]

#    def influence_matrices(self, i):
#        """Constructs the influence coefficient matrices.
#
#        Args:
#            i: Time step number.
#            Body: Body of the swimmer.
#            Edge: Edge panel of separation.
#            Wake: Wake panels.
#        """
#        Body = self.Body
#        Edge = self.Edge
#        Wake = self.Wake
#
#        # Tangential and normal body panels and panel length calculations
#        (xp1,xp2,zp) = transformation(Body.AF.x_col,Body.AF.z_col,Body.AF.x,Body.AF.z)
#
#        # Body source singularities influencing the body
#        # Transpose so that row elements represent the effect on the (row number)th panel
#        Body.phi_s = np.transpose((xp1 * np.log(xp1**2 + zp**2) - xp2 * np.log(xp2**2 + zp**2) \
#                                  + 2*zp*(np.arctan2(zp,xp2) - np.arctan2(zp,xp1)))/(4*np.pi))
#
#        # Body doublet singularities influencing body itself
#        # Transpose similar to phi_s
#        Body.phi_db = np.transpose(-(np.arctan2(zp,xp2)\
#                                  - np.arctan2(zp,xp1))/(2*np.pi))
#
#        # Edge doublet influencing the body
#        (xp1,xp2,zp) = transformation(Body.AF.x_col,Body.AF.z_col,Edge.x,Edge.z)
#
#        if i > 0: # No wake panels until i==1
#            # Wake doublets influencing the body
#            (xp1_w,xp2_w,zp_w) = transformation(Body.AF.x_col,Body.AF.z_col,Wake.x[:i+1],Wake.z[:i+1])
#            # Join edge and wake doublet influences into a single matrix
#            xp1 = np.insert(xp1, Edge.N, xp1_w, axis=0)
#            xp2 = np.insert(xp2, Edge.N, xp2_w, axis=0)
#            zp = np.insert(zp, Edge.N, zp_w, axis=0)
#
#        Body.phi_dw = np.transpose(-(np.arctan2(zp,xp2) \
#                                   -np.arctan2(zp,xp1))/(2*np.pi))
#
#    def kutta(self, RHO, DEL_T, i):
#        """Applies Kutta condition to the swimmer's trailing edge.
#
#        Args:
#            RHO: Fluid density.
#            SW_KUTTA: Switch for either explicit (0) or unsteady (1) Kutta
#                condition.
#            DEL_T: Time step length.
#            i: Time step number.
#            Body: Body of the swimmer.
#            Edge: Edge panel of separation.
#            Wake: Wake panels.
#        """
#        SW_KUTTA = self.SW_KUTTA
#        Body = self.Body
#        Edge = self.Edge
#        Wake = self.Wake
#
#        n_iter = 0
#        mu_guess = np.empty(2) # [0] is current guess, [1] is previous
#        delta_cp = np.empty(2) # [0] is current delta_cp, [1] is previous
#
#        while True:
#            n_iter += 1
#
#            if n_iter == 1:
#                # Begin with explicit Kutta condition as first guess
#                # Construct the augmented body matrix by combining body and trailing edge panel arrays
#                c = np.zeros((Body.N,Body.N))
#                c[:,0] = -Body.phi_dw[:,0] # c contains the explicit Kutta condition (first and last columns)
#                c[:,-1] = Body.phi_dw[:,0]
#                Body.phi_dinv = np.linalg.inv(Body.phi_db + c)
#                # Get rhs
#                if i == 1:
#                    rhs = -np.dot(Body.phi_s,Body.sigma)
#                else:
#                    rhs = -np.dot(Body.phi_s,Body.sigma) - np.dot(Body.phi_dw[:,1:],Wake.mu[:i])
#                # Solve for body doublet strengths using explicit Kutta
#                Body.mu = np.dot(Body.phi_dinv,rhs)
#                # First mu_guess (from explicit Kutta)
#                mu_guess[0] = Body.mu[-1]-Body.mu[0]
#
#            else:
#                if n_iter == 2: # Make a second initial guess
#                    # Update phi_dinv so it no longer includes explicit Kutta condition
#                    Body.phi_dinv = np.linalg.inv(Body.phi_db)
#
#                    mu_guess[1] = mu_guess[0]
#                    delta_cp[1] = delta_cp[0]
#                    mu_guess[0] = 0.8*mu_guess[1] # Multiply first (explicit) guess by arbitrary constant to get second guess
#
#                else: # Newton method to get delta_cp == 0
#                    # Get slope, which is change in delta_cp divided by change in mu_guess
#                    slope = (delta_cp[0]-delta_cp[1])/(mu_guess[0]-mu_guess[1])
#                    mu_guess[1] = mu_guess[0]
#                    delta_cp[1] = delta_cp[0]
#                    mu_guess[0] = mu_guess[1] - delta_cp[0]/slope
#
#                # Form right-hand side including mu_guess as an influence
#                if i == 1:
#                    rhs = -np.dot(Body.phi_s,Body.sigma) - np.squeeze(np.dot(Body.phi_dw,mu_guess[0]))
#                else:
#                    rhs = -np.dot(Body.phi_s,Body.sigma) - np.dot(Body.phi_dw,np.insert(Wake.mu[:i],0,mu_guess[0]))
#
#                Body.mu = np.dot(Body.phi_dinv,rhs)
#
#
#            Body.pressure(RHO, DEL_T, i)
#            if SW_KUTTA == 0:
#                break
#            delta_cp[0] = np.absolute(Body.cp[-1]-Body.cp[0])
#            if delta_cp[0] < 0.0001:
#                break
#
#        # mu_past used in differencing for pressure
#        Body.mu_past[1,:] = Body.mu_past[0,:]
#        Body.mu_past[0,:] = Body.mu
#
#        Edge.mu = mu_guess[0]
#        Edge.gamma[0] = -Edge.mu
#        Edge.gamma[1] = Edge.mu
#
#        # Get gamma of body panels for use in wake rollup
#        Body.gamma[0] = -Body.mu[0]
#        Body.gamma[1:-1] = Body.mu[:-1]-Body.mu[1:]
#        Body.gamma[-1] = Body.mu[-1]
#
#    def wake_rollup(self, DEL_T, i):
#        """Performs wake rollup on a swimmer's wake panels.
#
#        Args:
#            DEL_T: Time step length.
#            i: Time step number.
#            Body: Body of the swimmer.
#            Edge: Edge panel of separation.
#            Wake: Wake panels.
#            DELTA_CORE: Constant used to avoid singularities when getting too close
#                to other panels.
#        """
#        Body = self.Body
#        Edge = self.Edge
#        Wake = self.Wake
#        DELTA_CORE = self.DELTA_CORE
#
#        # Wake panels initialize when i==2
#        if i == 0:
#            pass
#
#        else:
#
#            NT = i # Number of targets (wake panel points that are rolling up)
#
#            vx = np.zeros(NT)
#            vz = np.zeros(NT)
#
#            # Coordinate transformation for body panels influencing wake
#            (xp1,xp2,zp) = transformation(Wake.x[1:i+1],Wake.z[1:i+1],Body.AF.x,Body.AF.z)
#
#            # Angle of normal vector with respect to global z-axis
#            (nx,nz) = panel_vectors(Body.AF.x,Body.AF.z)[2:4]
#            beta = np.arctan2(-nx,nz)
#
#            # Katz-Plotkin eqns 10.20 and 10.21 for body source influence
#            dummy1 = np.transpose(np.log((xp1**2+zp**2)/(xp2**2+zp**2))/(4*np.pi))
#            dummy2 = np.transpose((np.arctan2(zp,xp2)-np.arctan2(zp,xp1))/(2*np.pi))
#
#            # Rotate back to global coordinates
#            dummy3 = dummy1*np.cos(beta) - dummy2*np.sin(beta)
#            dummy4 = dummy1*np.sin(beta) + dummy2*np.cos(beta)
#
#            # Finish eqns 10.20 and 10.21 for induced velocity by multiplying with Body.sigma
#            vx = np.dot(dummy3,Body.sigma)
#            vz = np.dot(dummy4,Body.sigma)
#
#            # Formation of (x-x0) and (z-z0) matrices, similar to xp1/xp2/zp but coordinate transformation is not necessary
#            NI = Body.N+1
#            xp = np.repeat(Wake.x[1:i+1,np.newaxis].T,NI,0) - np.repeat(Body.AF.x[:,np.newaxis],NT,1)
#            zp = np.repeat(Wake.z[1:i+1,np.newaxis].T,NI,0) - np.repeat(Body.AF.z[:,np.newaxis],NT,1)
#
#            # Find distance r_b between each influence/target
#            r_b = np.sqrt(xp**2+zp**2)
#
#            # Katz-Plotkin eqns 10.9 and 10.10 for body doublet (represented as point vortices) influence
#            dummy1 = np.transpose(zp/(2*np.pi*(r_b**2+DELTA_CORE**2)))
#            dummy2 = np.transpose(-xp/(2*np.pi*(r_b**2+DELTA_CORE**2)))
#
#            # Finish eqns 10.9 and 10.10 by multiplying with Body.gamma, add to induced velocity
#            vx += np.dot(dummy1,Body.gamma)
#            vz += np.dot(dummy2,Body.gamma)
#
#            # Formation of (x-x0) and (z-z0) matrices, similar to xp1/xp2/zp but coordinate transformation is not necessary
#            NI = Edge.N+1
#            xp = np.repeat(Wake.x[1:i+1,np.newaxis].T,NI,0) - np.repeat(Edge.x[:,np.newaxis],NT,1)
#            zp = np.repeat(Wake.z[1:i+1,np.newaxis].T,NI,0) - np.repeat(Edge.z[:,np.newaxis],NT,1)
#
#            # Find distance r_e between each influence/target
#            r_e = np.sqrt(xp**2+zp**2)
#
#            # Katz-Plotkin eqns 10.9 and 10.10 for edge (as point vortices) influence
#            dummy1 = np.transpose(zp/(2*np.pi*(r_e**2+DELTA_CORE**2)))
#            dummy2 = np.transpose(-xp/(2*np.pi*(r_e**2+DELTA_CORE**2)))
#
#            # Finish eqns 10.9 and 10.10 by multiplying with Edge.gamma, add to induced velocity
#            vx += np.dot(dummy1,Edge.gamma)
#            vz += np.dot(dummy2,Edge.gamma)
#
#            # Formation of (x-x0) and (z-z0) matrices, similar to xp1/xp2/zp but coordinate transformation is not necessary
#            NI = i+1
#            xp = np.repeat(Wake.x[1:i+1,np.newaxis].T,NI,0) - np.repeat(Wake.x[:i+1,np.newaxis],NT,1)
#            zp = np.repeat(Wake.z[1:i+1,np.newaxis].T,NI,0) - np.repeat(Wake.z[:i+1,np.newaxis],NT,1)
#
#            # Find distance r_w between each influence/target
#            r_w = np.sqrt(xp**2+zp**2)
#
#            # Katz-Plotkin eqns 10.9 and 10.10 for wake (as point vortices) influence
#            dummy1 = np.transpose(zp/(2*np.pi*(r_w**2+DELTA_CORE**2)))
#            dummy2 = np.transpose(-xp/(2*np.pi*(r_w**2+DELTA_CORE**2)))
#
#            # Finish eqns 10.9 and 10.10 by multiplying with Wake.gamma, add to induced velocity
#            vx += np.dot(dummy1,Wake.gamma[:i+1])
#            vz += np.dot(dummy2,Wake.gamma[:i+1])
#
#            # Modify wake with the total induced velocity
#            Wake.x[1:i+1] += vx*DEL_T
#            Wake.z[1:i+1] += vz*DEL_T
Ejemplo n.º 9
0
                MotL[0].THETA_MAX / np.pi * 180., DEL_T)
po().initialize_output(T[START_COUNTER])
outerCorr = 1

for i in xrange(START_COUNTER, COUNTER):
    if i == 0:
        for Swim in Swimmers:
            Swim.Body.panel_positions(P, i)
            Swim.Body.surface_kinematics(P, i)
            Swim.edge_shed(DEL_T, i)
            Swim.wake_shed(DEL_T, i)
        solve_phi(Swimmers, P, i, outerCorr)
        for Swim in Swimmers:
            Swim.Body.force(P, i)
            Swim.Body.free_swimming(P, i)
            archive(Swim.Body.AF.x_mid)
            archive(Swim.Body.AF.z_mid)
        graph.plot_n_go(Swimmers, i, P)
        DIO.write_data(P, i, DEL_T, SwiL, GeoL, MotL, Swimmers)

    else:
        if np.fmod(i, VERBOSITY) == 0:
            po().timestep_header(i, T[i])

        for Swim in Swimmers:
            Swim.Body.panel_positions(P, i)
            Swim.Body.surface_kinematics(P, i)
            Swim.edge_shed(DEL_T, i)
            Swim.wake_shed(DEL_T, i)
        solve_phi(Swimmers, P, i, outerCorr)
        wake_rollup(Swimmers, DEL_T, i, P)