代码调试成功，但是数据却写入不到文件中去，我用的是VS2017，数据文件也已经放入项目中

想请问一下大家，代码运行没有报错，但是数据写入不到文件中去，请问是什么原因？
这是头文件

_****#ifndef _NS_H
#include<stdio.h>
#include<math.h>
#include<time.h>
#define imax 100
#define jmax 100
#define maxit 10000
extern double ma0, a0, u0, v0, p0, t0, tr, tw, tratio, visr, xl, gamma, gascon, pr;
extern double vis0;
extern double cv, cp, r0, rel, e0;
extern double kc0;
extern double delt, yl, dx, dy;
extern double dtime;
extern int iter;
extern int convergence;
extern int t1, t2;
extern double dt;
extern double u[imax][jmax], v[imax][jmax], p[imax][jmax], r[imax][jmax], rl[imax][jmax], t[imax][jmax], vis[imax][jmax], ma[imax][jmax];
extern double e[imax][jmax], a[imax][jmax], kc[imax][jmax];
void bc();
void conver();
void dynvis(double tr, double tout, double visr, double visout);
void mac();
void mdot();
void output();
void qcx(int i, int j, int icase, double qxout);
void qcy(int i, int j, int icase, double qyout);
void tauxx(int i, int j, int icase, double txx);
void tauxy(int i, int j, int icase, double txy);
void tauyy(int i, int j, int icase, double tyy);
void thermc(double vis0, double cp, double pr, double kcout);
void tstep();
#endif**_**

这是主循环

/*
    A C program of two-dimensional complete Navier-Stokes
    equations for the supersonic flow over a flat plate
    based on MacCormack's explicit time-marching technique.
    Written by ZhouMingming, January, 2019

    Based on John D. Anderson, JR., Chapter 10, In
    Computational Fluid Dynamics, The Basics with Applications,
    McGraw-Hill, 2002, 4
*/
#include"_NS_H.h"
int main()
{
    //初始化流场及各种参数
    ma0 = 8;
    a0 = 340.28;
    u0 = ma0 * a0;
    v0 = 0;
    p0 = 1.01325e5;
    t0 = 288.16;
    tr = 288.16;
    tratio = 2;
    tw = t0 * tratio;
    visr = 1.7894e-5;
    xl = 0.00001;
    gascon = 287;
    gamma = 1.4;
    pr = 0.71;
    dynvis(tr, t0, visr, vis0);
    cv = gascon / (gamma - 1);
    cp = cv * gamma;
    r0 = p0 / (gascon * t0);
    e0 = cv * t0;
    rel = r0 * sqrt(u0*u0 + v0 * v0)*xl / vis0;
    thermc(vis0, cp, pr, kc0);
    delt = 5 * xl / sqrt(rel);
    yl = 5 * delt;
    dx = xl / (imax - 1);
    dy = yl / (jmax - 1);
    FILE *fp4;
    fp4 = fopen("time.txt", "w");
    //主循环
    t1 = clock();
    for (iter = 0; iter < maxit; iter++) {
        if (iter == 0) {
            for (int i = 0; i < imax; i++) {
                for (int j = 0; j < jmax; j++) {
                    u[i][j] = u0;
                    v[i][j] = v0;
                    p[i][j] = p0;
                    t[i][j] = t0;
                    r[i][j] = r0;
                    rl[i][j] = r0;
                    vis[i][j] = vis0;
                    ma[i][j] = ma0;
                    e[i][j] = e0;
                    kc[i][j] = kc0;
                    a[i][j] = a0;
                }
            }
        }
        //确定推进时间步长
        tstep();
        //使用MacCormack time marching algorithm求解
        mac();
        //确定是否收敛
        conver();
        if (convergence) {
            mdot();
            output();
        }
    }
    t2 = clock();
    dt = (t2 - t1) / CLOCKS_PER_SEC;
    fprintf(fp4, "%f", dt);
    fclose(fp4);
}

以下是各个cpp文件

#include"_NS_H.h"
void bc()
{
    //定义边界条件
    //case1: at (0, 0)
    u[0][0] = 0;
    v[0][0] = 0;
    p[0][0] = p0;
    t[0][0] = t0;
    e[0][0] = cv * t[0][0];
    r[0][0] = p[0][0] / gascon / t[0][0];
    dynvis(tr, t[0][0], visr, vis[0][0]);
    thermc(vis[0][0], cp, pr, kc[0][0]);
    a[0][0] = a0;
    ma[0][0] = 0;
    //case2: at inflow and upper boundary
    for (int j = 1; j < jmax; j++) {
        u[0][j] = u0;
        v[0][j] = v0;
        p[0][j] = p0;
        t[0][j] = t0;
        e[0][j] = cv * t[0][j];
        r[0][j] = p[0][j] / gascon / t[0][j];
        dynvis(tr, t[0][j], visr, vis[0][j]);
        thermc(vis[0][j], cp, pr, kc[0][j]);
        a[0][j] = a0;
        ma[0][j] = ma0;
    }
    for (int i = 1; i < imax; i++) {
        u[i][jmax - 1] = u0;
        v[i][jmax - 1] = v0;
        p[i][jmax-1] = p0;
        t[i][jmax-1] = t0;
        e[i][jmax - 1] = cv * t[i][jmax - 1];
        r[i][jmax-1] = p[i][jmax-1] / gascon / t[i][jmax-1];
        dynvis(tr, t[i][jmax-1], visr, vis[i][jmax-1]);
        thermc(vis[i][jmax-1], cp, pr, kc[i][jmax-1]);
        a[i][jmax-1] = a0;
        ma[i][jmax-1] = ma0;
    }
    //case3: at lower surface boundary
    for (int i = 1; i < imax; i++) {
        u[i][0] = 0;
        v[i][0] = 0;
        p[i][0] = 2 * p[i][1] - p[i][2];
        t[i][0] = tw;
        e[i][0] = cv * t[i][0];
        r[i][0] = p[i][0] / gascon / t[i][0];
        dynvis(tr, t[i][0], visr, vis[i][0]);
        thermc(vis[i][0], cp, pr, kc[i][0]);

        a[i][0] = sqrt(gamma*gascon*t[i][0]);
        ma[i][0] = sqrt(u[i][0] * u[i][0] + v[i][0] * v[i][0]) / a[i][0];
    }
    //case4: at outflow boundary
    for (int j = 1; j < jmax - 1; j++) {
        u[imax - 1][j] = 2 * u[imax - 2][j] - u[imax - 3][j];
        v[imax - 1][j] = 2 * v[imax - 2][j] - v[imax - 3][j];
        p[imax - 1][j] = 2 * p[imax - 2][j] - p[imax - 3][j];
        t[imax - 1][j] = 2 * t[imax - 2][j] - t[imax - 3][j];
        e[imax - 1][j] = cv * t[imax - 1][j];
        r[imax - 1][j] = p[imax - 1][j] / gascon / t[imax - 1][j];
        dynvis(tr, t[imax - 1][j], visr, vis[imax - 1][j]);
        thermc(vis[imax - 1][j], cp, pr, kc[imax - 1][j]);
        a[imax - 1][j] = sqrt(gamma*gascon*t[imax - 1][j]);
        ma[imax - 1][j] = sqrt(u[imax - 1][j] * u[imax - 1][j] + v[imax - 1][j] * v[imax - 1][j]) / a[imax - 1][j];
    }
}

#include"_NS_H.h"
void conver()
{
    FILE *fp1;
    fp1 = fopen("time.txt", "a");
    double rcrit = 0;
    double dr;
    for (int i = 0; i < imax; i++) {
        for (int j = 0; j < jmax; j++) {
            dr = fabs(r[i][j] - rl[i][j]);
            if (rcrit < dr) {
                rcrit = dr;
            }
        }
    }
    if (rcrit <= 2e-6) {
        printf("Converence is done!");
        convergence = 1;
    }
    else {
        fprintf(fp1, "%d ", iter);
        fprintf(fp1, "%f ", rcrit);
        fprintf(fp1, "%f ", dtime);
        fprintf(fp1, "\n");
        fclose(fp1);
        for (int i = 0; i < imax; i++) {
            for (int j = 0; j < jmax; j++) {
                rl[i][j] = r[i][j];
            }
        }
        convergence = 0;
    }
}

#include"_NS_H.h"
void dynvis(double tr, double tout, double visr, double visout)
{
    visout = visr * pow(tout / tr, 1.5);
    visout = visout * (tr + 110) / (tout + 110);
}

#include"_NS_H.h"
double s[5][imax][jmax], f[5][imax][jmax], g[5][imax][jmax];
double sb[5][imax][jmax], sl[5][imax][jmax];
double txx[imax][jmax], txy[imax][jmax], tyy[imax][jmax];
double qx[imax][jmax], qy[imax][jmax];
void mac()
{
    double dsdt;
    //使用MacCormack's algorithm更新流场变量
    for (int i = 0; i < imax; i++) {
        for (int j = 0; j < jmax; j++) {
            s[0][i][j] = r[i][j];
            s[1][i][j] = r[i][j] * u[i][j];
            s[2][i][j] = r[i][j] * v[i][j];
            s[3][i][j] = 0;
            s[4][i][j] = r[i][j] * (e[i][j] + 1 / 2 * (u[i][j] * u[i][j] + v[i][j] * v[i][j]));
            sl[0][i][j] = r[i][j];
            sl[1][i][j] = r[i][j] * u[i][j];
            sl[2][i][j] = r[i][j] * v[i][j];
            sl[3][i][j] = 0;
            sl[4][i][j] = r[i][j] * (e[i][j] + 1 / 2 * (u[i][j] * u[i][j] + v[i][j] * v[i][j]));
            tauxx(i, j, 1, txx[i][j]);
            tauxy(i, j, 1, txy[i][j]);
            qcx(i, j, 1, qx[i][j]);
            f[0][i][j] = s[1][i][j];
            f[1][i][j] = s[1][i][j] * s[1][i][j] / s[0][i][j] + p[i][j] - txx[i][j];
            f[2][i][j] = s[1][i][j] * s[2][i][j] / s[0][i][j] - txy[i][j];
            f[3][i][j] = 0;
            f[4][i][j] = (s[4][i][j] + p[i][j])*s[1][i][j] / s[0][i][j] + qx[i][j] - s[1][i][j] / s[0][i][j] * txx[i][j] - s[2][i][j] / s[0][i][j] * txy[i][j];
            tauyy(i, j, 1, tyy[i][j]);
            tauxy(i, j, 3, txy[i][j]);
            qcy(i, j, 1, qy[i][j]);
            g[0][i][j] = s[2][i][j];
            g[1][i][j] = s[1][i][j] * s[2][i][j] / s[0][i][j] - txy[i][j];
            g[2][i][j] = s[2][i][j] * s[2][i][j] / s[0][i][j] + p[i][j] - tyy[i][j];
            g[3][i][j] = 0;
            g[4][i][j] = (s[4][i][j] + p[i][j])*s[2][i][j] / s[0][i][j] + qy[i][j] - s[1][i][j] / s[0][i][j] * txy[i][j] - s[2][i][j] / s[0][i][j] * tyy[i][j];
        }
    }
    //预测步
    for (int i = 1; i < imax - 1; i++) {
        for (int j = 1; j < jmax - 1; j++) {
            for (int k = 0; k < 5; k++) {
                dsdt = (f[k][i][j] - f[k][i + 1][j]) / dx + (g[k][i][j] - g[k][i][j + 1]) / dy;
                sb[k][i][j] = s[k][i][j] + dsdt * dtime;
            }
            //decode the variables
            r[i][j] = sb[0][i][j];
            u[i][j] = sb[1][i][j] / sb[0][i][j];
            v[i][j] = sb[2][i][j] / sb[0][i][j];
            e[i][j] = sb[4][i][j] / sb[0][i][j] - 0.5*v[i][j] * v[i][j];
            if (e[i][j] < 0) {
                e[i][j] = 0;
            }
            t[i][j] = e[i][j] / cv;
            p[i][j] = r[i][j] * gascon*t[i][j];
            dynvis(tr, t[i][j], visr, vis[i][j]);
            thermc(vis[i][j], cp, pr, kc[i][j]);
            a[i][j] = sqrt(gamma*gascon*t[i][j]);
            ma[i][j] = v[i][j] / a[i][j];
        }
    }
    //更新边界条件
    bc();
    //使用MacCormack's algorithm更新流场变量
    for (int i = 0; i < imax; i++) {
        for (int j = 0; j < jmax; j++) {
            s[0][i][j] = r[i][j];
            s[1][i][j] = r[i][j] * u[i][j];
            s[2][i][j] = r[i][j] * v[i][j];
            s[3][i][j] = 0;
            s[4][i][j] = r[i][j] * (e[i][j] + 1 / 2 * (u[i][j] * u[i][j] + v[i][j] * v[i][j]));
            tauxx(i, j, 2, txx[i][j]);
            tauxy(i, j, 2, txy[i][j]);
            qcx(i, j, 2, qx[i][j]);
            f[0][i][j] = s[1][i][j];
            f[1][i][j] = s[1][i][j] * s[1][i][j] / s[0][i][j] + p[i][j] - txx[i][j];
            f[2][i][j] = s[1][i][j] * s[2][i][j] / s[0][i][j] - txy[i][j];
            f[3][i][j] = 0;
            f[4][i][j] = (s[4][i][j] + p[i][j])*s[1][i][j] / s[0][i][j] + qx[i][j] - s[1][i][j] / s[0][i][j] * txx[i][j] - s[2][i][j] / s[0][i][j] * txy[i][j];
            tauyy(i, j, 2, tyy[i][j]);
            tauxy(i, j, 4, txy[i][j]);
            qcy(i, j, 2, qy[i][j]);
            g[0][i][j] = s[2][i][j];
            g[1][i][j] = s[1][i][j] * s[2][i][j] / s[0][i][j] - txy[i][j];
            g[2][i][j] = s[2][i][j] * s[2][i][j] / s[0][i][j] + p[i][j] - tyy[i][j];
            g[3][i][j] = 0;
            g[4][i][j] = (s[4][i][j] + p[i][j])*s[2][i][j] / s[0][i][j] + qy[i][j] - s[1][i][j] / s[0][i][j] * txy[i][j] - s[2][i][j] / s[0][i][j] * tyy[i][j];
        }
    }
    //修正步
    for (int i = 1; i < imax - 1; i++) {
        for (int j = 1; j < jmax - 1; j++) {
            for (int k = 0; k < 5; k++) {
                dsdt = (f[i - 1][j][k] - f[i][j][k]) / dx + (g[i][j - 1][k] - g[i][j][k]) / dy;
                s[i][j][k] = 0.5*(sl[i][j][k] + sb[i][j][k] + dtime * dsdt);
            }
            //decode the variables
            r[i][j] = sb[0][i][j];
            u[i][j] = sb[1][i][j] / sb[0][i][j];
            v[i][j] = sb[2][i][j] / sb[0][i][j];
            e[i][j] = sb[4][i][j] / sb[0][i][j] - 0.5*v[i][j] * v[i][j];
            if (e[i][j] < 0) {
                e[i][j] = 0;
            }
            t[i][j] = e[i][j] / cv;
            p[i][j] = r[i][j] * gascon*t[i][j];
            dynvis(tr, t[i][j], visr, vis[i][j]);
            thermc(vis[i][j], cp, pr, kc[i][j]);
            a[i][j] = sqrt(gamma*gascon*t[i][j]);
            ma[i][j] = v[i][j] / a[i][j];
        }
    }
    //更新边界条件
    bc();
}

#include"_NS_H.h"
void mdot()
{
    //检查质量守恒是否成立
    FILE *fp3;
    fp3 = fopen("dmass.txt", "a");
    double massin = 0.0, massout = 0.0;
    double dmass;
    for (int j = 0; j < jmax; j++) {
        massin += r[0][j] * u[0][j];
        massout += r[imax - 1][j] * u[imax - 1][j];
    }
    dmass = fabs(massout - massin) / massin * 100;
    if (dmass > 1.0) {
        fprintf(fp3, "%f ", dmass);
        fprintf(fp3, "\n");
        fclose(fp3);
    }
}

#include"_NS_H.h"
void output()
{
    double x[imax], y[jmax];
    FILE *fp2;
    fp2 = fopen("output.txt", "a");
    for (int i = 0; i < imax; i++) {
        x[i] = dx * i;
    }
    for (int j = 0; j < jmax; j++) {
        y[j] = dy * j;
    }
    for (int i = 0; i < imax; i++) {
        for (int j = 0; j < jmax; j++) {
            fprintf(fp2, "%f ", x[i]);
            fprintf(fp2, "%f ", y[i]);
            fprintf(fp2, "%f ", u[i][j] / u0);
            fprintf(fp2, "%f ", v[i][j]);
            fprintf(fp2, "%f ", p[i][j] / p0);
            fprintf(fp2, "%f ", t[i][j] / t0);
            fprintf(fp2, "%f ", r[i][j] / r0);
            fprintf(fp2, "%f ", a[i][j]);
            fprintf(fp2, "%f ", ma[i][j]);
            fprintf(fp2, "\n");
        }
    }
    fclose(fp2);
}

#include"_NS_H.h"
void qcx(int i, int j, int icase, double qxout)
{
    double dtdx;
    switch (icase) {
    //向前差分时
    case 1:
        if (i == 0) {
            dtdx = (t[1][j] - t[0][j]) / dx;
        }
        else {
            dtdx = (t[i][j] - t[i - 1][j]) / dx;
        }
        break;
    //向后差分时
    case 2:
        if (i == imax - 1) {
            dtdx = (t[imax - 1][j] - t[imax - 2][j]) / dx;
        }
        else {
            dtdx = (t[i + 1][j] - t[i][j]) / dx;
        }
        break;
    }
    qxout = -1 * kc[i][j] * dtdx;
}

#include"_NS_H.h"
void qcy(int i, int j, int icase, double qyout)
{
    double dtdy;
    switch (icase) {
        //向前差分时
    case 1:
        if (j == 0) {
            dtdy = (t[i][1] - t[i][0]) / dy;
        }
        else {
            dtdy = (t[i][j] - t[i][j - 1]) / dy;
        }
        break;
        //向后差分时
    case 2:
        if (j == jmax - 1) {
            dtdy = (t[i][jmax-1] - t[i][jmax-2]) / dy;
        }
        else {
            dtdy = (t[i][j+1] - t[i][j]) / dy;
        }
        break;
    }
    qyout = -1 * kc[i][j] * dtdy;
}

#include"_NS_H.h"
void tauxx(int i, int j, int icase, double txx)
{
    double dudx, dvdy;
    switch (icase) {
    //dF/dX为向前差分
    case 1:
        if (j == 0) {
            dvdy = (v[i][1] - v[i][0]) / dy;
        }
        else if (j == jmax - 1) {
            dvdy = (v[i][jmax - 1] - v[i][jmax - 2]) / dy;
        }
        else {
            dvdy = (v[i][j + 1] - v[i][j - 1]) / 2 / dy;
        }
        if (i == 0) {
            dudx = (u[1][j] - u[0][j]) / dx;
        }
        else {
            dudx = (u[i][j] - u[i - 1][j]) / dx;
        }
        break;
    //dF/dX为向后差分
    case 2:
        if (j == 0) {
            dvdy = (v[i][1] - v[i][0]) / dy;
        }
        else if (j == jmax - 1) {
            dvdy = (v[i][jmax - 1] - v[i][jmax - 2]) / dy;
        }
        else {
            dvdy = (v[i][j + 1] - v[i][j - 1]) / 2 / dy;
        }
        if (i == imax-1) {
            dudx = (u[imax - 1][j] - u[imax - 2][j]) / dx;
        }
        else {
            dudx = (u[i + 1][j] - u[i][j]) / dx;
        }
        break;
    }
    txx = vis[i][j] * (4 / 3 * dudx - 2 / 3 * dvdy);
}

#include"_NS_H.h"
void tauxy(int i, int j, int icase, double txy)
{
    double dudy, dvdx;
    switch (icase) {
    //dF/dX为向前差分
    case 1:
        if (j == 0) {
            dudy = (u[i][1] - u[i][0]) / dy;
        }
        else if (j == jmax - 1) {
            dudy = (u[i][jmax - 1] - u[i][jmax - 2]) / dy;
        }
        else {
            dudy = (u[i][j + 1] - u[i][j - 1]) / 2 / dy;
        }
        if (i == 0) {
            dvdx = (v[1][j] - v[0][j]) / dx;
        }
        else {
            dvdx = (v[i][j] - v[i - 1][j]) / dx;
        }
        break;
    //dF/dX为向后差分
    case 2:
        if (j == 0) {
            dudy = (u[i][1] - u[i][0]) / dy;
        }
        else if (j == jmax - 1) {
            dudy = (u[i][jmax - 1] - u[i][jmax - 2]) / dy;
        }
        else {
            dudy = (u[i][j + 1] - u[i][j - 1]) / 2 / dy;
        }
        if (i == imax - 1) {
            dvdx = (v[imax - 1][j] - v[imax - 2][j]) / dx;
        }
        else {
            dvdx = (v[i + 1][j] - v[i][j]) / dx;
        }
        break;
    //dG/dy为向前差分
    case 3:
        if (i == 0) {
            dvdx = (v[1][j] - v[0][j]) / dx;
        }
        else if (i == imax - 1) {
            dvdx = (v[imax - 1][j] - v[imax - 2][j]) / dx;
        }
        else {
            dvdx = (v[i + 1][j] - v[i - 1][j]) / 2 / dx;
        }
        if (j == 0) {
            dudy = (u[i][1] - u[i][0]) / dy;
        }
        else {
            dudy = (u[i][j] - u[i][j - 1]) / dy;
        }
        break;
    //dG/dy为向后差分
    case 4:
        if (i == 0) {
            dvdx = (v[1][j] - v[0][j]) / dx;
        }
        else if (i == imax - 1) {
            dvdx = (v[imax - 1][j] - v[imax - 2][j]) / dx;
        }
        else {
            dvdx = (v[i + 1][j] - v[i - 1][j]) / 2 / dx;
        }
        if (j == jmax-1) {
            dudy = (u[i][jmax - 1] - u[i][jmax - 2]) / dy;
        }
        else {
            dudy = (u[i][j + 1] - u[i][j]) / dy;
        }
        break;
    }
    txy = vis[i][j] * (dudy + dvdx);
}

#include"_NS_H.h"
void tauyy(int i, int j, int icase, double tyy)
{
    double dudx, dvdy;
    switch (icase) {
    //dG/dy为向前差分
    case 1:
        if (i == 0) {
            dudx = (u[1][j] - u[0][j]) / dx;
        }
        else if (i == imax-1) {
            dudx = (u[imax - 1][j] - u[imax - 2][j]) / dx;
        }
        else {
            dudx = (u[i + 1][j] - u[i - 1][j]) / 2 / dx;
        }
        if (j == 0) {
            dvdy = (v[i][1] - v[i][0]) / dy;
        }
        else {
            dvdy = (v[i][j] - v[i][j - 1]) / dy;
        }
        break;
    //dG/dy为向后差分
    case 2:
        if (i == 0) {
            dudx = (u[1][j] - u[0][j]) / dx;
        }
        else if (i == imax - 1) {
            dudx = (u[imax - 1][j] - u[imax - 2][j]) / dx;
        }
        else {
            dudx = (u[i + 1][j] - u[i - 1][j]) / 2 / dx;
        }
        if (j == jmax - 1) {
            dvdy = (v[i][jmax - 1] - v[i][jmax - 2]) / dy;
        }
        else {
            dvdy = (v[i][j + 1] - v[i][j]) / dy;
        }
        break;
    }
    tyy = vis[i][j] * (4 / 3 * dvdy - 2 / 3 * dudx);
}

#include"_NS_H.h"
void thermc(double vis0, double cp, double pr, double kcout)
{
    kcout = vis0 * cp / pr;
}

#include"_NS_H.h"
double vv[imax][jmax], dtt[imax][jmax];
double rex[imax][jmax], rey[imax][jmax];
void tstep()
{
    double vvmax = 0;
    double dt1, dt2, dt3;
    double dtmin = 1;
    double tf = 0.5;
    double rexmax = 0, reymax = 0;
    for (int i = 1; i < imax - 1; i++) {
        for (int j = 1; j < jmax - 1; j++) {
            vv[i][j] = 4 / 3*gamma*vis[i][j] * vis[i][j] / pr / r[i][j];
            rex[i][j] = r[i][j] * u[i][j] * dx / vis[i][j];
            rey[i][j] = r[i][j] * v[i][j] * dy / vis[i][j];
            if (rexmax < rex[i][j]) {
                rexmax = rex[i][j];
            }
            if (reymax < rey[i][j]) {
                reymax = rey[i][j];
            }
            if (vvmax < vv[i][j]) {
                vvmax = vv[i][j];
            }
        }
    }
    for (int i = 1; i < imax - 1; i++) {
        for (int j = 1; j < jmax - 1; j++) {
            dt1 = sqrt(u[i][j]) / dx + sqrt(v[i][j]) / dy;
            dt2 = dt1 + a[i][j] * sqrt(1 / (dx*dx) + 1 / (dy*dy));
            dt3 = dt2 + 2 * vvmax*(1 / dx / dx + 1 / dy / dy);
            dtt[i][j] = 1 / dt3;
            if (dtmin > dtt[i][j]) {
                dtmin = dtt[i][j];
            }
        }
    }
    dtime = tf * dtmin;
}

代码太多了，而且你的算法和输入我也不知道

给你一个思路，就是在 fprintf 上面下断点，调试运行，看看有没有执行到。

如果没有执行到，看你的调用代码有没有触发，循环条件是否满足，在fprintf前面的代码，尤其是fopen有没有报错退出。如果报错，检查下路径的权限。

如果都执行到了，数据肯定写入了，检查下是不是写入到别的路径了，和你看的那个不是一个文件。你可以fopen写绝对路径看看，或者搜索下，有没有别的路径有这个文件。

你以a的形式打开，如果不存在打开失败，也就是不存在不会进行创建，很可能会返回空指针，空指针操作进行操作是未定义的。所以建议如果
以a的模式打开，打开失败，则进行尝试创建，创建也失败就return。
fp2 = fopen("output.txt", "a");改成

if( NULL == (fp2 = fopen("output.txt", "a")) && NULL == (fp2 = fopen("output.txt", "w")) )
{
   return;
}