MSJGMX/Services/FortranInteropService.cs

using System.Runtime.InteropServices;
using FortranWebApi.Models;
using System.Text.Json;
using System.Runtime.InteropServices.Marshalling;
using System.IO;

namespace FortranWebApi.Services
{
    public class FortranInteropService
    {
        // 静态构造函数设置DLL导入解析器
        static FortranInteropService()
        {
            // 添加当前目录到库搜索路径
            NativeLibrary.SetDllImportResolver(typeof(FortranInteropService).Assembly, (name, assembly, path) =>
            {
                if (name == "libMSJGMX.so")
                {
                    // 尝试从当前目录加载
                    string currentDir = Directory.GetCurrentDirectory();
                    string libraryPath = Path.Combine(currentDir, "libMSJGMX.so");
                    
                    if (File.Exists(libraryPath))
                    {
                        return NativeLibrary.Load(libraryPath);
                    }
                }
                
                // 回退到默认加载行为
                return IntPtr.Zero;
            });
        }

        // DllImport声明
        [DllImport("libMSJGMX.so", CallingConvention = CallingConvention.Cdecl, EntryPoint = "MSJGMX")]
        private static extern void MSJGMX(
            ref int FILELEN,
            ref int NODE,
            ref int M,
            float[] PAR,
            ref int NAREA,
            float[] AREA,
            float[] UH,
            ref float DT,
            float[] P,
            float[] EP,
            float[] W,
            ref float FR,
            ref float S,
            ref float QRSS0,
            ref float QRG0,
            float[] Q20,
            ref float X,
            ref float K,
            ref float DETAT,
            out float C0,
            out float C1,
            out float C2,
            float[] QOUT
        );

        public string ProcessFortranRequest(string requestText)
        {
            try
            {
                // 解析请求
                var options = new JsonSerializerOptions
                {
                    PropertyNamingPolicy = JsonNamingPolicy.CamelCase,
                    DictionaryKeyPolicy = JsonNamingPolicy.CamelCase,
                    PropertyNameCaseInsensitive = true,
                    WriteIndented = true
                };
                
                var request = JsonSerializer.Deserialize<FortranRequest>(requestText, options);
                if (request == null)
                {
                    throw new ArgumentException("无效的请求格式");
                }

                // 准备输入参数
                var parameters = request.Parameters;
                
                // 提取参数
                int FILELEN = GetIntParameter(parameters, "FILELEN");
                int NODE = GetIntParameter(parameters, "NODE");
                int M = GetIntParameter(parameters, "M");
                float[] PAR = GetFloatArrayParameter(parameters, "PAR");
                int NAREA = GetIntParameter(parameters, "NAREA");
                float[] AREA = GetFloatArrayParameter(parameters, "AREA");
                float[] UH = GetFloatArrayParameter(parameters, "UH");
                float DT = GetFloatParameter(parameters, "DT");
                float[] P = GetFloatArrayParameter(parameters, "P");
                float[] EP = GetFloatArrayParameter(parameters, "EP");
                float[] W = GetFloatArrayParameter(parameters, "W");
                float FR = GetFloatParameter(parameters, "FR");
                float S = GetFloatParameter(parameters, "S");
                float QRSS0 = GetFloatParameter(parameters, "QRSS0");
                float QRG0 = GetFloatParameter(parameters, "QRG0");
                float[] Q20 = GetFloatArrayParameter(parameters, "Q20");
                float X = GetFloatParameter(parameters, "X");
                float K = GetFloatParameter(parameters, "K");
                float DETAT = GetFloatParameter(parameters, "DETAT");
                float C0;
                float C1;
                float C2;


                // 准备数组参数
                float[] QOUT = new float[10000]; // 输出数组，初始大小为10000


                // 调用Fortran函数
                MSJGMX(
                    ref FILELEN,
                    ref NODE,
                    ref M,
                    PAR,
                    ref NAREA,
                    AREA,
                    UH,
                    ref DT,
                    P,
                    EP,
                    W,
                    ref FR,
                    ref S,
                    ref QRSS0,
                    ref QRG0,
                    Q20,
                    ref X,
                    ref K,
                    ref DETAT,
                    out C0,
                    out C1,
                    out C2,
                    QOUT
                );

                // 更新输出参数
                UpdateParameter(parameters, "C0", C0);
                UpdateParameter(parameters, "C1", C1);
                UpdateParameter(parameters, "C2", C2);
                UpdateArrayParameter(parameters, "QOUT", QOUT);


                // 处理输出数组
                // 处理输出数组 QOUT
                // 注意：没有找到明确的长度参数，使用非零元素数量
                {
                    int nonZeroCount = 0;
                    for (int i = 0; i < QOUT.Length; i++)
                    {
                        if (QOUT[i] != 0) nonZeroCount = i + 1;
                    }
                    if (nonZeroCount > 0)
                    {
                        float[] resultArray = new float[nonZeroCount];
                        Array.Copy(QOUT, resultArray, nonZeroCount);
                        UpdateArrayParameter(parameters, "QOUT", resultArray);
                    }
                }


                // 返回结果 - 只返回原始请求的结构，但包含更新后的参数
                var result = new FortranRequest
                {
                    FuncName = request.FuncName,
                    ClassName = request.ClassName,
                    Parameters = parameters
                };
                
                return JsonSerializer.Serialize(result, options);
            }
            catch (Exception ex)
            {
                return JsonSerializer.Serialize(new { error = ex.Message });
            }
        }

        private float GetFloatParameter(List<FortranParameter> parameters, string name)
        {
            var param = parameters.FirstOrDefault(p => p.Name == name);
            if (param == null || param.Data == null)
            {
                return 0.0f;
            }
            
            if (param.Data is JsonElement element)
            {
                if (element.ValueKind == JsonValueKind.Number)
                {
                    return element.GetSingle();
                }
            }
            
            return Convert.ToSingle(param.Data);
        }
        private double GetDoubleParameter(List<FortranParameter> parameters, string name)
        {
            var param = parameters.FirstOrDefault(p => p.Name == name);
            if (param == null || param.Data == null)
            {
                return 0.0;
            }

            if (param.Data is JsonElement element)
            {
                if (element.ValueKind == JsonValueKind.Number)
                {
                    return element.GetSingle();
                }
            }

            return Convert.ToDouble(param.Data);
        }
        private int GetIntParameter(List<FortranParameter> parameters, string name)
        {
            var param = parameters.FirstOrDefault(p => p.Name == name);
            if (param == null || param.Data == null)
            {
                return 0;
            }
            
            if (param.Data is JsonElement element)
            {
                if (element.ValueKind == JsonValueKind.Number)
                {
                    return element.GetInt32();
                }
            }
            
            return Convert.ToInt32(param.Data);
        }
        private int[] GetIntArrayParameter(List<FortranParameter> parameters, string name)
        {
            var param = parameters.FirstOrDefault(p => p.Name == name);
            if (param == null || param.Data == null)
            {
                return Array.Empty<int>();
            }

            if (param.Data is JsonElement element && element.ValueKind == JsonValueKind.Array)
            {
                var array = new List<int>();
                foreach (var item in element.EnumerateArray())
                {
                    if (item.ValueKind == JsonValueKind.Number)
                    {
                        array.Add(item.GetInt32());
                    }
                }
                return array.ToArray();
            }

            if (param.Data is System.Collections.IEnumerable enumerable && !(param.Data is string))
            {
                var array = new List<int>();
                foreach (var item in enumerable)
                {
                    array.Add(Convert.ToInt32(item));
                }
                return array.ToArray();
            }

            return Array.Empty<int>();
        }
        private float[] GetFloatArrayParameter(List<FortranParameter> parameters, string name)
        {
            var param = parameters.FirstOrDefault(p => p.Name == name);
            if (param == null || param.Data == null)
            {
                return Array.Empty<float>();
            }
            
            if (param.Data is JsonElement element && element.ValueKind == JsonValueKind.Array)
            {
                var array = new List<float>();
                foreach (var item in element.EnumerateArray())
                {
                    if (item.ValueKind == JsonValueKind.Number)
                    {
                        array.Add(item.GetSingle());
                    }
                }
                return array.ToArray();
            }
            
            if (param.Data is System.Collections.IEnumerable enumerable && !(param.Data is string))
            {
                var array = new List<float>();
                foreach (var item in enumerable)
                {
                    array.Add(Convert.ToSingle(item));
                }
                return array.ToArray();
            }
            
            return Array.Empty<float>();
        }
        private double[] GetDoubleArrayParameter(List<FortranParameter> parameters, string name)
        {
            var param = parameters.FirstOrDefault(p => p.Name == name);
            if (param == null || param.Data == null)
            {
                return Array.Empty<double>();
            }

            if (param.Data is JsonElement element && element.ValueKind == JsonValueKind.Array)
            {
                var array = new List<double>();
                foreach (var item in element.EnumerateArray())
                {
                    if (item.ValueKind == JsonValueKind.Number)
                    {
                        array.Add(item.GetSingle());
                    }
                }
                return array.ToArray();
            }

            if (param.Data is System.Collections.IEnumerable enumerable && !(param.Data is string))
            {
                var array = new List<double>();
                foreach (var item in enumerable)
                {
                    array.Add(Convert.ToSingle(item));
                }
                return array.ToArray();
            }

            return Array.Empty<double>();
        }
        private void UpdateParameter(List<FortranParameter> parameters, string name, object value)
        {
            var param = parameters.FirstOrDefault(p => p.Name == name);
            if (param != null)
            {
                param.Data = value;
            }
        }

        private void UpdateArrayParameter(List<FortranParameter> parameters, string name, float[] value)
        {
            var param = parameters.FirstOrDefault(p => p.Name == name);
            if (param != null)
            {
                param.Data = value;
            }
        }
        private void UpdateDoubleArrayParameter(List<FortranParameter> parameters, string name, double[] value)
        {
            var param = parameters.FirstOrDefault(p => p.Name == name);
            if (param != null)
            {
                param.Data = value;
            }
        }
        private void UpdateIntArrayParameter(List<FortranParameter> parameters, string name, int[] value)
        {
            var param = parameters.FirstOrDefault(p => p.Name == name);
            if (param != null)
            {
                param.Data = value;
            }
        }
        // 添加新的辅助方法来处理二维数组
        private double[,] GetDouble2DArrayParameter(List<FortranParameter> parameters, string name, int rows, int cols)
        {
            var param = parameters.FirstOrDefault(p => p.Name == name);
            if (param == null || param.Data == null)
            {
                return new double[rows, cols];
            }

            double[,] result = new double[rows, cols];

            if (param.Data is JsonElement element && element.ValueKind == JsonValueKind.Array)
            {
                int index = 0;
                foreach (var item in element.EnumerateArray())
                {
                    if (item.ValueKind == JsonValueKind.Number)
                    {
                        int row = index / cols;
                        int col = index % cols;
                        if (row < rows && col < cols)
                        {
                            result[row, col] = item.GetDouble();
                        }
                        index++;
                    }
                }
            }
            else if (param.Data is System.Collections.IEnumerable enumerable && !(param.Data is string))
            {
                int index = 0;
                foreach (var item in enumerable)
                {
                    int row = index / cols;
                    int col = index % cols;
                    if (row < rows && col < cols)
                    {
                        result[row, col] = Convert.ToDouble(item);
                    }
                    index++;
                }
            }

            return result;
        }

        // 添加更新二维数组参数的方法
        private void UpdateDouble2DArrayParameter(List<FortranParameter> parameters, string name, double[,] value)
        {
            var param = parameters.FirstOrDefault(p => p.Name == name);
            if (param != null)
            {
                // 将二维数组转换为一维数组以便于JSON序列化
                int rows = value.GetLength(0);
                int cols = value.GetLength(1);
                double[] flatArray = new double[rows * cols];
                for (int i = 0; i < rows; i++)
                {
                    for (int j = 0; j < cols; j++)
                    {
                        flatArray[i * cols + j] = value[i, j];
                    }
                }
                param.Data = flatArray;
            }
        }
        // float版本
        private float[,] GetFloat2DArrayParameter(List<FortranParameter> parameters, string name, int rows, int cols)
        {
            var param = parameters.FirstOrDefault(p => p.Name == name);
            if (param == null || param.Data == null)
            {
                return new float[rows, cols];
            }

            float[,] result = new float[rows, cols];

            if (param.Data is JsonElement element && element.ValueKind == JsonValueKind.Array)
            {
                int index = 0;
                foreach (var item in element.EnumerateArray())
                {
                    if (item.ValueKind == JsonValueKind.Number)
                    {
                        int row = index / cols;
                        int col = index % cols;
                        if (row < rows && col < cols)
                        {
                            result[row, col] = item.GetSingle();
                        }
                        index++;
                    }
                }
            }
            else if (param.Data is System.Collections.IEnumerable enumerable && !(param.Data is string))
            {
                int index = 0;
                foreach (var item in enumerable)
                {
                    int row = index / cols;
                    int col = index % cols;
                    if (row < rows && col < cols)
                    {
                        result[row, col] = Convert.ToSingle(item);
                    }
                    index++;
                }
            }

            return result;
        }

        private void UpdateFloat2DArrayParameter(List<FortranParameter> parameters, string name, float[,] value)
        {
            var param = parameters.FirstOrDefault(p => p.Name == name);
            if (param != null)
            {
                int rows = value.GetLength(0);
                int cols = value.GetLength(1);
                float[] flatArray = new float[rows * cols];
                for (int i = 0; i < rows; i++)
                {
                    for (int j = 0; j < cols; j++)
                    {
                        flatArray[i * cols + j] = value[i, j];
                    }
                }
                param.Data = flatArray;
            }
        }

        // int版本
        private int[,] GetInt2DArrayParameter(List<FortranParameter> parameters, string name, int rows, int cols)
        {
            var param = parameters.FirstOrDefault(p => p.Name == name);
            if (param == null || param.Data == null)
            {
                return new int[rows, cols];
            }

            int[,] result = new int[rows, cols];

            if (param.Data is JsonElement element && element.ValueKind == JsonValueKind.Array)
            {
                int index = 0;
                foreach (var item in element.EnumerateArray())
                {
                    if (item.ValueKind == JsonValueKind.Number)
                    {
                        int row = index / cols;
                        int col = index % cols;
                        if (row < rows && col < cols)
                        {
                            result[row, col] = item.GetInt32();
                        }
                        index++;
                    }
                }
            }
            else if (param.Data is System.Collections.IEnumerable enumerable && !(param.Data is string))
            {
                int index = 0;
                foreach (var item in enumerable)
                {
                    int row = index / cols;
                    int col = index % cols;
                    if (row < rows && col < cols)
                    {
                        result[row, col] = Convert.ToInt32(item);
                    }
                    index++;
                }
            }

            return result;
        }

        private void UpdateInt2DArrayParameter(List<FortranParameter> parameters, string name, int[,] value)
        {
            var param = parameters.FirstOrDefault(p => p.Name == name);
            if (param != null)
            {
                int rows = value.GetLength(0);
                int cols = value.GetLength(1);
                int[] flatArray = new int[rows * cols];
                for (int i = 0; i < rows; i++)
                {
                    for (int j = 0; j < cols; j++)
                    {
                        flatArray[i * cols + j] = value[i, j];
                    }
                }
                param.Data = flatArray;
            }
        }
    }
}