示例#1
0
        /// <summary>
        ///Output of 2-D concentration files (concentrations, deposition, odour-files)
        /// </summary>
        public void Write2DConcentrations()
        {
            try
            {
                Console.Write("Writing result files.");
                if (Program.ResultFileZipped)
                {
                    using (FileStream zipToOpen = new FileStream(Program.ZippedFile, FileMode.OpenOrCreate))
                    {
                        using (ZipArchive archive = new ZipArchive(zipToOpen, ZipArchiveMode.Create))
                        {
                            for (int IQ = 0; IQ < Program.SourceGroups.Count; IQ++)
                            {
                                for (int II = 0; II < Program.NS; II++)
                                {
                                    if ((IQ + II) % 2 == 0)
                                    {
                                        Console.Write(".");
                                    }
                                    string fname = Program.IWET.ToString("00000") + "-" + (II + 1).ToString("0") + Program.SourceGroups[IQ].ToString("00") + ".con";

                                    if (Program.WriteASCiiResults) // aditional ASCii Output
                                    {
                                        writeConDataAscii(fname, IQ, II);
                                    }

                                    ZipArchiveEntry write_entry = archive.CreateEntry(fname);

                                    using (BinaryWriter sw = new BinaryWriter(write_entry.Open()))
                                    {
                                        if (Program.ResultFileHeader == -2)
                                        {
                                            WriteConcentrationDataStrongCompressed(sw, IQ, II);
                                        }
                                        else if (Program.ResultFileHeader == -3)
                                        {
                                            WriteConcentrationDataAllCompressed(sw, IQ, II);
                                        }
                                        else
                                        {
                                            WriteConcentrationData(sw, IQ, II);
                                        }
                                    }

                                    // Write deposition
                                    if (II == 0 && (Program.DepositionExist || Program.WetDeposition))
                                    {
                                        fname       = Program.IWET.ToString("00000") + "-" + Program.SourceGroups[IQ].ToString("00") + ".dep";
                                        write_entry = archive.CreateEntry(fname);

                                        using (BinaryWriter sw = new BinaryWriter(write_entry.Open()))
                                        {
                                            if (Program.ResultFileHeader == -2)
                                            {
                                                WriteDepositionStrongCompressed(sw, IQ);
                                            }
                                            else if (Program.ResultFileHeader == -3)
                                            {
                                                WriteDepositionAllCompressed(sw, IQ);
                                            }
                                            else
                                            {
                                                WriteDepositionData(sw, IQ);
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
                else // not zipped
                {
                    for (int IQ = 0; IQ < Program.SourceGroups.Count; IQ++)
                    {
                        for (int II = 0; II < Program.NS; II++)
                        {
                            if ((IQ + II) % 2 == 0)
                            {
                                Console.Write(".");
                            }

                            string fname = Program.IWET.ToString("00000") + "-" + (II + 1).ToString("0") + Program.SourceGroups[IQ].ToString("00") + ".con";
                            if (Program.WriteASCiiResults) // aditional ASCii Output
                            {
                                writeConDataAscii(fname, IQ, II);
                            }

                            using (BinaryWriter sw = new BinaryWriter(File.Open(fname, FileMode.Create)))
                            {
                                WriteConcentrationData(sw, IQ, II);
                            }

                            // Write deposition
                            if (II == 0 && (Program.DepositionExist || Program.WetDeposition))
                            {
                                fname = Program.IWET.ToString("00000") + "-" + Program.SourceGroups[IQ].ToString("00") + ".dep";
                                using (BinaryWriter sw = new BinaryWriter(File.Open(fname, FileMode.Create)))
                                {
                                    WriteDepositionData(sw, IQ);
                                }
                            }
                        }
                    }
                }
            }
            catch (Exception exc)
            {
                Console.WriteLine();
                LogfileProblemreportWrite("Situation: " + Program.IWET.ToString() + " Error writing con file: " + exc.Message);
            } //Output of concentration files


            /// <summary>
            ///output of 2-D concentration files above selected layer and some other quantities, needed to compute R90 in odour simulations
            /// </summary>
            if (Program.Odour == true)
            {
                double Nhor = Program.NXL * Program.NYL;

                for (int IQ = 0; IQ < Program.SourceGroups.Count; IQ++)
                {
                    for (int II = 0; II < Program.NS; II++)
                    {
                        if ((IQ + II) % 2 == 0)
                        {
                            Console.Write(".");
                        }

                        Object thisLock = new Object();

                        Parallel.For(1, Program.NXL + 1, Program.pOptions, i =>
                        {
                            float Q_cv0_L = 0;
                            float td_L    = 0;

                            for (int j = 1; j <= Program.NYL; j++)
                            {
                                int IUst   = 1;
                                int JUst   = 1;
                                int IndexI = 1;
                                int IndexJ = 1;

                                int IndexK  = 1;
                                float UXint = 0, UYint = 0, UZint = 0, U0int = 0, V0int = 0;
                                float W0int = 0;
                                double xco  = Convert.ToDouble((float)i * Program.GralDx - 0.5 * Program.GralDx + Program.IKOOAGRAL);
                                double yco  = Convert.ToDouble((float)j * Program.GralDy - 0.5 * Program.GralDy + Program.JKOOAGRAL);

                                //horizontal cell indices
                                double xsi1 = (float)i * Program.GralDx - 0.5 * Program.GralDx + Program.IKOOAGRAL - Program.GrammWest;
                                double eta1 = (float)j * Program.GralDy - 0.5 * Program.GralDy + Program.JKOOAGRAL - Program.GrammSouth;
                                if (Program.Topo == 1)
                                {
                                    double xsi = xco - Program.IKOOAGRAL;
                                    double eta = yco - Program.JKOOAGRAL;
                                    IUst       = (int)(xsi1 / Program.DDX[1]) + 1;
                                    JUst       = (int)(eta1 / Program.DDY[1]) + 1;
                                    IUst       = Math.Clamp(IUst, 1, Program.NX);
                                    JUst       = Math.Clamp(JUst, 1, Program.NY);

                                    IndexI = (int)(xsi / Program.DXK) + 1;
                                    IndexJ = (int)(eta / Program.DYK) + 1;
                                }
                                else
                                {
                                    double xsi = xco - Program.IKOOAGRAL;
                                    double eta = yco - Program.JKOOAGRAL;
                                    IndexI     = (int)(xsi / Program.DXK) + 1;
                                    IndexJ     = (int)(eta / Program.DYK) + 1;
                                }
                                //surface height
                                float AHint = 0;
                                if (Program.Topo == 1)
                                {
                                    AHint = Program.AHK[IndexI][IndexJ];
                                }
                                //wind speed
                                (UXint, UYint, UZint, IndexK) = Zeitschleife.IntWindCalculate(IndexI, IndexJ, AHint, xco, yco, Program.HorSlices[II]);
                                float windge = (float)Math.Sqrt(Program.Pow2(UXint) + Program.Pow2(UYint));
                                if (windge <= 0)
                                {
                                    windge = 0.01F;
                                }

                                float ObLength = Program.Ob[IUst][JUst];
                                float Z0       = Program.Z0Gramm[IUst][JUst];
                                float ust      = Program.Ustern[IUst][JUst];
                                if (Program.AdaptiveRoughnessMax > 0)
                                {
                                    ObLength = Program.OLGral[i][j];
                                    Z0       = Program.Z0Gral[i][j];
                                    ust      = Program.USternGral[i][j];
                                }

                                //horizontal wind standard deviations
                                (U0int, V0int) = Zeitschleife.IntStandCalculate(1, Z0, Program.HorSlices[II], windge, 0);

                                //vertical wind standard deviation
                                if (Program.IStatistics == 3)
                                {
                                    W0int = Program.W0int;
                                }
                                else
                                {
                                    if (ObLength >= 0)
                                    {
                                        W0int = ust * Program.StdDeviationW * 1.25F;
                                    }
                                    else
                                    {
                                        W0int = (float)(ust * (1.15F + 0.1F * Math.Pow(Program.BdLayHeight / (-ObLength), 0.67)) * Program.StdDeviationW);
                                    }
                                }

                                //dissipation
                                float eps = (float)(Program.Pow3(ust) / Math.Max(Program.HorSlices[II], Z0) / 0.4F *
                                                    Math.Pow(1 + 0.5F * Math.Pow(Program.HorSlices[II] / Math.Abs(ObLength), 0.8), 1.8));

                                Q_cv0_L += (float)(4 / eps * (Program.Pow4(U0int) / 3 + Program.Pow4(V0int) / 3 + Program.Pow4(W0int) / 4));
                                td_L    += (float)(2 * Program.Pow2(W0int) / 4 / eps);
                            } // j - loop

                            lock (thisLock)
                            {
                                //source-term for the concentration variance (the term is probably wrongly calculated -> should be stored separately for each direction and then multiplied with the corresponding concentration gradient
                                Program.Q_cv0[II][IQ] += Q_cv0_L;

                                //dissipation time-scale set equal to the vertical lagrangian time-scale; note the proportionality constant is different in various publications
                                Program.DisConcVar[II][IQ] += td_L;
                            }
                        });

                        thisLock = null;

                        Program.Q_cv0[II][IQ]      /= (float)Nhor;
                        Program.DisConcVar[II][IQ] /= (float)Nhor;

                        //output of several quantities needed to run the concentration variance model subsequently
                        string fname = Program.IWET.ToString("00000") + "-" + (II + 1).ToString("0") + Program.SourceGroups[IQ].ToString("00") + ".odr";
                        try
                        {
                            if (Program.ResultFileZipped)
                            {
                                using (FileStream zipToOpen = new FileStream(Program.ZippedFile, FileMode.OpenOrCreate))
                                {
                                    using (ZipArchive archive = new ZipArchive(zipToOpen, ZipArchiveMode.Update))
                                    {
                                        ZipArchiveEntry write_entry = archive.CreateEntry(fname);

                                        using (BinaryWriter sw = new BinaryWriter(write_entry.Open()))
                                        {
                                            if (Program.ResultFileHeader == -2)
                                            {
                                                WriteOdourDataStrongCompressed(sw, IQ, II);
                                            }
                                            else if (Program.ResultFileHeader == -3)
                                            {
                                                WriteOdourDataAllCompressed(sw, IQ, II);
                                            }
                                            else
                                            {
                                                WriteOdourData(sw, IQ, II);
                                            }
                                        }
                                    }
                                }
                            }
                            else //unzipped files
                            {
                                using (BinaryWriter sw = new BinaryWriter(File.Open(fname, FileMode.Create)))
                                {
                                    WriteOdourData(sw, IQ, II);
                                }
                            }
                        }
                        catch (Exception exc)
                        {
                            if (IQ == 1)
                            {
                                Console.WriteLine();
                                LogfileProblemreportWrite("Situation: " + Program.IWET.ToString() + " Error writing odr file: " + exc.Message);
                            }
                        }
                    }
                }
            }

            //reset concentrations
            Console.WriteLine(".");
            for (int iq = 0; iq < Program.SourceGroups.Count; iq++)
            {
                for (int II = 0; II < Program.NS; II++)
                {
                    for (int i = 1; i <= Program.NXL; i++)
                    {
                        for (int j = 1; j <= Program.NYL; j++)
                        {
                            Program.Conz3d[i][j][II][iq] = 0;
                            Program.Depo_conz[i][j][iq]  = 0;
                            if (Program.Odour == true)
                            {
                                Program.Conz3dp[i][j][II][iq] = 0;
                                Program.Conz3dm[i][j][II][iq] = 0;
                                Program.Q_cv0[II][iq]         = 0;
                                Program.DisConcVar[II][iq]    = 0;
                            }
                        }
                    }
                }
            }
            Console.WriteLine();
        }//output of 2-D concentration files (concentrations, deposition, odour-files)
示例#2
0
        /*INPUT FILES :
         * BASIC DOMAIN INFORMATION              GRAL.geb
         * MAIN CONTROL PARAM FILEs              in.dat
         * GEOMETRY DATA                         ggeom.asc
         * LANDUSE DATA                          landuse.asc
         * METEOROLOGICAL DATA                   meteopgt.all, or inputzr.dat, or sonic.dat
         * MAX. NUMBER OF CPUs                   Max_Proc.txt
         * EMISSION SOURCES                      line.dat, point.dat, cadastre.dat, portals.dat
         * TUNNEL JET DESTRUCTION
         * BY TRAFFIC ON OPPOSITE LANE           oppsite_lane.txt
         * POLLUTANTS SUCKED IN BY
         * TUNNEL PORTAL AT OPPOSITE LANE        tunnel_entrance.txt
         * LOCATIONS AND HEIGHTS OF BUILDINGS    buildings.dat
         * LOCATIONS AND HEIGHTS OF VEGETATION   vegetation.dat
         * LOCATIONS AND HEIGHTS OF RECEPTORS    Receptor.dat
         * NUMBER OF VERTICAL LAYERS FOR
         * PROGNOSTIC FLOW FIELD MODEL           micro_vert_layers.txt
         * RELAXATION FACTORS FOR
         * PROGNOSTIC FLOW FIELD MODEL           relaxation_factors.txt
         * MINIMUM ANd MAXIMUM INTEGRATION TIMES
         * FOR PROGNOSTIC FLOW FIELD MODEL       Integrationtime.txt
         * ROUGHNESS LENGTH FOR OBSTACLES
         * FOR PROGNOSTIC FLOW FIELD MODEL       building_roughness.txt
         * TRANSIENT GRAL MODE CONC.THRESHOLD	GRAL_Trans_Conc_Threshold.txt
         * POLLUTANT & WET DEPOSITION SETTINGS	Pollutant.txt
         * WET DEPOSITION PRECIPITATION DATA		Precipitation.txt
         * CALCULATE 3D CONCENTRATION DATA IN
         * TRANSIENT GRAL MODE					GRAL_Vert_Conc.txt
         */

        static void Main(string[] args)
        {
            int p = (int)Environment.OSVersion.Platform;

            if ((p == 4) || (p == 6) || (p == 128))
            {
                //Console.WriteLine ("Running on Unix");
                RunOnUnix = true;
            }

            //WRITE GRAL VERSION INFORMATION TO SCREEN
            Console.WriteLine("");
            Console.WriteLine("+------------------------------------------------------+");
            Console.WriteLine("|                                                      |");
            string Info = "+  > >         G R A L VERSION: 20.09            < <   +";

            Console.WriteLine(Info);
            if (RunOnUnix)
            {
                Console.WriteLine("|                     L I N U X                        |");
            }
            Console.WriteLine("|                 .Net Core Version                    |");
            Console.WriteLine("|                                                      |");
            Console.WriteLine("+------------------------------------------------------+");
            Console.WriteLine("");

            ShowCopyright(args);

            // write zipped files?
            ResultFileZipped = false;
            //User defined decimal seperator
            Decsep = NumberFormatInfo.CurrentInfo.NumberDecimalSeparator;

            int SIMD = CheckSIMD();

            LogLevel = CheckCommandLineArguments(args);

            //Delete file Problemreport_GRAL.txt
            if (File.Exists("Problemreport_GRAL.txt") == true)
            {
                try
                {
                    File.Delete("Problemreport_GRAL.txt");
                }
                catch { }
            }
            // Write to "Logfile_GRALCore"
            try
            {
                ProgramWriters.LogfileGralCoreWrite(new String('-', 80));
                ProgramWriters.LogfileGralCoreWrite(Info);
                ProgramWriters.LogfileGralCoreWrite("Computation started at: " + DateTime.Now.ToString());
                ProgramWriters.LogfileGralCoreWrite("Computation folder:     " + Directory.GetCurrentDirectory());
                Info = "Application hash code:  " + GetAppHashCode();
                ProgramWriters.LogfileGralCoreWrite(Info);
            }
            catch { }

            ProgramReaders ReaderClass = new ProgramReaders();

            //Read number of user defined vertical layers
            ReaderClass.ReadMicroVertLayers();
            GFFFilePath = ReaderClass.ReadGFFFilePath();

            //Lowest grid level of the prognostic flow field model grid
            HOKART[0] = 0;

            //read main GRAL domain file "GRAL.geb" and check if the file "UseOrigTopography.txt" exists -> needed to read In.Dat!
            ReaderClass.ReadGRALGeb();

            //optional: read GRAMM file ggeom.asc
            if (File.Exists("ggeom.asc") == true)
            {
                ReaderClass.ReadGRAMMGeb();
            }

            //horizontal grid sizes of the GRAL concentration grid
            GralDx = (float)((XsiMaxGral - XsiMinGral) / (float)NXL);
            GralDy = (float)((EtaMaxGral - EtaMinGral) / (float)NYL);

            //Set the maximum number of threads to be used in each parallelized region
            ReaderClass.ReadMaxNumbProc();

            //sets the number of cells near the walls of obstacles, where a boundary-layer is computed in the diagnostic flow field approach
            IGEB = Math.Max((int)(20 / DXK), 1);

            //Read Pollutant and Wet deposition data
            Odour = ReaderClass.ReadPollutantTXT();

            //Create large arrays
            CreateLargeArrays();

            //optional: reading GRAMM orography file ggeom.asc -> there are two ways to read ggeom.asc (1) the files contains all information or (2) the file just provides the path to the original ggeom.asc
            ReaderClass.ReadGgeomAsc();

            //number of grid cells of the GRAL microscale flow field
            NII          = (int)((XsiMaxGral - XsiMinGral) / DXK);
            NJJ          = (int)((EtaMaxGral - EtaMinGral) / DYK);
            AHKOri       = CreateArray <float[]>(NII + 2, () => new float[NJJ + 2]);
            GralTopofile = ReaderClass.ReadGRALTopography(NII, NJJ); // GRAL Topofile OK?

            //reading main control file in.dat
            ReaderClass.ReadInDat();
            //total number of particles released for each weather situation
            NTEILMAX = (int)(TAUS * TPS);
            //Volume of the GRAL concentration grid
            GridVolume = GralDx * GralDy * GralDz;

            //Reading building data
            //case 1: complex terrain
            if (Topo == 1)
            {
                InitGralTopography(SIMD);
                ReaderClass.ReadBuildingsTerrain(Program.CUTK); //define buildings in GRAL
            }
            //flat terrain application
            else
            {
                InitGralFlat();
                ReaderClass.ReadBuildingsFlat(Program.CUTK); //define buildings in GRAL
            }

            // array declarations for prognostic and diagnostic flow field
            if ((FlowFieldLevel > 0) || (Topo == 1))
            {
                // create jagged arrays manually to keep memory areas of similar indices togehter -> reduce false sharing &
                // save memory because of the unused index 0
                DIV = new float[NII + 1][][];
                DPM = new float[NII + 1][][];
                for (int i = 1; i < NII + 1; ++i)
                {
                    DIV[i] = new float[NJJ + 1][];
                    DPM[i] = new float[NJJ + 1][];
                    for (int j = 1; j < NJJ + 1; ++j)
                    {
                        DIV[i][j] = new float[NKK + 1];
                        DPM[i][j] = new float[NKK + 2];
                    }
                    if (i % 100 == 0)
                    {
                        Console.Write(".");
                    }
                }
            }

            //In case of transient simulations: load presets and define arrays
            if (ISTATIONAER == 0)
            {
                TransientPresets.LoadAndDefine();
            }

            Console.WriteLine(".");
            //reading receptors from file Receptor.dat
            ReaderClass.ReadReceptors();

            //the horizontal standard deviations of wind component fluctuations are dependent on the averaging time (dispersion time)
            if ((IStatistics == 4))
            {
                StdDeviationV = (float)Math.Pow(TAUS / 3600, 0.2);
            }

            //for applications in flat terrain, the roughness length is homogenous as defined in the file in.dat
            if (Topo != 1)
            {
                Z0Gramm[1][1] = Z0;
            }

            //checking source files
            if (File.Exists("line.dat") == true)
            {
                LS_Count = 1;
            }

            if (File.Exists("portals.dat") == true)
            {
                TS_Count = 1;
            }

            if (File.Exists("point.dat") == true)
            {
                PS_Count = 1;
            }

            if (File.Exists("cadastre.dat") == true)
            {
                AS_Count = 1;
            }

            Console.WriteLine();
            Info = "Total number of horizontal slices for concentration grid: " + NS.ToString();
            Console.WriteLine(Info);

            for (int i = 0; i < NS; i++)
            {
                try
                {
                    Info = "  Slice height above ground [m]: " + HorSlices[i].ToString();
                    Console.WriteLine(Info);
                }
                catch
                { }
            }

            //emission modulation for transient mode
            ReaderClass.ReadEmissionTimeseries();

            //vegetation array
            VEG = CreateArray <float[][]>(NII + 2, () => CreateArray <float[]>(NJJ + 2, () => new float[NKK + 1]));
            Program.VEG[0][0][0] = -0.00001f;
            COV = CreateArray <float[]>(NII + 2, () => new float[NJJ + 2]);

            //reading optional files used to define areas where either the tunnel jet stream is destroyed due to traffic
            //on the opposite lanes of a highway or where pollutants are sucked into a tunnel portal
            ReaderClass.ReadTunnelfilesOptional();

            //optional: reading land-use data from file landuse.asc
            ReaderClass.ReadLanduseFile();

            //Use the adaptive roughness lenght mode?
            if (AdaptiveRoughnessMax > 0 && BuildingsExist)
            {
                //define FlowField dependend Z0, UStar and OL, generate Z0GRAL[][] array and write RoghnessGRAL file
                InitAdaptiveRoughnessLenght(ReaderClass);
            }
            else
            {
                AdaptiveRoughnessMax = 0;
            }

            //setting the lateral borders of the domain -> Attention: changes the GRAL borders from absolute to reletive values!
            InitGralBorders();

            //reading point source data
            if (PS_Count > 0)
            {
                PS_Count = 0;
                Console.WriteLine();
                Console.WriteLine("Reading file point.dat");
                ReadPointSources.Read();
            }
            //reading line source data
            if (LS_Count > 0)
            {
                LS_Count = 0;
                Console.WriteLine();
                Console.WriteLine("Reading file line.dat");
                ReadLineSources.Read();
            }
            //reading tunnel portal data
            if (TS_Count > 0)
            {
                TS_Count = 0;
                Console.WriteLine();
                Console.WriteLine("Reading file portals.dat");
                ReadTunnelPortals.Read();
            }
            //reading area source data
            if (AS_Count > 0)
            {
                AS_Count = 0;
                Console.WriteLine();
                Console.WriteLine("Reading file cadastre.dat");
                ReadAreaSources.Read();
            }

            //distribution of all particles over all sources according to their source strengths (the higher the emission rate the larger the number of particles)
            NTEILMAX = ParticleManagement.Calculate();
            //Coriolis parameter
            CorolisParam = (float)(2 * 7.29 * 0.00001 * Math.Sin(Math.Abs(LatitudeDomain) * 3.1415 / 180));

            //weather situation to start with
            IWET = IWETstart - 1;

            //read mettimeseries.dat, meteopgt.all and Precipitation.txt in case of transient simulations
            InputMettimeSeries InputMetTimeSeries = new InputMettimeSeries();

            if ((ISTATIONAER == 0) && (IStatistics == 4))
            {
                InputMetTimeSeries.WindData = MeteoTimeSer;
                InputMetTimeSeries.ReadMetTimeSeries();
                MeteoTimeSer = InputMetTimeSeries.WindData;
                if (MeteoTimeSer.Count == 0) // no data available
                {
                    string err = "Error when reading file mettimeseries.dat -> Execution stopped: press ESC to stop";
                    Console.WriteLine(err);
                    ProgramWriters.LogfileProblemreportWrite(err);
                }
                InputMetTimeSeries.WindData = MeteopgtLst;
                InputMetTimeSeries.ReadMeteopgtAll();
                MeteopgtLst = InputMetTimeSeries.WindData;
                if (MeteopgtLst.Count == 0) // no data available
                {
                    string err = "Error when reading file meteopgt.all -> Execution stopped: press ESC to stop";
                    Console.WriteLine(err);
                    ProgramWriters.LogfileProblemreportWrite(err);
                }
                // Read precipitation data
                ReaderClass.ReadPrecipitationTXT();
            }
            else
            {
                WetDeposition = false;
            }

            if (ISTATIONAER == 0)
            {
                Info = "Transient GRAL mode. Number of weather situations: " + MeteoTimeSer.Count.ToString();
                Console.WriteLine(Info);
                ProgramWriters.LogfileGralCoreWrite(Info);
            }

            /********************************************
            * MAIN LOOP OVER EACH WEATHER SITUATION    *
            ********************************************/
            Thread ThreadWriteGffFiles   = null;
            Thread ThreadWriteConz4dFile = null;

            bool FirstLoop = true;

            while (IEND == 0)
            {
                // if GFF writing thread has been started -> wait until GFF--WriteThread has been finished
                if (ThreadWriteGffFiles != null)
                {
                    ThreadWriteGffFiles.Join(5000); // wait up to 5s or until thread has been finished
                    if (ThreadWriteGffFiles.IsAlive)
                    {
                        Console.Write("Writing *.gff file..");
                        while (ThreadWriteGffFiles.IsAlive)
                        {
                            ThreadWriteGffFiles.Join(30000); // wait up to 30s or until thread has been finished
                            Console.Write(".");
                        }
                        Console.WriteLine();
                    }
                    ThreadWriteGffFiles = null; // Release ressources
                }

                //Next weather situation
                IWET++;
                IDISP        = IWET;
                WindVelGramm = -99; WindDirGramm = -99; StabClassGramm = -99; // Reset GRAMM values

                //show actual computed weather situation
                Console.WriteLine("_".PadLeft(79, '_'));
                Console.Write("Weather number: " + IWET.ToString());
                if (ISTATIONAER == 0)
                {
                    int _iwet = IWET - 1;
                    if (_iwet < MeteoTimeSer.Count)
                    {
                        Console.WriteLine(" - " + MeteoTimeSer[_iwet].Day + "." + MeteoTimeSer[_iwet].Month + "-" + MeteoTimeSer[_iwet].Hour + ":00");
                    }
                }
                else
                {
                    Console.WriteLine();
                }

                //time stamp to evaluate computation times
                int StartTime = Environment.TickCount;

                //Set the maximum number of threads to be used in each parallelized region
                ReaderClass.ReadMaxNumbProc();

                //read meteorological input data
                if (IStatistics == 4)
                {
                    if (ISTATIONAER == 0)
                    {
                        //search for the corresponding weather situation in meteopgt.all
                        IDISP     = InputMetTimeSeries.SearchWeatherSituation() + 1;
                        IWETstart = IDISP;
                        if (IWET > MeteoTimeSer.Count)
                        {
                            IEND = 1;
                        }
                    }
                    else
                    {
                        //in stationary mode, meteopgt.all is read here, because we need IEND
                        IEND = Input_MeteopgtAll.Read();
                        IWETstart--; // reset the counter, because metepgt.all is finally read in ReadMeteoData, after the GRAMM wind field is available
                    }
                }

                if (ISTATIONAER == 0 && IDISP == 0)
                {
                    break; // reached last line in mettimeseries -> exit loop
                }

                if (IEND == 1)
                {
                    break; // reached last line in meteopgt.all ->  exit loop
                }

                String WindfieldPath = ReadWindfeldTXT();

                if (Topo == 1)
                {
                    Console.Write("Reading GRAMM wind field: ");
                }

                if (ISTATIONAER == 0 && IDISP < 0) // found no corresponding weather situation in meteopgt.all
                {
                    Info = "Cannot find a corresponding entry in meteopgt.all to the following line in mettimeseries.dat - situation skipped: " + IWET.ToString();
                    Console.WriteLine();
                    Console.WriteLine(Info);
                    ProgramWriters.LogfileGralCoreWrite(Info);
                }
                else if (Topo == 0 || (Topo == 1 && ReadWndFile.Read(WindfieldPath))) // stationary mode or an entry in meteopgt.all exist && if topo -> wind field does exist
                {
                    //GUI output
                    try
                    {
                        using (StreamWriter wr = new StreamWriter("DispNr.txt"))
                        {
                            wr.WriteLine(IWET.ToString());
                        }
                    }
                    catch { }

                    //Topography mode -> read GRAMM stability classes
                    if (Topo == 1)
                    {
                        string SclFileName = String.Empty;
                        if (WindfieldPath == String.Empty)
                        {
                            //case 1: stability fields are located in the same sub-directory as the GRAL executable
                            SclFileName = Convert.ToString(Program.IDISP).PadLeft(5, '0') + ".scl";
                        }
                        else
                        {
                            //case 2: wind fields are imported from a different project
                            SclFileName = Path.Combine(WindfieldPath, Convert.ToString(Program.IDISP).PadLeft(5, '0') + ".scl");
                        }

                        if (File.Exists(SclFileName))
                        {
                            Console.WriteLine("Reading GRAMM stability classes: " + SclFileName);

                            ReadSclUstOblClasses Reader = new ReadSclUstOblClasses
                            {
                                FileName    = SclFileName,
                                Stabclasses = AKL_GRAMM
                            };
                            Reader.ReadSclFile();
                            AKL_GRAMM = Reader.Stabclasses;
                            Reader.Close();
                        }
                    }

                    //Read meteorological input data depending on the input type IStatisitcs
                    ReadMeteoData();

                    //Check if all weather situations have been computed
                    if (IEND == 1)
                    {
                        break;
                    }

                    //potential temperature gradient
                    CalculateTemperatureGradient();

                    //optional: read pre-computed GRAL flow fields
                    bool GffFiles = ReadGralFlowFields.Read();
                    if (GffFiles == false) // Reading of GRAL Flowfields not successful
                    {
                        //microscale flow field: complex terrain
                        if (Topo == 1)
                        {
                            MicroscaleTerrain.Calculate(FirstLoop);
                        }
                        //microscale flow field: flat terrain
                        else if ((Topo == 0) && ((BuildingsExist == true) || (File.Exists("vegetation.dat") == true)))
                        {
                            MicroscaleFlat.Calculate();
                        }
                        if (Topo == 0)
                        {
                            Program.AHMIN = 0;
                        }

                        //optional: write GRAL flow fields
                        ThreadWriteGffFiles = new Thread(WriteGRALFlowFields.Write);
                        ThreadWriteGffFiles.Start(); // start writing thread

                        if (FirstLoop)
                        {
                            WriteGRALFlowFields.WriteGRALGeometries();
                        }
                    }
                    ProgramWriters WriteClass = new ProgramWriters();

                    //time needed for wind-field computations
                    double CalcTimeWindfield = (Environment.TickCount - StartTime) * 0.001;

                    //reset receptor concentrations
                    if (ReceptorsAvailable == 1) // if receptors are acitvated
                    {
                        ReadReceptors.ReceptorResetConcentration();
                    }

                    if (FirstLoop)
                    {
                        //read receptors
                        ReceptorNumber = 0;
                        if (ReceptorsAvailable == 1)      // if receptors are acitvated
                        {
                            ReadReceptors.ReadReceptor(); // read coordinates of receptors - flow field data needed
                        }
                        //in case of complex terrain and/or the presence of buildings some data is written for usage in the GUI (visualization of vertical slices)
                        WriteClass.WriteGRALGeometries();
                        //optional: write building heights as utilized in GRAL
                        WriteClass.WriteBuildingHeights("building_heights.txt", Program.BUI_HEIGHT, "0.0", 1, Program.IKOOAGRAL, Program.JKOOAGRAL);

                        Console.WriteLine(Info);
                        ProgramWriters.LogfileGralCoreWrite(Info);
                    }

                    //calculating momentum and bouyancy forces for point sources
                    PointSourceHeight.CalculatePointSourceHeight();

                    //defining the initial positions of particles
                    StartCoordinates.Calculate();

                    //boundary-layer height
                    CalculateBoudaryLayerHeight();

                    //show meteorological parameters on screen
                    OutputOfMeteoData();

                    //Transient mode: non-steady-state particles
                    if (ISTATIONAER == 0)
                    {
                        Console.WriteLine();
                        Console.Write("Dispersion computation.....");
                        // calculate wet deposition parameter
                        if (IWET < WetDepoPrecipLst.Count)
                        {
                            if (WetDepoPrecipLst[IWET] > 0)
                            {
                                WetDepoRW = Wet_Depo_CW * Math.Pow(WetDepoPrecipLst[IWET], WedDepoAlphaW);
                                WetDepoRW = Math.Max(0, Math.Min(1, WetDepoRW));
                            }
                            else
                            {
                                WetDepoRW = 0;
                            }
                        }

                        //set lower concentration threshold for memory effect
                        TransConcThreshold = ReaderClass.ReadTransientThreshold();
                        int IPERCnss     = 0;
                        int advancenss   = 0;
                        int cellNr       = NII * NJJ;
                        int percent10nss = (int)(cellNr * 0.1F);
                        DispTimeSum = TAUS;
                        // loop over all cells
                        Parallel.For(0, cellNr, Program.pOptions, cell =>
                        {
                            Interlocked.Increment(ref advancenss);
                            if (advancenss > percent10nss)
                            {
                                Interlocked.Exchange(ref advancenss, 0); // set advance to 0
                                Interlocked.Add(ref IPERCnss, 10);
                                if (IPERCnss < 100)
                                {
                                    Console.Write("X");
                                    if (IPERCnss % 20 == 0)
                                    {
                                        try
                                        {
                                            using (StreamWriter sr = new StreamWriter("Percent.txt", false))
                                            {
                                                sr.Write(MathF.Round(IPERCnss * 0.5F).ToString());
                                            }
                                        }
                                        catch { }
                                    }
                                }
                            }

                            // indices of recent cellNr
                            int i = 1 + (cell % NII);
                            int j = 1 + (int)(cell / NII);
                            for (int k = 1; k <= NKK_Transient; k++)
                            {
                                for (int IQ = 0; IQ < Program.SourceGroups.Count; IQ++)
                                {
                                    if (Conz4d[i][j][k][IQ] >= TransConcThreshold)
                                    {
                                        ZeitschleifeNonSteadyState.Calculate(i, j, k, IQ, Conz4d[i][j][k][IQ]);
                                    }
                                }
                            }
                        });
                        Console.Write("X");
                    } // non-steady-state particles

                    Console.WriteLine();
                    Console.Write("Dispersion computation.....");
                    //new released particles
                    int IPERC     = 0;
                    int advance   = 0;
                    int percent10 = (int)(NTEILMAX * 0.1F);
                    DispTimeSum = TAUS;
                    Parallel.For(1, NTEILMAX + 1, Program.pOptions, nteil =>
                    {
                        Interlocked.Increment(ref advance);
                        if (advance > percent10)
                        {
                            Interlocked.Exchange(ref advance, 0); // set advance to 0
                            Interlocked.Add(ref IPERC, 10);
                            Console.Write("I");
                            if (IPERC % 20 == 0)
                            {
                                try
                                {
                                    using (StreamWriter sr = new StreamWriter("Percent.txt", false))
                                    {
                                        if (ISTATIONAER == 0)
                                        {
                                            sr.Write((50 + MathF.Round(IPERC * 0.5F)).ToString());
                                        }
                                        else
                                        {
                                            sr.Write(IPERC.ToString());
                                        }
                                    }
                                }
                                catch { }
                            }
                        }
                        Zeitschleife.Calculate(nteil);
                    });

                    Console.Write("I");
                    Console.WriteLine();

                    // Wait until conz4d file is written
                    if (ThreadWriteConz4dFile != null) // if Thread has been started -> wait until GFF--WriteThread has been finished
                    {
                        ThreadWriteConz4dFile.Join();  // wait, until thread has been finished
                        ThreadWriteConz4dFile = null;  // Release ressources
                    }

                    //tranferring non-steady-state concentration fields
                    if (ISTATIONAER == 0)
                    {
                        TransferNonSteadyStateConcentrations(WriteClass, ref ThreadWriteConz4dFile);
                    }

                    if (FirstLoop)
                    {
                        ProgramWriters.LogfileGralCoreInfo(ResultFileZipped, GffFiles);
                        FirstLoop = false;
                    }

                    //Correction of concentration volume in each cell and for each gridded receptor
                    VolumeCorrection();

                    //time needed for dispersion computations
                    double CalcTimeDispersion = (Environment.TickCount - StartTime) * 0.001 - CalcTimeWindfield;
                    Console.WriteLine();
                    Console.WriteLine("Total simulation time [s]: " + (CalcTimeWindfield + CalcTimeDispersion).ToString("0.0"));
                    Console.WriteLine("Dispersion [s]: " + CalcTimeDispersion.ToString("0.0"));
                    Console.WriteLine("Flow field [s]: " + CalcTimeWindfield.ToString("0.0"));

                    if (LogLevel > 0) // additional LOG-Output
                    {
                        LOG01_Output();
                    }

                    ZippedFile = IWET.ToString("00000") + ".grz";
                    try
                    {
                        if (File.Exists(ZippedFile))
                        {
                            File.Delete(ZippedFile); // delete existing files
                        }
                    }
                    catch { }

                    //output of 2-D concentration files (concentrations, deposition, odour-files)
                    WriteClass.Write2DConcentrations();

                    //receptor concentrations
                    if (ISTATIONAER == 0)
                    {
                        WriteClass.WriteReceptorTimeseries(0);
                    }
                    WriteClass.WriteReceptorConcentrations();

                    //microscale flow-field at receptors
                    WriteClass.WriteMicroscaleFlowfieldReceptors();
                } //skipped situation if no entry in meteopgt.all could be found in transient GRAL mode
            }

            // Write summarized emission per source group and 3D Concentration file
            if (ISTATIONAER == 0)
            {
                ProgramWriters WriteClass = new ProgramWriters();
                if (WriteVerticalConcentration)
                {
                    WriteClass.Write3DTextConcentrations();
                }
                Console.WriteLine();
                ProgramWriters.LogfileGralCoreWrite("");
                ProgramWriters.ShowEmissionRate();
            }

            if (ThreadWriteGffFiles != null) // if Thread has been started -> wait until GFF--WriteThread has been finished
            {
                ThreadWriteGffFiles.Join();  // wait, until thread has been finished
                ThreadWriteGffFiles = null;  // Release ressources
            }

            // Clean transient files
            Delete_Temp_Files();

            //Write receptor statistical error
            if (Program.ReceptorsAvailable > 0)
            {
                ProgramWriters WriteClass = new ProgramWriters();
                WriteClass.WriteReceptorTimeseries(1);
            }

            ProgramWriters.LogfileGralCoreWrite("GRAL simulations finished at: " + DateTime.Now.ToString());
            ProgramWriters.LogfileGralCoreWrite(new String('-', 80));

            if (Program.IOUTPUT <= 0 && Program.WaitForConsoleKey) // not for Soundplan or no keystroke
            {
                Console.WriteLine();
                Console.WriteLine("GRAL simulations finished. Press any key to continue...");
                Console.ReadKey(true);  // wait for a key input
            }

            Environment.Exit(0);        // Exit console
        }