/// <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)
/*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
}
