动网格udf

画大饼

如下udf程序，进气阀1与进气阀2具有相同的运动状态，但下面程序进气阀1循环完成之后，转角已经改变，怎样修改才可以使阀1和2同时运动呢
DEFINE_CG_MOTION(val_s_1_s_move, dt, vel, omega, time, dtime)
{
        // 进气阀1动网格函数  
        Thread *t;Thread *t_s_1_up;Thread *t_s_1_down;Thread *cylin;Thread *wall;
        face_t f;
        cell_t c;
        int n,i,size;
        float vt=0.0;
        Node *v;
        real NV_VEC(A);
        real forces,force_sgas,force_sgas1,force_sgas_sum,down_force_sgas,force_sspring,dv,P,V;
        real ks=1000;  //进气阀弹簧系数 ？？？？N/m
       
        real XYZ[ND_ND];
        real x_s_1_up[ND_ND],x_s_1_up_j[ND_ND];                        //进气阀片上表面重心
        real x_s_1_down[ND_ND],x_s_1_down_j[ND_ND];//进气阀片下表面重心
        Domain *domain;
        float time1=0,time2=0;
    FILE *fpout;       
        NV_S(vel,=,0.0);NV_S(omega,=,0.0);forces=0;force_sgas=0.0;force_sgas1=0.0;force_sspring = 0.0;force_sgas_sum=0.0=0.0;V=0.0;fpout=fopen("out-1.txt","a");
        //t=DT_THREAD ((Dynamic_Thread *) dt);
        domain=Get_Domain(1);
        t_s_1_up=DT_THREAD(dt);    //获得进气阀上表面线索指针
        t_s_1_down=Lookup_Thread(domain,225);  //获得进气阀下表面线索指针
    cylin=Lookup_Thread(domain,144);
        // 求阀片受力
                 
if (prog==0)
{
                   #if RP_NODE
                begin_f_loop (f,t_s_1_down)
                                                {
                                                        F_AREA (A,f,t_s_1_down);
                                                        force_sgas+=fabs((F_P(f,t_s_1_down)+101325)*NV_MAG(A));
                                                        F_CENTROID(x_s_1_down,f,t_s_1_down);
                                                }
                                end_f_loop (f,t_s_1_down);
                                #endif
                               
                                x_s_1_down_j[0]=PRF_GRHIGH1(x_s_1_down[0]);
                                force_sgas=PRF_GRSUM1(force_sgas);
                                node_to_host_real_1(force_sgas);
                               
                                #if RP_HOST
                                fprintf(fpout,"down force_gas=%g\n",force_sgas);
                                #endif
                                       
                                #if RP_NODE
                    begin_f_loop (f,t_s_1_up)
                                                {
                                                        F_AREA (A,f,t_s_1_up);
                                                        force_sgas1-=fabs((F_P(f,t_s_1_up)+101325)*NV_MAG(A)/1);
                                F_CENTROID(x_s_1_up,f,t_s_1_up);
                                                }
                                end_f_loop (f,t_s_1_up);
                                #endif
                               
                                x_s_1_up_j[0]=PRF_GRHIGH1(x_s_1_up[0]);
                                force_sgas1=PRF_GRSUM1(force_sgas1);
                                node_to_host_real_1(force_sgas1);
                                force_sgas_sum=force_sgas1/0.963+force_sgas;
                               
                                #if RP_HOST
                                fprintf(fpout,"up force_gas=%g\n",force_sgas1);
                                fprintf(fpout,"force_gas=%g\n",force_sgas_sum);
                    #endif
                               
                                node_to_host_real_1(x_s_1_up_j[0]);
                                node_to_host_real_1(x_s_1_down_j[0]);
                               
                                #if RP_HOST
                                        Hs_1=Hs_h-x_s_1_up_j[0];
                force_sspring=ks*(0.004+Hs_1);//预压缩量
                fprintf(fpout,"force_x=%g\n",force_sspring);               
                fprintf(fpout,"force=%g\n",force_sspring+force_sgas_sum);       
                #endif               
        if(force_sspring*force_sgas_sum<0&&fabs(force_sgas_sum)>fabs(force_sspring))       
        {
       forces=force_sgas_sum+force_sspring;
                dv=dtime*forces/m;    //阀片质量
                v_s_1+=dv;
                prog=1;
        }

             vel[0]=v_s_1;
                host_to_node_real_1(vel[0]);
}

else{
                      #if RP_NODE
                begin_f_loop (f,t_s_1_down)
                                                {
                                                        F_AREA (A,f,t_s_1_down);
                                                        force_sgas+=fabs((F_P(f,t_s_1_down)+101325)*NV_MAG(A));
                                                        F_CENTROID(x_s_1_down,f,t_s_1_down);
                                                }
                                end_f_loop (f,t_s_1_down);
                                #endif
                               
                                x_s_1_down_j[0]=PRF_GRHIGH1(x_s_1_down[0]);
                                force_sgas=PRF_GRSUM1(force_sgas);
                               
                                node_to_host_real_1(force_sgas);
                               
                                #if RP_HOST
                                down_force_sgas=force_sgas;
                                fprintf(fpout,"down force_gas=%g\n",force_sgas);
                                #endif
                               
                               
                               
                                #if RP_NODE
                    begin_f_loop (f,t_s_1_up)
                                                {
                                                        F_AREA (A,f,t_s_1_up);
                                                        force_sgas1-=fabs((F_P(f,t_s_1_up)+101325)*NV_MAG(A));
                                F_CENTROID(x_s_1_up,f,t_s_1_up);
                                                }
                                end_f_loop (f,t_s_1_up);
                                #endif
                               
                                x_s_1_up_j[0]=PRF_GRHIGH1(x_s_1_up[0]);
                                force_sgas1=PRF_GRSUM1(force_sgas1);
                                node_to_host_real_1(force_sgas1);
                                force_sgas_sum=force_sgas1+force_sgas;
                                #if RP_HOST
                                fprintf(fpout,"up force_gas=%g\n",force_sgas1);
                                fprintf(fpout,"force_gas=%g\n",force_sgas_sum);
                    #endif
                               
                                node_to_host_real_1(x_s_1_up_j[0]);
                                node_to_host_real_1(x_s_1_down_j[0]);
                                #if RP_HOST
                                        Hs_1=Hs_h-x_s_1_up_j[0];
                                        Hs_1_his[0]=Hs_1_his[1];Hs_1_his[1]=Hs_1_his[2];Hs_1_his[2]=Hs_1;
                force_sspring=ks*(0.004+Hs_1);//预压缩量
                fprintf(fpout,"force_x=%g\n",force_sspring);       
                fprintf(fpout,"force=%g\n",force_sspring+force_sgas_sum);

                s_1_open=judge_opens1(Hs_1_his,force_sspring,force_sgas_sum);
                if (0==s_1_open||2==s_1_open)  //阀片为关闭状态，返回速度为0
                {
                        v_s_1=0.0;
                        vel[0]=v_s_1;
                        v_s_1_x=vel[0];
                }
               
                else if (3==s_1_open&&fantan_ss_1==0) //阀片随着压叉关闭，速度等于压叉速度
                {
                        v_s_1=v_y_1;
                        vel[0]=v_s_1;
                        v_s_1_x=vel[0];
                }
               
        else
                {
                forces=force_sspring+force_sgas_sum;
                dv=dtime*forces/m;    //阀片质量
                v_s_1+=dv;
         vel[0]=v_s_1;
                 v_s_1_x=vel[0];
                }
                  #endif
               
          #if RP_NODE
                ////////反弹,定义上表面位置, 进
                begin_f_loop (f,t_s_1_up)      
                {
                        f_node_loop (f,t_s_1_up,n)
                        {
                                v=F_NODE (f,t_s_1_up,n);
                                if (((x_s_1_down_j[0]+v_s_1*dtime)<=Hs_l+0.00001)&&NODE_POS_NEED_UPDATE(v))     //下表面反弹  进
                                        {
                                                NODE_POS_UPDATED(v);
                                                XYZ[2]=NODE_Z(v);
                                                XYZ[1]=NODE_Y(v);
                                                time1=(x_s_1_down_j[0]-Hs_l-0.00001)/v_s_1;
                                                time2=dtime+time1;
                                                XYZ[0]=Hs_l+0.00001+v_s_1*Cr2*time2+0.0024;
                                                NV_V(NODE_COORD(v),=,XYZ);
                                        }       
                                else if (((x_s_1_up_j[0]+v_s_1*dtime)>Hs_h)&&NODE_POS_NEED_UPDATE(v))     //上表面反弹  进
                                        {
                                                NODE_POS_UPDATED(v);
                                                XYZ[2]=NODE_Z(v);
                                                XYZ[1]=NODE_Y(v);
                                                time1=(Hs_h-x_s_1_up_j[0])/v_s_1;
                                                time2=dtime-time1;
                                                XYZ[0]=Hs_h+v_s_1*Cr1*time2;
                                                NV_V(NODE_COORD(v),=,XYZ);               
                                        }
                        }
                }
                end_f_loop (f,t_s_1_up);
                ////////////////////////
                ////////反弹，定义下表面位置
                begin_f_loop (f,t_s_1_down)      
                {
                        f_node_loop (f,t_s_1_down,n)
                        {
                                v=F_NODE (f,t_s_1_down,n);
                                        if(((x_s_1_down_j[0]+v_s_1*dtime)<=Hs_l+0.00001)&&NODE_POS_NEED_UPDATE(v))   ///下表面反弹,进
                                        {
       
                                                NODE_POS_UPDATED(v);
                                                XYZ[2]=NODE_Z(v);
                                                XYZ[1]=NODE_Y(v);
                                                time1=(x_s_1_down_j[0]-Hs_l-0.00001)/v_s_1;
                                                time2=dtime+time1;
                                                XYZ[0]=Hs_l+0.00001+v_s_1*Cr2*time2;
                                                NV_V(NODE_COORD(v),=,XYZ);                                       
                                        }

                                else if(((x_s_1_up_j[0]+v_s_1*dtime)>Hs_h)&&NODE_POS_NEED_UPDATE(v))   //上表面反弹，进
                                        {
                       
                                                NODE_POS_UPDATED(v);
                                                XYZ[2]=NODE_Z(v);
                                                XYZ[1]=NODE_Y(v);
                                                time1=(Hs_h-x_s_1_up_j[0])/v_s_1;
                                                time2=dtime-time1;
                                                XYZ[0]=Hs_h+v_s_1*Cr1*time2-0.0024;
                                                NV_V(NODE_COORD(v),=,XYZ);                       
                                        }
                        }
                }
                end_f_loop (f,t_s_1_down);
                ////////////////////////
                #endif
                #if RP_HOST
                if ((v_s_1==0)&&fabs(Hs_1_his[0])<=0.000015&&fabs(Hs_1_his[1])<=0.000015&&fabs(Hs_1_his[2])<=0.000015)     //上表面反弹  进
                                        {
                                                vel[0]=(Hs_h-x_s_1_up_j[0])/dtime;
                                                //judge=judge+1;                                               
                                        }

                        if ((x_s_1_up_j[0]+v_s_1*dtime)>Hs_h)   //反弹
                        {
                                fantan_ss_1+=1;
                                fprintf(fpout,"fantan1 velocity=%f\n",v_s_1);
                                v_s_1=v_s_1*(Cr1);
            vel[0]=0;
                        v_s_1_x=vel[0];
       
                        }
                    else if ((x_s_1_down_j[0]+v_s_1*dtime)<=Hs_l+0.00001)
                        {
                            fantan_sx_1+=1;
                                fprintf(fpout,"fantan2 velocity=%f\n",v_s_1);
                                v_s_1=v_s_1*(Cr2);
                                 vel[0]=0;
                                 v_s_1_x=vel[0];               
                        }
                        #endif
               
                 host_to_node_real_1(vel[0]);
                    
}
        #if RP_NODE
                begin_c_loop(c,cylin)
                                                {
                                                        vt=C_VOLUME(c,cylin);
                                                        P+=C_P(c,cylin)*vt;
                                                        V+=vt;
                                                }
                                end_c_loop(c,cylin);
                               
                                P=PRF_GRSUM1(P);
                                V=PRF_GRSUM1(V);
                                #endif
                                node_to_host_real_1(P);
                                node_to_host_real_1(V);
                                #if RP_HOST   
                                P=P/V;       
                                #endif
   #if RP_HOST
  fprintf(fpout,"valve displacement=%f\n",Hs_1);
  fprintf(fpout,"Hs_1_his[0]=%f\n",Hs_1_his[0]);
  fprintf(fpout,"Hs_1_his[1]=%f\n",Hs_1_his[1]);
  fprintf(fpout,"Hs_1_his[2]=%f\n",Hs_1_his[2]);
  fprintf(fpout,"current angle=%f\n",CURRENT_TIME*6*495);
  fprintf(fpout,"fantan_ss_1=%d\n",fantan_ss_1);
  fprintf(fpout,"fantan_sx_1=%d\n",fantan_sx_1);
  fprintf(fpout,"velocity=%f\n",vel[0]);
  fprintf(fpout,"velocity_v=%f\n",v_s_1);
  fprintf(fpout,"final valve displacementj=%f\n",Hs_h-x_s_1_up_j[0]);
  fprintf(fpout,"shangbiaomianzuobiaoj=%f\n",x_s_1_up_j[0]);
  fprintf(fpout,"xiabiaomianzuobiaodj=%f\n",x_s_1_down_j[0]);
  fprintf(fpout,"average pressure=%f\n",P);
    fprintf(fpout,"prog=%d\n",prog);
        fprintf(fpout,"s_1_open=%d\n",s_1_open);
  //fprintf(fpout,"judge=%d\n",judge);
  fclose(fpout);
  #endif
                               
}

DEFINE_CG_MOTION(val_s_2_s_move, dt, vel, omega, time, dtime)
{
        // 进气阀2动网格函数
        Thread *t;Thread *t_s_2_up;Thread *t_s_2_down;Thread *cylin;Thread *wall;
        face_t f;
        cell_t c;
        int n,i,size;
        float vt=0.0;
        Node *v;
        real NV_VEC(A);
        real forces2,force_sgas2,force_sgas12,force_sgas_sum2,down_force_sgas2,force_sspring2,dv,P,V;
        real ks=1000;  //进气阀弹簧系数 ？？？？N/m

        real XYZ[ND_ND];
        real x_s_2_up[ND_ND],x_s_2_up_j[ND_ND];                        //进气阀片上表面重心
        real x_s_2_down[ND_ND],x_s_2_down_j[ND_ND];//进气阀片下表面重心
        Domain *domain;
        float time1=0,time2=0;
    FILE *fpout;
        NV_S(vel,=,0.0);NV_S(omega,=,0.0);forces2=0;force_sgas2=0.0;force_sgas12=0.0;force_sspring2 = 0.0;force_sgas_sum2=0.0=0.0;V=0.0;fpout=fopen("out-2.txt","a");
        //t=DT_THREAD ((Dynamic_Thread *) dt);
        domain=Get_Domain(1);
        t_s_2_up=DT_THREAD(dt);    //获得进气阀上表面线索指针
        t_s_2_down=Lookup_Thread(domain,226);  //获得进气阀下表面线索指针
    cylin=Lookup_Thread(domain,144);
        // 求阀片受力

if (prog2==0)
{
                   #if RP_NODE
                begin_f_loop (f,t_s_2_down)
                                                {
                                                        F_AREA (A,f,t_s_2_down);
                                                        force_sgas2+=fabs((F_P(f,t_s_2_down)+101325)*NV_MAG(A));
                                                        F_CENTROID(x_s_2_down,f,t_s_2_down);
                                                }
                                end_f_loop (f,t_s_2_down);
                                #endif

                                x_s_2_down_j[1]=PRF_GRHIGH1(x_s_2_down[1]);
                                force_sgas2=PRF_GRSUM1(force_sgas2);
                                node_to_host_real_1(force_sgas2);

                                #if RP_HOST
                                fprintf(fpout,"down force_gas=%g\n",force_sgas2);
                                #endif

                                #if RP_NODE
                    begin_f_loop (f,t_s_2_up)
                                                {
                                                        F_AREA (A,f,t_s_2_up);
                                                        (force_sgas12)-=fabs((F_P(f,t_s_2_up)+101325)*NV_MAG(A)/1);
                                F_CENTROID(x_s_2_up,f,t_s_2_up);
                                                }
                                end_f_loop (f,t_s_2_up);
                                #endif

                                x_s_2_up_j[1]=PRF_GRHIGH1(x_s_2_up[1]);
                                force_sgas12=PRF_GRSUM1(force_sgas12);
                                node_to_host_real_1(force_sgas12);
                                force_sgas_sum2=(force_sgas12)/0.963+force_sgas2;

                                #if RP_HOST
                                fprintf(fpout,"up force_gas=%g\n",force_sgas12);
                                fprintf(fpout,"force_gas=%g\n",force_sgas_sum2);
                    #endif

                                node_to_host_real_1(x_s_2_up_j[1]);
                                node_to_host_real_1(x_s_2_down_j[1]);

                                #if RP_HOST
                                        Hs_2=Hs_h-x_s_2_up_j[1];
                force_sspring2=ks*(0.004+Hs_2);//预压缩量
                fprintf(fpout,"force_x=%g\n",force_sspring2);
                fprintf(fpout,"force=%g\n",force_sspring2+force_sgas_sum2);
                #endif
        if((force_sspring2)*force_sgas_sum2<0&&fabs(force_sgas_sum2)>fabs(force_sspring2))
        {
       forces2=force_sgas_sum2+force_sspring2;
                dv=dtime*forces2/m;    //阀片质量
                v_s_2+=dv;
                prog2=1;
        }

             vel[1]=v_s_2;
                host_to_node_real_1(vel[1]);
}

else{
                      #if RP_NODE
                begin_f_loop (f,t_s_2_down)
                                                {
                                                        F_AREA (A,f,t_s_2_down);
                                                        force_sgas2+=fabs((F_P(f,t_s_2_down)+101325)*NV_MAG(A));
                                                        F_CENTROID(x_s_2_down,f,t_s_2_down);
                                                }
                                end_f_loop (f,t_s_2_down);
                                #endif

                                x_s_2_down_j[1]=PRF_GRHIGH1(x_s_2_down[1]);
                                force_sgas2=PRF_GRSUM1(force_sgas2);

                                node_to_host_real_1(force_sgas2);

                                #if RP_HOST
                                down_force_sgas2=force_sgas2;
                                fprintf(fpout,"down force_gas2=%g\n",force_sgas2);
                                #endif



                                #if RP_NODE
                    begin_f_loop (f,t_s_2_up)
                                                {
                                                        F_AREA (A,f,t_s_2_up);
                                                        force_sgas2-=fabs((F_P(f,t_s_2_up)+101325)*NV_MAG(A));
                                F_CENTROID(x_s_2_up,f,t_s_2_up);
                                                }
                                end_f_loop (f,t_s_2_up);
                                #endif

                                x_s_2_up_j[1]=PRF_GRHIGH1(x_s_2_up[1]);
                                force_sgas12=PRF_GRSUM1(force_sgas12);
                                node_to_host_real_1(force_sgas12);
                                force_sgas_sum2=force_sgas12+force_sgas2;
                                #if RP_HOST
                                fprintf(fpout,"up force_gas=%g\n",force_sgas12);
                                fprintf(fpout,"force_gas=%g\n",force_sgas_sum2);
                    #endif

                                node_to_host_real_1(x_s_2_up_j[1]);
                                node_to_host_real_1(x_s_2_down_j[1]);
                                #if RP_HOST
                                        Hs_2=Hs_h-x_s_2_up_j[1];
                                        Hs_2_his[0]=Hs_2_his[1];Hs_2_his[1]=Hs_2_his[2];Hs_2_his[2]=Hs_2;
                force_sspring2=ks*(0.004+Hs_2);//预压缩量
                fprintf(fpout,"force_x=%g\n",force_sspring2);
                fprintf(fpout,"force=%g\n",force_sspring2+force_sgas_sum2);

                s_2_open=judge_opens1(Hs_2_his,force_sspring2,force_sgas_sum2);
                if (0==s_2_open||2==s_2_open)  //阀片为关闭状态，返回速度为0
                {
                        v_s_2=0.0;
                        vel[1]=v_s_2;
                        v_s_2_x=vel[1];
                }

                else if (3==s_2_open&&fantan_ss_2==0) //阀片随着压叉关闭，速度等于压叉速度
                {
                        v_s_2=v_y_2;
                        vel[1]=v_s_2;
                        v_s_2_x=vel[1];
                }

        else
                {
                forces2=force_sspring2+force_sgas_sum2;
                dv=dtime*forces2/m;    //阀片质量
                v_s_2+=dv;
         vel[1]=v_s_2;
                 v_s_2_x=vel[1];
                }
                  #endif

          #if RP_NODE
                ////////反弹,定义上表面位置, 进
                begin_f_loop (f,t_s_2_up)
                {
                        f_node_loop (f,t_s_2_up,n)
                        {
                                v=F_NODE (f,t_s_2_up,n);
                                if (((x_s_2_down_j[1]+v_s_2*dtime)<=Hs_l+0.00001)&&NODE_POS_NEED_UPDATE(v))     //下表面反弹  进
                                        {
                                                NODE_POS_UPDATED(v);
                                                XYZ[2]=NODE_Z(v);
                                                XYZ[0]=NODE_X(v);
                                                time1=(x_s_2_down_j[1]-Hs_l-0.00001)/v_s_2;
                                                time2=dtime+time1;
                                                XYZ[1]=Hs_l+0.00001+v_s_2*Cr2*time2+0.0024;
                                                NV_V(NODE_COORD(v),=,XYZ);
                                        }
                                else if (((x_s_2_up_j[1]+v_s_2*dtime)>Hs_h)&&NODE_POS_NEED_UPDATE(v))     //上表面反弹  进
                                        {
                                                NODE_POS_UPDATED(v);
                                                XYZ[2]=NODE_Z(v);
                                                XYZ[0]=NODE_X(v);
                                                time1=(Hs_h-x_s_2_up_j[1])/v_s_2;
                                                time2=dtime-time1;
                                                XYZ[1]=Hs_h+v_s_2*Cr1*time2;
                                                NV_V(NODE_COORD(v),=,XYZ);
                                        }
                        }
                }
                end_f_loop (f,t_s_2_up);
                ////////////////////////
                ////////反弹，定义下表面位置
                begin_f_loop (f,t_s_2_down)
                {
                        f_node_loop (f,t_s_2_down,n)
                        {
                                v=F_NODE (f,t_s_2_down,n);
                                        if(((x_s_2_down_j[1]+v_s_2*dtime)<=Hs_l+0.00001)&&NODE_POS_NEED_UPDATE(v))   ///下表面反弹,进
                                        {

                                                NODE_POS_UPDATED(v);
                                                XYZ[2]=NODE_Z(v);
                                                XYZ[0]=NODE_X(v);
                                                time1=(x_s_2_down_j[1]-Hs_l-0.00001)/v_s_2;
                                                time2=dtime+time1;
                                                XYZ[1]=Hs_l+0.00001+v_s_2*Cr2*time2;
                                                NV_V(NODE_COORD(v),=,XYZ);
                                        }

                                else if(((x_s_2_up_j[1]+v_s_2*dtime)>Hs_h)&&NODE_POS_NEED_UPDATE(v))   //上表面反弹，进
                                        {

                                                NODE_POS_UPDATED(v);
                                                XYZ[2]=NODE_Z(v);
                                                XYZ[0]=NODE_X(v);
                                                time1=(Hs_h-x_s_2_up_j[1])/v_s_2;
                                                time2=dtime-time1;
                                                XYZ[1]=Hs_h+v_s_2*Cr1*time2-0.0024;
                                                NV_V(NODE_COORD(v),=,XYZ);
                                        }
                        }
                }
                end_f_loop (f,t_s_2_down);
                ////////////////////////
                #endif
                #if RP_HOST
                if ((v_s_2==0)&&fabs(Hs_2_his[0])<=0.000015&&fabs(Hs_2_his[1])<=0.000015&&fabs(Hs_2_his[2])<=0.000015)     //上表面反弹  进
                                        {
                                                vel[1]=(Hs_h-x_s_2_up_j[1])/dtime;
                                                //judge=judge+1;
                                        }

                        if ((x_s_2_up_j[1]+v_s_2*dtime)>Hs_h)   //反弹
                        {
                                fantan_ss_2+=1;
                                fprintf(fpout,"fantan1 velocity=%f\n",v_s_2);
                                v_s_2=v_s_2*(Cr1);
            vel[1]=0;
                        v_s_2_x=vel[1];

                        }
                    else if ((x_s_2_down_j[1]+v_s_2*dtime)<=Hs_l+0.00001)
                        {
                            fantan_sx_2+=1;
                                fprintf(fpout,"fantan2 velocity=%f\n",v_s_2);
                                v_s_2=v_s_2*(Cr2);
                                 vel[1]=0;
                                 v_s_2_x=vel[1];
                        }
                        #endif

                 host_to_node_real_1(vel[1]);

}
        #if RP_NODE
                begin_c_loop(c,cylin)
                                                {
                                                        vt=C_VOLUME(c,cylin);
                                                        P+=C_P(c,cylin)*vt;
                                                        V+=vt;
                                                }
                                end_c_loop(c,cylin);

                                P=PRF_GRSUM1(P);
                                V=PRF_GRSUM1(V);
                                #endif
                                node_to_host_real_1(P);
                                node_to_host_real_1(V);
                                #if RP_HOST
                                P=P/V;
                                #endif
   #if RP_HOST
  fprintf(fpout,"valve displacement=%f\n",Hs_2);
  fprintf(fpout,"Hs_1_his[0]=%f\n",Hs_2_his[0]);
  fprintf(fpout,"Hs_1_his[1]=%f\n",Hs_2_his[1]);
  fprintf(fpout,"Hs_1_his[2]=%f\n",Hs_2_his[2]);
  fprintf(fpout,"current angle=%f\n",CURRENT_TIME*6*495);
  fprintf(fpout,"fantan_ss_1=%d\n",fantan_ss_2);
  fprintf(fpout,"fantan_sx_1=%d\n",fantan_sx_2);
  fprintf(fpout,"velocity=%f\n",vel[1]);
  fprintf(fpout,"velocity_v=%f\n",v_s_2);
  fprintf(fpout,"final valve displacementj=%f\n",Hs_h-x_s_2_up_j[1]);
  fprintf(fpout,"shangbiaomianzuobiaoj=%f\n",x_s_2_up_j[1]);
  fprintf(fpout,"xiabiaomianzuobiaodj=%f\n",x_s_2_down_j[1]);
  fprintf(fpout,"average pressure=%f\n",P);
    fprintf(fpout,"prog=%d\n",prog2);
        fprintf(fpout,"s_1_open=%d\n",s_2_open);
  //fprintf(fpout,"judge=%d\n",judge);
  fclose(fpout);
  #endif

}