Water Modeling Hub: Expert Insights on SWMM5, ICM & InfoSWMM: #SWMM5 - Delphi Pascal unit that imports a SWMM project's data from a formatted text file

Sunday, July 23, 2017

#SWMM5 - Delphi Pascal unit that imports a SWMM project's data from a formatted text file

unit Uimport;

{-------------------------------------------------------------------}
{ Unit: Uimport.pas }
{ Project: EPA SWMM }
{ Version: 5.1 }
{ Date: 12/02/13 (5.1.001) }
{ 04/04/14 (5.1.003) }
{ 04/14/14 (5.1.004) }
{ 09/15/14 (5.1.007) }
{ 03/19/15 (5.1.008) }
{ 08/05/15 (5.1.010) }
{ 08/01/16 (5.1.011) }
{ Author: L. Rossman }
{ }
{ Delphi Pascal unit that imports a SWMM project's data from a }
{ a formatted text file. }
{ }
{ 5.1.011 - Support for reading [EVENTS] section added. }
{-------------------------------------------------------------------}

interface

uses
Classes, Forms, Controls, Dialogs, SysUtils, Windows, Math, StrUtils,
Uutils, Uglobals;

const
ITEMS_ERR = 1;
KEYWORD_ERR = 2;
SUBCATCH_ERR = 3;
NODE_ERR = 4;
LINK_ERR = 5;
LANDUSE_ERR = 6;
POLLUT_ERR = 7;
NUMBER_ERR = 8;
XSECT_ERR = 9;
TRANSECT_ERR = 10;
TIMESTEP_ERR = 11;
DATE_ERR = 12;
LID_ERR = 13;
MAX_ERRORS = 50;

type
TFileType = (ftInput, ftImport);

// These routines can be called from other units
function ErrMsg(const ErrCode: Integer; const Name: String): Integer;
function OpenProject(const Fname: String): TInputFileType;
function ReadInpFile(const Fname: String):Boolean;
procedure SetDefaultDates;

implementation

uses
Fmain, Fmap, Fstatus, Dxsect, Uexport, Uinifile, Uproject, Umap,
Ucoords, Uvertex, Uupdate, Dreporting, Ulid;

const
MSG_READING_PROJECT_DATA = 'Reading project data... ';
TXT_ERROR = 'Error ';
TXT_AT_LINE = ' at line ';
TXT_MORE_ERRORS = ' more errors found in file.';
TXT_ERROR_REPORT = 'Error Report for File ';

SectionWords : array[0..54] of PChar = //(5.1.011)
('[TITLE', //0
'[OPTION', //1
'[RAINGAGE', //2
'[HYDROGRAPH', //3
'[EVAPORATION', //4
'[SUBCATCHMENT', //5
'[SUBAREA', //6
'[INFILTRATION', //7
'[AQUIFER', //8
'[GROUNDWATER', //9
'[JUNCTION', //10
'[OUTFALL', //11
'[STORAGE', //12
'[DIVIDER', //13
'[CONDUIT', //14
'[PUMP', //15
'[ORIFICE', //16
'[WEIR', //17
'[OUTLET', //18
'[XSECTION', //19
'[TRANSECT', //20
'[LOSS', //21
'[CONTROL', //22
'[POLLUTANT', //23
'[LANDUSE', //24
'[BUILDUP', //25
'[WASHOFF', //26
'[COVERAGE', //27
'[INFLOW', //28
'[DWF', //29
'[PATTERN', //30
'[RDII', //31
'[LOAD', //32
'[CURVE', //33
'[TIMESERIES', //34
'[REPORT', //35
'[FILE', //36
'[MAP', //37
'[COORDINATES', //38
'[VERTICES', //39
'[POLYGONS', //40
'[SYMBOLS', //41
'[LABELS', //42
'[BACKDROP', //43
'[PROFILE', //44
'[TABLE', //45
'[TEMPERATURE', //46
'[SNOWPACK', //47
'[TREATMENT', //48
'[TAG', //49
'[LID_CONTROL', //50
'[LID_USAGE', //51
'[GWF', //52 //(5.1.007)
'[ADJUSTMENTS', //53 //(5.1.007)
'[EVENT'); //54 //(5.1.011)

var
FileType : TFileType;
InpFile : String;
ErrList : TStringlist;
SubcatchList : TStringlist;
NodeList : TStringlist;
LinkList : TStringlist;
TokList : TStringlist;
Ntoks : Integer;
Section : Integer;
LineCount : LongInt;
ErrCount : LongInt;
Line : String;
Comment : String;
TsectComment : String;
PrevID : String;
PrevIndex : Integer;
CurveType : Integer;
MapExtentSet : Boolean;
ManningsN : array[1..3] of String;

// These are deprecated attributes of a backdrop image
BackdropX : Extended;
BackdropY : Extended;
BackdropW : Extended;
BackdropH : Extended;

function ErrMsg(const ErrCode: Integer; const Name: String): Integer;
//-----------------------------------------------------------------------------
// Adds an error message for a specific error code to the list
// of errors encountered when reading an input file.
//-----------------------------------------------------------------------------
var
S: String;
begin
if ErrCount <= MAX_ERRORS then
begin
case ErrCode of
ITEMS_ERR: S := 'Too few items ';
KEYWORD_ERR: S := 'Unrecognized keyword (' + Name + ') ';
SUBCATCH_ERR: S := 'Undefined Subcatchment (' + Name + ') referenced ';
NODE_ERR: S := 'Undefined Node (' + Name + ') referenced ';
LINK_ERR: S := 'Undefined Link (' + Name + ') referenced ';
LANDUSE_ERR: S := 'Undefined Land Use (' + Name + ') referenced ';
POLLUT_ERR: S := 'Undefined Pollutant (' + Name + ') referenced ';
NUMBER_ERR: S := 'Illegal numeric value (' + Name + ') ';
XSECT_ERR: S := 'Illegal cross section for Link ' + Name + ' ';
TRANSECT_ERR: S := 'No Transect defined for these data ';
TIMESTEP_ERR: S := 'Illegal time step value ';
DATE_ERR: S := 'Illegal date/time value ';
LID_ERR: S := 'Undefined LID process (' + Name + ') referenced ';
else S := 'Unknown error ';
end;
S := S + 'at line ' + IntToStr(LineCount) + ':';
ErrList.Add(S);
if Section >= 0 then ErrList.Add(SectionWords[Section] + ']');
ErrList.Add(Line);
ErrList.Add('');
end;
Result := ErrCode;
end;

function FindSubcatch(const ID: String): TSubcatch;
//-----------------------------------------------------------------------------
// Finds a Subcatchment object given its ID name.
//-----------------------------------------------------------------------------
var
Index: Integer;
Atype: Integer;
begin
Result := nil;
if (FileType = ftInput) then
begin
if SubcatchList.Find(ID, Index)
then Result := TSubcatch(SubcatchList.Objects[Index]);
end
else
begin
if (Project.FindSubcatch(ID, Atype, Index))
then Result := Project.GetSubcatch(Atype, Index);
end;
end;

function FindNode(const ID: String): TNode;
//-----------------------------------------------------------------------------
// Finds a Node object given its ID name.
//-----------------------------------------------------------------------------
var
Index: Integer;
Ntype: Integer;
begin
Result := nil;
if (FileType = ftInput) then
begin
if NodeList.Find(ID, Index)
then Result := TNode(NodeList.Objects[Index]);
end
else
begin
if (Project.FindNode(ID, Ntype, Index))
then Result := Project.GetNode(Ntype, Index);
end;
end;

function FindLink(const ID: String): TLink;
//-----------------------------------------------------------------------------
// Finds a Link object given its ID name.
//-----------------------------------------------------------------------------
var
Index : Integer;
Ltype : Integer;
begin
Result := nil;
if (FileType = ftInput) then
begin
if LinkList.Find(ID, Index)
then Result := TLink(LinkList.Objects[Index]);
end
else
begin
if (Project.FindLink(ID, Ltype, Index))
then Result := Project.GetLink(Ltype, Index);
end;
end;

function ReadTitleData(Line: String): Integer;
//-----------------------------------------------------------------------------
// Adds Line of text to a project's title and notes.
//-----------------------------------------------------------------------------
begin
if Project.Lists[NOTES].Count = 0 then Project.Title := Line;
Project.Lists[NOTES].Add(Line);
Project.HasItems[NOTES] := True;
Result := 0;
end;

procedure ReadOldRaingageData(I: Integer; aGage: TRaingage);
//-----------------------------------------------------------------------------
// Reads a line of parsed rain gage data using older format.
//-----------------------------------------------------------------------------
begin
if I = 0 then
begin
aGage.Data[GAGE_DATA_SOURCE] := RaingageOptions[0];
if Ntoks > 2 then aGage.Data[GAGE_SERIES_NAME] := TokList[2];
if Ntoks > 3 then aGage.Data[GAGE_DATA_FORMAT] := TokList[3];
if Ntoks > 4 then aGage.Data[GAGE_DATA_FREQ] := TokList[4];
end;
if I = 1 then
begin
aGage.Data[GAGE_DATA_SOURCE] := RaingageOptions[1];
if Ntoks > 2 then aGage.Data[GAGE_FILE_NAME] := TokList[2];
if Ntoks > 3 then aGage.Data[GAGE_STATION_NUM] := TokList[3];
end;
end;

procedure ReadNewRaingageData(aGage: TRaingage);
//-----------------------------------------------------------------------------
// Reads a line of rain gage data using newer format.
//-----------------------------------------------------------------------------
var
I: Integer;
Fname: String;
begin
if Ntoks > 1 then aGage.Data[GAGE_DATA_FORMAT] := TokList[1];
if Ntoks > 2 then aGage.Data[GAGE_DATA_FREQ] := TokList[2];
if Ntoks > 3 then aGage.Data[GAGE_SNOW_CATCH] := TokList[3];
if Ntoks > 4 then
begin
I := Uutils.FindKeyWord(TokList[4], RaingageOptions, 4);
if I = 0 then
begin
aGage.Data[GAGE_DATA_SOURCE] := RaingageOptions[0];
if Ntoks > 5 then aGage.Data[GAGE_SERIES_NAME] := TokList[5];
end;
if I = 1 then
begin
aGage.Data[GAGE_DATA_SOURCE] := RaingageOptions[1];
if Ntoks > 5 then
begin
Fname := TokList[5];
if ExtractFilePath(Fname) = ''
then Fname := ExtractFilePath(Uglobals.InputFileName) + Fname;
aGage.Data[GAGE_FILE_NAME] := Fname;
end;
if Ntoks > 6 then aGage.Data[GAGE_STATION_NUM] := TokList[6];
if Ntoks > 7 then aGage.Data[GAGE_RAIN_UNITS] := TokList[7];
end;
end;
end;

function ReadRaingageData: Integer;
//-----------------------------------------------------------------------------
// Parses rain gage data from the input line.
//-----------------------------------------------------------------------------
var
aGage : TRaingage;
ID : String;
I : Integer;
begin
if Ntoks < 2 then
begin
Result := ErrMsg(ITEMS_ERR, '');
Exit;
end;
ID := TokList[0];
aGage := TRaingage.Create;
Uutils.CopyStringArray(Project.DefProp[RAINGAGE].Data, aGage.Data);
aGage.X := MISSING;
aGage.Y := MISSING;
aGage.Data[COMMENT_INDEX ] := Comment;
Project.Lists[RAINGAGE].AddObject(ID, aGage);
Project.HasItems[RAINGAGE] := True;
I := Uutils.FindKeyWord(TokList[1], RaingageOptions, 4);
if I >= 0
then ReadOldRaingageData(I, aGage)
else ReadNewRaingageData(aGage);
Result := 0;
end;

function ReadOldHydrographFormat(const I: Integer; UH: THydrograph): Integer;
//-----------------------------------------------------------------------------
// Reads older format of unit hydrograph parameters from a line of input.
//-----------------------------------------------------------------------------
var
J, K, N: Integer;
begin
Result := 0;
if Ntoks < 2 then Result := ErrMsg(ITEMS_ERR, '')
else
begin
N := 2;
for K := 1 to 3 do
begin
for J := 1 to 3 do
begin
UH.Params[I,J,K] := TokList[N];
Inc(N);
end;
end;
for J := 1 to 3 do
begin
UH.InitAbs[I,J,1] := '';
if Ntoks > N then UH.InitAbs[I,J,1] := TokList[N];
Inc(N);
for K := 2 to 3 do UH.InitAbs[I,J,K] := UH.InitAbs[I,J,1];
end;
end;
end;

function ReadHydrographData: Integer;
//-----------------------------------------------------------------------------
// Reads RDII unit hydrograph data from a line of input.
//-----------------------------------------------------------------------------
var
I, J, K: Integer;
ID: String;
aUnitHyd: THydrograph;
Index: Integer;
begin
Result := 0;
if Ntoks < 2 then Result := ErrMsg(ITEMS_ERR, '')
else
begin

// Check if hydrograph ID is same as for previous line
ID := TokList[0];
if (ID = PrevID)
then Index := PrevIndex
else Index := Project.Lists[HYDROGRAPH].IndexOf(ID);

// If starting input for a new hydrograph then create it
if Index < 0 then
begin
aUnitHyd := THydrograph.Create;
Project.Lists[HYDROGRAPH].AddObject(ID, aUnitHyd);
Project.HasItems[HYDROGRAPH] := True;
Index := Project.Lists[HYDROGRAPH].Count - 1;
PrevID := ID;
PrevIndex := Index;
end
else aUnitHyd := THydrograph(Project.Lists[HYDROGRAPH].Objects[Index]);

// Parse rain gage name for 2-token line
if Ntoks = 2 then
begin
aUnitHyd.Raingage := TokList[1];
end

// Extract remaining hydrograph parameters
else if Ntoks < 6 then Result := ErrMsg(ITEMS_ERR, '')
else
begin
// Determine month of year
I := Uutils.FindKeyWord(TokList[1], MonthLabels, 3);
if I < 0 then Result := ErrMsg(KEYWORD_ERR, TokList[1]);

// Determine if response type present - if not, process old format
K := Uutils.FindKeyWord(TokList[2], ResponseTypes, 3) + 1;
if K < 1 then Result := ReadOldHydrographFormat(I, aUnitHyd)
else
begin
// Extract R-T-K values
for J := 3 to 5 do
begin
aUnitHyd.Params[I,J-2,K] := TokList[J];
end;
// Extract IA parameters
for J := 6 to 8 do
begin
if J >= Ntoks then break
else aUnitHyd.InitAbs[I,J-5,K] := TokList[J];
end;
end;
end;
end;
end;

function ReadTemperatureData: Integer;
//-----------------------------------------------------------------------------
// Reads description of air temperature data from a line of input.
//-----------------------------------------------------------------------------
var
I: Integer;
begin
Result := 0;
if Ntoks < 2 then Result := ErrMsg(ITEMS_ERR, '')
else with Project.Climatology do
begin
I := Uutils.FindKeyWord(TokList[0], TempKeywords, 10);
if I < 0 then Result := ErrMsg(KEYWORD_ERR, TokList[0])
else case I of
0: begin // Time series
TempDataSource := 1;
TempTseries := TokList[1];
end;
1: begin // File
TempDataSource := 2;
TempFile := TokList[1];
if ExtractFilePath(TempFile) = '' then
TempFile := ExtractFilePath(Uglobals.InputFileName) + TempFile;
if Ntoks >= 3 then TempStartDate := TokList[2];
end;
2: begin // Wind speed
if SameText(TokList[1], 'MONTHLY') then
begin
if Ntoks < 14 then Result := ErrMsg(ITEMS_ERR, '')
else
begin
WindType := MONTHLY_WINDSPEED;
for I := 1 to 12 do WindSpeed[I] := TokList[I+1];
end;
end
else if SameText(TokList[1], 'FILE') then WindType := FILE_WINDSPEED
else Result := ErrMsg(KEYWORD_ERR, TokList[1]);
end;
3: begin
if Ntoks < 7 then Result := ErrMsg(ITEMS_ERR, '')
else for I := 1 to 6 do SnowMelt[I] := TokList[I];
end;
4: begin
if Ntoks < 12 then Result := ErrMsg(ITEMS_ERR, '')
else
begin
if SameText(TokList[1], 'IMPERVIOUS') then
for I := 1 to 10 do ADCurve[1][I] := TokList[I+1]
else if SameText(TokList[1], 'PERVIOUS') then
for I := 1 to 10 do ADCurve[2][I] := TokList[I+1]
else Result := ErrMsg(KEYWORD_ERR, TokList[1]);
end;
end;
end;
end;
end;

function ReadEvaporationRates(Etype: Integer): Integer;
var
J: Integer;
begin
if (Etype <> TEMP_EVAP) and (Ntoks < 2)
then Result := ErrMsg(ITEMS_ERR, '')

else with Project.Climatology do
begin
EvapType := Etype;

case EvapType of

CONSTANT_EVAP:
for J := 0 to 11 do EvapData[J] := TokList[1];

TSERIES_EVAP:
EvapTseries := TokList[1];

FILE_EVAP:
for J := 1 to 12 do
begin
if J >= Ntoks then break;
PanData[J-1] := TokList[J];
end;

MONTHLY_EVAP:
for J := 1 to 12 do
begin
if J >= Ntoks then break;
EvapData[J-1] := TokList[J];
end;
end;

Result := 0;
end;

end;

function ReadEvaporationData: Integer;
//-----------------------------------------------------------------------------
// Reads evaporation data from a line of input.
//-----------------------------------------------------------------------------
var
I: Integer;
begin
Result := 0;
I := Uutils.FindKeyWord(TokList[0], EvapOptions, 4);
if I >= 0 then Result := ReadEvaporationRates(I)

else if (I <> TEMP_EVAP) and (Ntoks < 2)
then Result := ErrMsg(ITEMS_ERR, '')

else with Project.Climatology do
begin

if SameText(TokList[0], 'RECOVERY')
then RecoveryPat := TokList[1]

else if SameText(TokList[0], 'DRY_ONLY') then
begin
if SameText(TokList[1], 'NO') then EvapDryOnly := False
else if SameText(TokList[1], 'YES') then EvapDryOnly := True
else Result := ErrMsg(KEYWORD_ERR, TokList[1]);
end

else Result := ErrMsg(KEYWORD_ERR, TokList[0]);

end;
end;

function ReadSubcatchmentData: Integer;
//-----------------------------------------------------------------------------
// Reads subcatchment data from a line of input.
//-----------------------------------------------------------------------------
var
S : TSubcatch;
ID : String;
begin
if Ntoks < 8
then Result := ErrMsg(ITEMS_ERR, '')
else begin
ID := TokList[0];
S := TSubcatch.Create;
SubcatchList.AddObject(ID, S);
S.X := MISSING;
S.Y := MISSING;
S.Zindex := -1;
Uutils.CopyStringArray(Project.DefProp[SUBCATCH].Data, S.Data);
S.Data[SUBCATCH_RAINGAGE_INDEX] := TokList[1];
S.Data[SUBCATCH_OUTLET_INDEX] := TokList[2];
S.Data[SUBCATCH_AREA_INDEX] := TokList[3];
S.Data[SUBCATCH_IMPERV_INDEX] := TokList[4];
S.Data[SUBCATCH_WIDTH_INDEX] := TokList[5];
S.Data[SUBCATCH_SLOPE_INDEX] := TokList[6];
S.Data[SUBCATCH_CURBLENGTH_INDEX] := TokList[7];
if Ntoks >= 9
then S.Data[SUBCATCH_SNOWPACK_INDEX] := TokList[8];
S.Data[COMMENT_INDEX ] := Comment;
Project.Lists[SUBCATCH].AddObject(ID, S);
Project.HasItems[SUBCATCH] := True;
Result := 0;
end;
end;

function ReadSubareaData: Integer;
//-----------------------------------------------------------------------------
// Reads subcatchment sub-area data from a line of input.
//-----------------------------------------------------------------------------
var
S : TSubcatch;
ID : String;
begin
if Ntoks < 7
then Result := ErrMsg(ITEMS_ERR, '')
else begin
ID := TokList[0];
S := FindSubcatch(ID);
if S = nil
then Result := ErrMsg(SUBCATCH_ERR, ID)
else begin
S.Data[SUBCATCH_IMPERV_N_INDEX] := TokList[1];
S.Data[SUBCATCH_PERV_N_INDEX] := TokList[2];
S.Data[SUBCATCH_IMPERV_DS_INDEX] := TokList[3];
S.Data[SUBCATCH_PERV_DS_INDEX] := TokList[4];
S.Data[SUBCATCH_PCTZERO_INDEX] := TokList[5];
S.Data[SUBCATCH_ROUTE_TO_INDEX] := TokList[6];
if Ntoks >= 8
then S.Data[SUBCATCH_PCT_ROUTED_INDEX] := TokList[7];
Result := 0;
end;
end;
end;

function ReadInfiltrationData: Integer;
//-----------------------------------------------------------------------------
// Reads subcatchment infiltration data from a line of input.
//-----------------------------------------------------------------------------
var
S : TSubcatch;
ID : String;
J : Integer;
Jmax : Integer;
begin
ID := TokList[0];
S := FindSubcatch(ID);
if S = nil
then Result := ErrMsg(SUBCATCH_ERR, ID)
else begin
Jmax := Ntoks-1;
if Jmax > MAXINFILPROPS then Jmax := MAXINFILPROPS;
for J := 1 to Jmax do S.InfilData[J-1] := TokList[J];
Result := 0;
end;
end;

function ReadAquiferData: Integer;
//-----------------------------------------------------------------------------
// Reads aquifer data from a line of input.
//-----------------------------------------------------------------------------
var
ID : String;
A : TAquifer;
I : Integer;
begin
if nToks < MAXAQUIFERPROPS then Result := ErrMsg(ITEMS_ERR, '') //(5.1.003)
else begin
ID := TokList[0];
A := TAquifer.Create;
//Uutils.CopyStringArray(Project.DefProp[AQUIFER].Data, A.Data); //(5.1.004)
Project.Lists[AQUIFER].AddObject(ID, A);
Project.HasItems[AQUIFER] := True;
for I := 0 to MAXAQUIFERPROPS-1 do A.Data[I] := TokList[I+1]; //(5.1.003)
if nToks >= MAXAQUIFERPROPS + 2 //(5.1.004)
then A.Data[MAXAQUIFERPROPS] := TokList[MAXAQUIFERPROPS+1] //(5.1.003)
else A.Data[MAXAQUIFERPROPS] := ''; //(5.1.003)
Result := 0;
end;
end;

function ReadGroundwaterData: Integer;
//-----------------------------------------------------------------------------
// Reads subcatchment groundwater data from a line of input.
//-----------------------------------------------------------------------------
var
S: TSubcatch;
ID: String;
P: String;
J: Integer;
K: Integer;

begin
// Get subcatchment name
ID := TokList[0];
S := FindSubcatch(ID);
if S = nil
then Result := ErrMsg(SUBCATCH_ERR, ID)
else
begin

// Line contains GW flow parameters
if Ntoks < 10 then Result := ErrMsg(ITEMS_ERR, '')
else begin
S.Groundwater.Clear;

// Read required parameters
for J := 1 to 9 do S.Groundwater.Add(TokList[J]);

// Read optional parameters
for K := 10 to 13 do
begin
if Ntoks > K then
begin
P := TokList[K];
if P = '*' then P := '';
S.Groundwater.Add(P);
end
else S.Groundwater.Add('');
end;
S.Data[SUBCATCH_GWATER_INDEX] := 'YES';
Result := 0;
end;
end;
end;

//// This function was re-written for release 5.1.007. //// //(5.1.007)
function ReadGroundwaterFlowEqn(Line: String): Integer;
//-----------------------------------------------------------------------------
// Reads GW flow math expression from a line of input.
//-----------------------------------------------------------------------------
var
S: TSubcatch;
N: Integer;
begin
// Check for enough tokens in line
if Ntoks < 3 then Result := ErrMsg(ITEMS_ERR, '')
// Get subcatchment object referred to by name
else begin
Result := 0;
S := FindSubcatch(TokList[0]);
if S = nil then Result := ErrMsg(SUBCATCH_ERR, TokList[0])
else begin
// Find position in Line where second token ends
N := Pos(TokList[1], Line) + Length(TokList[1]);
// Save remainder of line to correct type of GW flow equation
if SameText(TokList[1], 'LATERAL') then
S.GwLatFlowEqn := Trim(AnsiRightStr(Line, Length(Line)-N))
else if SameText(TokList[1], 'DEEP') then
S.GwDeepFlowEqn := Trim(AnsiRightStr(Line, Length(Line)-N))
else Result := ErrMsg(KEYWORD_ERR, TokList[1]);
end;
end;
end;

function ReadSnowpackData: Integer;
//-----------------------------------------------------------------------------
// Reads snowpack data from a line of input.
//-----------------------------------------------------------------------------
var
ID : String;
P : TSnowpack;
I : Integer;
J : Integer;
Index: Integer;
begin
Result := 0;
if Ntoks < 8
then Result := ErrMsg(ITEMS_ERR, '')
else begin
I := Uutils.FindKeyWord(TokList[1], SnowpackOptions, 7);
if I < 0
then Result := ErrMsg(KEYWORD_ERR, TokList[1])
else begin

// Check if snow pack ID is same as for previous line
ID := TokList[0];
if (ID = PrevID)
then Index := PrevIndex
else Index := Project.Lists[SNOWPACK].IndexOf(ID);

// If starting input for a new snow pack then create it
if Index < 0 then
begin
P := TSnowpack.Create;
Project.Lists[SNOWPACK].AddObject(ID, P);
Project.HasItems[SNOWPACK] := True;
Index := Project.Lists[SNOWPACK].Count - 1;
PrevID := ID;
PrevIndex := Index;
end
else P := TSnowpack(Project.Lists[SNOWPACK].Objects[Index]);

// Parse line depending on data type
case I of

// Plowable area
0: begin
if Ntoks < 9 then Result := ErrMsg(ITEMS_ERR, '')
else
begin
for J := 1 to 6 do P.Data[1][J] := TokList[J+1];
P.FracPlowable := TokList[8];
end;
end;

// Impervious or Pervious area
1,
2: begin
if Ntoks < 9 then Result := ErrMsg(ITEMS_ERR, '')
else for J := 1 to 7 do P.Data[I+1][J] := TokList[J+1];
end;

// Plowing parameters
3: begin
for J := 1 to 6 do P.Plowing[J] := TokList[J+1];
if Ntoks >= 9 then P.Plowing[7] := TokList[8];
end;
end;
end;
end;
end;

function ReadJunctionData: Integer;
//-----------------------------------------------------------------------------
// Reads junction data from a line of input.
//-----------------------------------------------------------------------------
var
aNode: TNode;
ID : String;
begin
if Ntoks < 2
then Result := ErrMsg(ITEMS_ERR, '')
else begin
ID := TokList[0];
aNode := TNode.Create;
NodeList.AddObject(ID, aNode);
aNode.Ntype := JUNCTION;
aNode.X := MISSING;
aNode.Y := MISSING;
aNode.Zindex := -1;
Uutils.CopyStringArray(Project.DefProp[JUNCTION].Data, aNode.Data);
aNode.Data[NODE_INVERT_INDEX] := TokList[1];
if Ntoks > 2 then aNode.Data[JUNCTION_MAX_DEPTH_INDEX] := TokList[2];
if Ntoks > 3 then aNode.Data[JUNCTION_INIT_DEPTH_INDEX] := TokList[3];
if Ntoks > 4 then aNode.Data[JUNCTION_SURCHARGE_DEPTH_INDEX] := TokList[4];
if Ntoks > 5 then aNode.Data[JUNCTION_PONDED_AREA_INDEX] := TokList[5];
aNode.Data[COMMENT_INDEX ] := Comment;
Project.Lists[JUNCTION].AddObject(ID, aNode);
Project.HasItems[JUNCTION] := True;
Result := 0;
end;
end;

function ReadOutfallData: Integer;
//-----------------------------------------------------------------------------
// Reads outfall data from a line of input.
//-----------------------------------------------------------------------------
var
aNode: TNode;
ID : String;
I : Integer;
N : Integer; //(5.1.008)
begin
if Ntoks < 3
then Result := ErrMsg(ITEMS_ERR, '')
else begin
N := 4; //(5.1.008)
ID := TokList[0];
aNode := TNode.Create;
NodeList.AddObject(ID, aNode);
aNode.Ntype := OUTFALL;
aNode.X := MISSING;
aNode.Y := MISSING;
aNode.Zindex := -1;
Uutils.CopyStringArray(Project.DefProp[OUTFALL].Data, aNode.Data);
aNode.Data[NODE_INVERT_INDEX] := TokList[1];
I := Uutils.FindKeyWord(TokList[2], OutfallOptions, 4);
if I < 0 then I := FREE_OUTFALL;
if (I > NORMAL_OUTFALL) and (Ntoks >= 4) then
begin
case I of
FIXED_OUTFALL: aNode.Data[OUTFALL_FIXED_STAGE_INDEX] := TokList[3];
TIDAL_OUTFALL: aNode.Data[OUTFALL_TIDE_TABLE_INDEX] := TokList[3];
TIMESERIES_OUTFALL: aNode.Data[OUTFALL_TIME_SERIES_INDEX] := TokList[3];
end;
N := 5;
if Ntoks >= 5 then aNode.Data[OUTFALL_TIDE_GATE_INDEX] := TokList[4]; // (5.1.008)
end
else if Ntoks >= 4 then aNode.Data[OUTFALL_TIDE_GATE_INDEX] := TokList[3]; //(5.1.008)
if Ntoks > N then aNode.Data[OUTFALL_ROUTETO_INDEX] := TokList[N]; //(5.1.008)
aNode.Data[OUTFALL_TYPE_INDEX] := OutfallOptions[I];
aNode.Data[COMMENT_INDEX ] := Comment;
Project.Lists[OUTFALL].AddObject(ID, aNode);
Project.HasItems[OUTFALL] := True;
Result := 0;
end;
end;

//// The following function was modified for release 5.1.007. //// //(5.1.007)

function ReadStorageData: Integer;
//-----------------------------------------------------------------------------
// Reads storage unit data from a line of input.
//-----------------------------------------------------------------------------
var
aNode: TNode;
ID : String;
N : Integer;
X : Single;
begin
Result := 0;
N := 6;
if Ntoks < 6
then Result := ErrMsg(ITEMS_ERR, '')
else begin
ID := TokList[0];
aNode := TNode.Create;
NodeList.AddObject(ID, aNode);
aNode.Ntype := STORAGE;
aNode.X := MISSING;
aNode.Y := MISSING;
aNode.Zindex := -1;
Uutils.CopyStringArray(Project.DefProp[STORAGE].Data, aNode.Data);
Project.Lists[STORAGE].AddObject(ID, aNode);
aNode.Data[NODE_INVERT_INDEX] := TokList[1];
aNode.Data[STORAGE_MAX_DEPTH_INDEX] := TokList[2];
aNode.Data[STORAGE_INIT_DEPTH_INDEX] := TokList[3];
aNode.Data[STORAGE_GEOMETRY_INDEX] := TokList[4];
if CompareText(TokList[4], 'TABULAR') = 0 then
begin
aNode.Data[STORAGE_ATABLE_INDEX] := TokList[5];
end
else begin
if Ntoks < 7
then Result := ErrMsg(ITEMS_ERR, '')
else begin
aNode.Data[STORAGE_ACOEFF_INDEX] := TokList[5];
aNode.Data[STORAGE_AEXPON_INDEX] := TokList[6];
if Ntoks >= 8 then aNode.Data[STORAGE_ACONST_INDEX] := TokList[7];
N := 8;
end;
end;

// Optional items
if (Result = 0) and (Ntoks > N) then
begin
// Ponded area
aNode.Data[STORAGE_PONDED_AREA_INDEX] := TokList[N];
// Evaporation factor
if Ntoks > N+1 then aNode.Data[STORAGE_EVAP_FACTOR_INDEX] := TokList[N+1];
// Constant seepage rate
if Ntoks = N+3 then
begin
aNode.InfilData[STORAGE_KSAT_INDEX] := TokList[N+2];
end
// Green-Ampt seepage parameters
else if Ntoks = N+5 then
begin
aNode.InfilData[STORAGE_SUCTION_INDEX] := TokList[N+2];
aNode.InfilData[STORAGE_KSAT_INDEX] := TokList[N+3];
aNode.InfilData[STORAGE_IMDMAX_INDEX] := TokList[N+4];
end;
end;
Uutils.GetSingle(aNode.InfilData[STORAGE_KSAT_INDEX ], X);
if (X > 0) then aNode.Data[STORAGE_SEEPAGE_INDEX] := 'YES'
else aNode.Data[STORAGE_SEEPAGE_INDEX] := 'NO';
aNode.Data[COMMENT_INDEX ] := Comment;
Project.HasItems[STORAGE] := True;
end;
end;

function ReadDividerData: Integer;
//-----------------------------------------------------------------------------
// Reads flow divider data from a line of input.
// (Corrected on 6/14/05)
//-----------------------------------------------------------------------------
var
N, J : Integer;
aNode: TNode;
ID : String;
begin
if Ntoks < 4
then Result := ErrMsg(ITEMS_ERR, '')
else begin
Result := 0;
ID := TokList[0];
aNode := TNode.Create;
NodeList.AddObject(ID, aNode);
aNode.Ntype := DIVIDER;
aNode.X := MISSING;
aNode.Y := MISSING;
aNode.Zindex := -1;
Uutils.CopyStringArray(Project.DefProp[DIVIDER].Data, aNode.Data);
Project.Lists[DIVIDER].AddObject(ID, aNode);
Project.HasItems[DIVIDER] := True;
aNode.Data[COMMENT_INDEX ] := Comment;
aNode.Data[NODE_INVERT_INDEX] := TokList[1];
aNode.Data[DIVIDER_LINK_INDEX] := TokList[2];
aNode.Data[DIVIDER_TYPE_INDEX] := TokList[3];
N := 5;
if SameText(TokList[3], 'OVERFLOW') then
begin
N := 4;
end
else if SameText(TokList[3], 'CUTOFF') then
begin
aNode.Data[DIVIDER_CUTOFF_INDEX] := TokList[4];
end
else if SameText(TokList[3], 'TABULAR') then
begin
aNode.Data[DIVIDER_TABLE_INDEX] := TokList[4];
end
else if SameText(TokList[3], 'WEIR') and (Ntoks >= 7) then
begin
aNode.Data[DIVIDER_QMIN_INDEX] := TokList[4];
aNode.Data[DIVIDER_DMAX_INDEX] := TokList[5];
aNode.Data[DIVIDER_QCOEFF_INDEX] := TokList[6];
N := 7;
end
else Result := ErrMsg(KEYWORD_ERR, TokList[3]);
if (Result = 0) and (Ntoks > N) then
begin
for J := N to Ntoks-1 do
aNode.Data[DIVIDER_MAX_DEPTH_INDEX + J - N] := TokList[J];
end;
end;
end;

function ReadConduitData: Integer;
//-----------------------------------------------------------------------------
// Reads conduit data from a line of input.
//-----------------------------------------------------------------------------
var
aLink : TLink;
aNode1: TNode;
aNode2: TNode;
ID : String;
begin
if Ntoks < 7 then Result := ErrMsg(ITEMS_ERR, '')
else begin
ID := TokList[0];
aNode1 := FindNode(TokList[1]);
aNode2 := FindNode(TokList[2]);
if (aNode1 = nil) then Result := ErrMsg(NODE_ERR, TokList[1])
else if (aNode2 = nil) then Result := ErrMsg(NODE_ERR, TokList[2])
else begin
aLink := TLink.Create;
LinkList.AddObject(ID, aLink);
aLink.Ltype := CONDUIT;
aLink.Node1 := aNode1;
aLink.Node2 := aNode2;
aLink.Zindex := -1;
Uutils.CopyStringArray(Project.DefProp[CONDUIT].Data, aLink.Data);
Project.Lists[CONDUIT].AddObject(ID, aLink);
Project.HasItems[CONDUIT] := True;
aLink.Data[CONDUIT_LENGTH_INDEX] := TokList[3];
aLink.Data[CONDUIT_ROUGHNESS_INDEX] := TokList[4];
aLink.Data[CONDUIT_INLET_HT_INDEX] := TokList[5];
aLink.Data[CONDUIT_OUTLET_HT_INDEX] := TokList[6];
if Ntoks > 7 then aLink.Data[CONDUIT_INIT_FLOW_INDEX] := TokList[7];
if Ntoks > 8 then aLink.Data[CONDUIT_MAX_FLOW_INDEX] := TokList[8];
aLink.Data[COMMENT_INDEX ] := Comment;
Result := 0;
end;
end;
end;

function ReadPumpData: Integer;
//-----------------------------------------------------------------------------
// Reads pump data from a line of input.
//-----------------------------------------------------------------------------
var
aLink : TLink;
aNode1: TNode;
aNode2: TNode;
ID : String;
N : Integer;
begin
if nToks < 4
then Result := ErrMsg(ITEMS_ERR, '')
else begin
ID := TokList[0];
aNode1 := FindNode(TokList[1]);
aNode2 := FindNode(TokList[2]);
if (aNode1 = nil) then Result := ErrMsg(NODE_ERR, TokList[1])
else if (aNode2 = nil) then Result := ErrMsg(NODE_ERR, TokList[2])
else begin
aLink := TLink.Create;
LinkList.AddObject(ID, aLink);
aLink.Ltype := PUMP;
aLink.Node1 := aNode1;
aLink.Node2 := aNode2;
aLink.Zindex := -1;
Uutils.CopyStringArray(Project.DefProp[PUMP].Data, aLink.Data);
Project.Lists[PUMP].AddObject(ID, aLink);
Project.HasItems[PUMP] := True;

// Skip over PumpType if line has old format
if Uutils.FindKeyWord(TokList[3], PumpTypes, 5) >= 0 then N := 4
else N := 3;
if Ntoks <= N then Result := ErrMsg(ITEMS_ERR, '')
else
begin
aLink.Data[PUMP_CURVE_INDEX] := TokList[N];
if nToks > N+1 then aLink.Data[PUMP_STATUS_INDEX] := TokList[N+1];
if nToks > N+2 then aLink.Data[PUMP_STARTUP_INDEX] := TokList[N+2];
if nToks > N+3 then aLink.Data[PUMP_SHUTOFF_INDEX] := TokList[N+3];
aLink.Data[COMMENT_INDEX ] := Comment;
Result := 0;
end;
end;
end;
end;

function ReadOrificeData: Integer;
//-----------------------------------------------------------------------------
// Reads orifice data from a line of input.
//-----------------------------------------------------------------------------
var
aLink : TLink;
aNode1: TNode;
aNode2: TNode;
ID : String;
begin
if nToks < 6
then Result := ErrMsg(ITEMS_ERR, '')
else begin
ID := TokList[0];
aNode1 := FindNode(TokList[1]);
aNode2 := FindNode(TokList[2]);
if (aNode1 = nil) then Result := ErrMsg(NODE_ERR, TokList[1])
else if (aNode2 = nil) then Result := ErrMsg(NODE_ERR, TokList[2])
else begin
aLink := TLink.Create;
LinkList.AddObject(ID, aLink);
aLink.Ltype := ORIFICE;
aLink.Node1 := aNode1;
aLink.Node2 := aNode2;
aLink.Zindex := -1;
Uutils.CopyStringArray(Project.DefProp[ORIFICE].Data, aLink.Data);
Project.Lists[ORIFICE].AddObject(ID, aLink);
Project.HasItems[ORIFICE] := True;
aLink.Data[ORIFICE_TYPE_INDEX] := TokList[3];
aLink.Data[ORIFICE_BOTTOM_HT_INDEX] := TokList[4];
aLink.Data[ORIFICE_COEFF_INDEX] := TokList[5];
if nToks >= 7
then aLink.Data[ORIFICE_FLAPGATE_INDEX] := TokList[6];
if nToks >= 8
then aLink.Data[ORIFICE_ORATE_INDEX] := TokList[7];
aLink.Data[COMMENT_INDEX ] := Comment;
Result := 0;
end;
end;
end;

function ReadWeirData: Integer;
//-----------------------------------------------------------------------------
// Reads weir data from a line of input.
//-----------------------------------------------------------------------------
var
aLink : TLink;
aNode1: TNode;
aNode2: TNode;
ID : String;
begin
if nToks < 6
then Result := ErrMsg(ITEMS_ERR, '')
else begin
ID := TokList[0];
aNode1 := FindNode(TokList[1]);
aNode2 := FindNode(TokList[2]);
if (aNode1 = nil) then Result := ErrMsg(NODE_ERR, TokList[1])
else if (aNode2 = nil) then Result := ErrMsg(NODE_ERR, TokList[2])
else begin
aLink := TLink.Create;
LinkList.AddObject(ID, aLink);
aLink.Ltype := WEIR;
aLink.Node1 := aNode1;
aLink.Node2 := aNode2;
aLink.Zindex := -1;
Uutils.CopyStringArray(Project.DefProp[WEIR].Data, aLink.Data);
Project.Lists[WEIR].AddObject(ID, aLink);
Project.HasItems[WEIR] := True;
aLink.Data[WEIR_TYPE_INDEX] := TokList[3];
aLink.Data[WEIR_CREST_INDEX] := TokList[4];
aLink.Data[WEIR_COEFF_INDEX] := TokList[5];

//// Following section modified for release 5.1.007. //// //(5.1.007)
if (nToks >= 7) and not SameText(TokList[6], '*') then
aLink.Data[WEIR_FLAPGATE_INDEX] := TokList[6];
if (nToks >= 8) and not SameText(TokList[7], '*') then
aLink.Data[WEIR_CONTRACT_INDEX] := TokList[7];
if (nToks >= 9) and not SameText(TokList[8], '*') then
aLink.Data[WEIR_END_COEFF_INDEX] := TokList[8];
if (nToks >= 10) and not SameText(TokList[9], '*') then
aLink.Data[WEIR_SURCHARGE_INDEX] := TokList[9];

//// Following section added for release 5.1.010. //(5.1.010)
if (nToks >= 11) and not SameText(TokList[10], '*') then
aLink.Data[WEIR_ROAD_WIDTH_INDEX] := TokList[10];
if (nToks >= 12) and not SameText(TokList[11], '*') then
aLink.Data[WEIR_ROAD_SURF_INDEX] := TokList[11];
////

aLink.Data[COMMENT_INDEX] := Comment;
Result := 0;
end;
end;
end;

function ReadOutletData: Integer;
//-----------------------------------------------------------------------------
// Reads outlet data from a line of input.
//-----------------------------------------------------------------------------
var
aLink : TLink;
aNode1: TNode;
aNode2: TNode;
ID : String;
N : Integer;
begin
if nToks < 6
then Result := ErrMsg(ITEMS_ERR, '')
else begin
ID := TokList[0];
aNode1 := FindNode(TokList[1]);
aNode2 := FindNode(TokList[2]);
if (aNode1 = nil) then Result := ErrMsg(NODE_ERR, TokList[1])
else if (aNode2 = nil) then Result := ErrMsg(NODE_ERR, TokList[2])
else begin
aLink := TLink.Create;
LinkList.AddObject(ID, aLink);
aLink.Ltype := OUTLET;
aLink.Node1 := aNode1;
aLink.Node2 := aNode2;
aLink.Zindex := -1;
Uutils.CopyStringArray(Project.DefProp[OUTLET].Data, aLink.Data);
Project.Lists[OUTLET].AddObject(ID, aLink);
Project.HasItems[OUTLET] := True;
aLink.Data[OUTLET_CREST_INDEX] := TokList[3];

//... added for backwards compatibility
if SameText(TokList[4], 'TABULAR') then TokList[4] := 'TABULAR/DEPTH';
if SameText(TokList[4], 'FUNCTIONAL') then TokList[4] := 'FUNCTIONAL/DEPTH';
aLink.Data[OUTLET_TYPE_INDEX] := TokList[4];

if AnsiContainsText(TokList[4], 'TABULAR') then
begin
aLink.Data[OUTLET_QTABLE_INDEX] := TokList[5];
N := 6;
end
else begin
if Ntoks < 7 then
begin
Result := ErrMsg(ITEMS_ERR, '');
Exit;
end
else
begin
aLink.Data[OUTLET_QCOEFF_INDEX] := TokList[5];
aLink.Data[OUTLET_QEXPON_INDEX] := TokList[6];
N := 7;
end;
end;
if Ntoks > N then aLink.Data[OUTLET_FLAPGATE_INDEX] := TokList[N];
aLink.Data[COMMENT_INDEX ] := Comment;
Result := 0;
end;
end;
end;

function GetXsectShape(const S: String): Integer;
//-----------------------------------------------------------------------------
// Finds the code number corresponding to cross section shape S.
//-----------------------------------------------------------------------------
var
I: Integer;
begin
for I := 0 to High(Dxsect.XsectShapes) do
begin
if CompareText(S, Dxsect.XsectShapes[I].Text[1]) = 0 then
begin
Result := I;
Exit;
end;
end;
Result := -1;
end;

//// New procedure added to release 5.1.008. //// //(5.1.008)
procedure CheckForStdSize;
//-----------------------------------------------------------------------------
// Converts from old format for standard size ellipse and arch pipes
// to new format.
//-----------------------------------------------------------------------------
var
J: Integer;
X: Extended;
begin
// Old format had size code as 3rd token and 0 for 4th token
J := StrToIntDef(TokList[2], 0);
Uutils.GetExtended(TokList[3], X);
if (J > 0) and (X = 0) then
begin
// New format has 5th token as size code
TokList[4] := TokList[2];
TokList[2] := '0';
TokList[3] := '0';
end;
end;

function ReadXsectionData: Integer;
//-----------------------------------------------------------------------------
// Reads cross section data froma line of input.
//-----------------------------------------------------------------------------
var
I : Integer;
ID : String;
aLink : TLink;
begin
if nToks < 3
then Result := ErrMsg(ITEMS_ERR, '')
else begin
ID := TokList[0];
aLink := FindLink(ID);
if (aLink = nil)
then Result := ErrMsg(LINK_ERR, TokList[0])
else begin
I := GetXsectShape(TokList[1]);
if I < 0 then Result := ErrMsg(KEYWORD_ERR, TokList[1])
else case aLink.Ltype of

CONDUIT:
begin
aLink.Data[CONDUIT_SHAPE_INDEX] := TokList[1];
if I = Dxsect.IRREG_SHAPE_INDEX then
begin
aLink.Data[CONDUIT_TSECT_INDEX] := TokList[2];
aLink.Data[CONDUIT_GEOM1_INDEX] := ''; //(5.1.008)
Result := 0;
end

else begin
if nToks < 6 then Result := ErrMsg(ITEMS_ERR, '')
else begin
{
//// Added to release 5.1.008. //// //(5.1.008)
if I in [Dxsect.HORIZ_ELLIPSE_SHAPE_INDEX,
Dxsect.VERT_ELLIPSE_SHAPE_INDEX,
Dxsect.ARCH_SHAPE_INDEX]
then CheckForStdSize;
}
aLink.Data[CONDUIT_GEOM1_INDEX] := TokList[2];
aLink.Data[CONDUIT_GEOM2_INDEX] := TokList[3];
aLink.Data[CONDUIT_GEOM3_INDEX] := TokList[4];
aLink.Data[CONDUIT_GEOM4_INDEX] := TokList[5];
if Ntoks > 6 then aLink.Data[CONDUIT_BARRELS_INDEX] := TokList[6];
if Ntoks > 7 then aLink.Data[CONDUIT_CULVERT_INDEX] := TokList[7];
if I = Dxsect.CUSTOM_SHAPE_INDEX then
aLink.Data[CONDUIT_TSECT_INDEX] := TokList[3];
Result := 0;
end;
end;
end;

ORIFICE:
begin
if not I in [0, 1] then Result := ErrMsg(XSECT_ERR, TokList[0])
else begin
aLink.Data[ORIFICE_SHAPE_INDEX] := TokList[1];
aLink.Data[ORIFICE_HEIGHT_INDEX] := TokList[2];
aLink.Data[ORIFICE_WIDTH_INDEX] := TokList[3];
Result := 0;
end;
end;

WEIR:
begin
if not I in [2, 3, 4] then Result := ErrMsg(XSECT_ERR, TokList[0])
else begin
aLink.Data[WEIR_SHAPE_INDEX] := TokList[1];
aLink.Data[WEIR_HEIGHT_INDEX] := TokList[2];
aLink.Data[WEIR_WIDTH_INDEX] := TokList[3];
aLink.Data[WEIR_SLOPE_INDEX] := TokList[4];
Result := 0;
end;
end;

else Result := 0;
end;
end;
end;
end;

function ReadTransectData: Integer;
//-----------------------------------------------------------------------------
// Reads transect data from a line of input.
//-----------------------------------------------------------------------------
var
I : Integer;
K : Integer;
N : Integer;
ID : String;
Tsect : TTransect;
begin
Result := 0;
if SameText(TokList[0], 'NC') then
begin
if nToks < 4 then Result := ErrMsg(ITEMS_ERR, '')
else for I := 1 to 3 do ManningsN[I] := TokList[I];
TsectComment := Comment;
Exit;
end;

if SameText(TokList[0], 'X1') then
begin
if nToks < 2 then Exit;
ID := TokList[1];
Tsect := TTransect.Create;

if Length(Comment) > 0 then TsectComment := Comment;
Tsect.Comment := TsectComment;

Project.Lists[TRANSECT].AddObject(ID, Tsect);
Project.HasItems[TRANSECT] := True;
Tsect.Data[TRANSECT_N_LEFT] := ManningsN[1];
Tsect.Data[TRANSECT_N_RIGHT] := ManningsN[2];
Tsect.Data[TRANSECT_N_CHANNEL] := ManningsN[3];
if nToks < 10 then Result := ErrMsg(ITEMS_ERR, '')
else
begin
Tsect.Data[TRANSECT_X_LEFT] := TokList[3];
Tsect.Data[TRANSECT_X_RIGHT] := TokList[4];
Tsect.Data[TRANSECT_L_FACTOR] := TokList[7];
Tsect.Data[TRANSECT_X_FACTOR] := TokList[8];
Tsect.Data[TRANSECT_Y_FACTOR] := TokList[9];
end;
Exit;
end;

if SameText(TokList[0], 'GR') then
begin
N := Project.Lists[TRANSECT].Count;
if N = 0 then Result := ErrMsg(TRANSECT_ERR, '')
else begin
Tsect := TTransect(Project.Lists[TRANSECT].Objects[N-1]);
K := 1;
while K + 1 < Ntoks do
begin
Tsect.Ydata.Add(TokList[K]);
Tsect.Xdata.Add(TokList[K+1]);
K := K + 2;
end;
end;
Exit;
end;
end;

function ReadLossData: Integer;
//-----------------------------------------------------------------------------
// Reads conduit loss data from a line of input.
//-----------------------------------------------------------------------------
var
ID : String;
aLink : TLink;
begin
if nToks < 4
then Result := ErrMsg(ITEMS_ERR, '')
else begin
ID := TokList[0];
aLink := FindLink(ID);
if (aLink = nil) then Result := ErrMsg(LINK_ERR, ID)
else if (aLink.Ltype <> CONDUIT) then Result := 0
else begin
aLink.Data[CONDUIT_ENTRY_LOSS_INDEX] := TokList[1];
aLink.Data[CONDUIT_EXIT_LOSS_INDEX] := TokList[2];
aLink.Data[CONDUIT_AVG_LOSS_INDEX] := TokList[3];
if nToks >= 5
then aLink.Data[CONDUIT_CHECK_VALVE_INDEX] := TokList[4];
if nToks >= 6
then aLink.Data[CONDUIT_SEEPAGE_INDEX] := TokList[5];
Result := 0;
end;
end;
end;

function ReadPollutantData: Integer;
//-----------------------------------------------------------------------------
// Reads pollutant data from a line of input.
//-----------------------------------------------------------------------------
var
ID : String;
aPollut : TPollutant;
X : Single;
begin
if nToks < 5
then Result := ErrMsg(ITEMS_ERR, '')
else begin

// Add new pollutant to project
ID := TokList[0];
aPollut := TPollutant.Create;
Uutils.CopyStringArray(Project.DefProp[POLLUTANT].Data, aPollut.Data);
Project.Lists[POLLUTANT].AddObject(ID, aPollut);
Project.HasItems[POLLUTANT] := True;

// Parse units & concens.
aPollut.Data[POLLUT_UNITS_INDEX] := TokList[1];
aPollut.Data[POLLUT_RAIN_INDEX] := TokList[2];
aPollut.Data[POLLUT_GW_INDEX] := TokList[3];

// This is for old format
if (Ntoks = 5)
or ( (Ntoks = 7) and Uutils.GetSingle(TokList[6], X) ) then
begin
aPollut.Data[POLLUT_DECAY_INDEX] := TokList[4];
if nToks >= 7 then
begin
aPollut.Data[POLLUT_COPOLLUT_INDEX] := TokList[5];
aPollut.Data[POLLUT_FRACTION_INDEX] := TokList[6];
end;
end

// This is for new format
else
begin
aPollut.Data[POLLUT_II_INDEX] := TokList[4];
if Ntoks >= 6 then aPollut.Data[POLLUT_DECAY_INDEX] := TokList[5];
if nToks >= 7 then aPollut.Data[POLLUT_SNOW_INDEX] := TokList[6];
if Ntoks >= 9 then
begin
aPollut.Data[POLLUT_COPOLLUT_INDEX] := TokList[7];
aPollut.Data[POLLUT_FRACTION_INDEX] := TokList[8];
end;
if Ntoks >= 10 then aPollut.Data[POLLUT_DWF_INDEX] := TokList[9];
if Ntoks >= 11 then aPollut.Data[POLLUT_INIT_INDEX] := TokList[10];
end;
Result := 0;
end;
end;

function ReadLanduseData: Integer;
//-----------------------------------------------------------------------------
// Reads land use data from a line of input.
//-----------------------------------------------------------------------------
var
ID : String;
aLanduse : TLanduse;
aNonPtSource : TNonpointSource;
J : Integer;
begin
ID := TokList[0];
aLanduse := TLanduse.Create;
for J := 0 to Project.Lists[POLLUTANT].Count - 1 do
begin
aNonPtSource := TNonpointSource.Create;
aLanduse.NonpointSources.AddObject(Project.Lists[POLLUTANT].Strings[J],
aNonPtSource);
end;
Project.Lists[LANDUSE].AddObject(ID, aLanduse);
Project.HasItems[LANDUSE] := True;
if Ntoks > 1 then aLanduse.Data[LANDUSE_CLEANING_INDEX] := TokList[1];
if Ntoks > 2 then aLanduse.Data[LANDUSE_AVAILABLE_INDEX] := TokList[2];
if Ntoks > 3 then aLanduse.Data[LANDUSE_LASTCLEAN_INDEX] := TokList[3];
aLanduse.Data[COMMENT_INDEX ] := Comment;
Result := 0;
end;

function ReadBuildupData: Integer;
//-----------------------------------------------------------------------------
// Reads pollutant buildup function data from a line of input.
//-----------------------------------------------------------------------------
var
LanduseIndex : Integer;
PollutIndex : Integer;
aLanduse : TLanduse;
aNonpointSource: TNonpointSource;
J : Integer;
begin
if nToks < 7
then Result := ErrMsg(ITEMS_ERR, '')
else begin
LanduseIndex := Project.Lists[LANDUSE].IndexOf(TokList[0]);
PollutIndex := Project.Lists[POLLUTANT].IndexOf(TokList[1]);
if (LanduseIndex < 0) then Result := ErrMsg(LANDUSE_ERR, TokList[0])
else if (PollutIndex < 0) then Result := ErrMsg(POLLUT_ERR, TokList[1])
else begin
aLanduse := TLanduse(Project.Lists[LANDUSE].Objects[LanduseIndex]);
aNonpointSource :=
TNonpointSource(aLanduse.NonpointSources.Objects[PollutIndex]);
for J := 2 to 6 do
aNonpointSource.BuildupData[J-2] := TokList[J];
Result := 0;
end;
end;
end;

function ReadWashoffData: Integer;
//-----------------------------------------------------------------------------
// Reads pollutant washoff function data from a line of input.
//-----------------------------------------------------------------------------
var
LanduseIndex : Integer;
PollutIndex : Integer;
aLanduse : TLanduse;
aNonpointSource: TNonpointSource;
J : Integer;
begin
if nToks < 7
then Result := ErrMsg(ITEMS_ERR, '')
else begin
LanduseIndex := Project.Lists[LANDUSE].IndexOf(TokList[0]);
PollutIndex := Project.Lists[POLLUTANT].IndexOf(TokList[1]);
if (LanduseIndex < 0) then Result := ErrMsg(LANDUSE_ERR, TokList[0])
else if (PollutIndex < 0) then Result := ErrMsg(POLLUT_ERR, TokList[1])
else begin
aLanduse := TLanduse(Project.Lists[LANDUSE].Objects[LanduseIndex]);
aNonpointSource :=
TNonpointSource(aLanduse.NonpointSources.Objects[PollutIndex]);
for J := 2 to 6 do
aNonpointSource.WashoffData[J-2] := TokList[J];
Result := 0;
end;
end;
end;

function ReadCoverageData: Integer;
//-----------------------------------------------------------------------------
// Reads land use coverage data from a line of input.
//-----------------------------------------------------------------------------
var
MaxToks: Integer;
X : Single;
S : TSubcatch;
S1 : String;
I : Integer;
begin
Result := 0;
S := FindSubcatch(TokList[0]);
if S = nil
then Result := ErrMsg(SUBCATCH_ERR, TokList[0])
else begin
MaxToks := 3;
while (MaxToks <= nToks) do
begin
if not Uutils.GetSingle(TokList[MaxToks-1], X) then
begin
Result := ErrMsg(NUMBER_ERR, TokList[MaxToks-1]);
break;
end;
S1 := TokList[MaxToks-2];
I := S.LandUses.IndexOfName(S1);
S1 := TokList[MaxToks-2] + '=' + TokList[MaxToks-1];
if I < 0
then S.LandUses.Add(S1)
else S.Landuses[I] := S1;
MaxToks := MaxToks + 2;
end;
S.Data[SUBCATCH_LANDUSE_INDEX] := IntToStr(S.LandUses.Count);
end;
end;

function ReadTreatmentData(Line: String): Integer;
//-----------------------------------------------------------------------------
// Reads pollutant treatment function from a line of input.
//-----------------------------------------------------------------------------
var
S : String;
aNode : TNode;
I : Integer;
begin
if Ntoks < 3
then Result := ErrMsg(ITEMS_ERR, '')
else begin
aNode := FindNode(TokList[0]);
if (aNode = nil) then Result := ErrMsg(NODE_ERR, TokList[0])
else if Project.Lists[POLLUTANT].IndexOf(TokList[1]) < 0 then
Result := ErrMsg(POLLUT_ERR, TokList[1])
else begin
I := aNode.Treatment.IndexOfName(TokList[1]);
S := Copy(Line, Pos(TokList[1], Line)+Length(TokList[1]), Length(Line));
S := TokList[1] + '=' + Trim(S);
if I < 0 then
aNode.Treatment.Add(S)
else
aNode.Treatment[I] := S;
aNode.Data[NODE_TREAT_INDEX] := 'YES';
Result := 0;
end;
end;
end;

function ReadExInflowData: Integer;
//-----------------------------------------------------------------------------
// Reads external inflow data from a line of input.
//-----------------------------------------------------------------------------
var
S : array[1..7] of String;
Inflow: String;
I : Integer;
aNode : TNode;
begin

if Ntoks < 3
then Result := ErrMsg(ITEMS_ERR, '')
else begin
aNode := FindNode(TokList[0]);
if (aNode = nil) then Result := ErrMsg(NODE_ERR, TokList[0])
else begin
S[1] := TokList[1]; // Constituent name
S[2] := TokList[2]; // Time Series name
S[3] := 'FLOW';
S[4] := '1.0';
if not SameText(S[1], 'FLOW') then
begin
if nToks >= 4 then S[3] := TokList[3] else S[3] := 'CONCEN';
if nToks >= 5 then S[4] := TokList[4] else S[4] := '1.0';
end;
if nToks >= 6 then S[5] := TokList[5] else S[5] := '1.0';
if nToks >= 7 then S[6] := TokList[6] else S[6] := '';
if nToks >= 8 then S[7] := TokList[7] else S[7] := '';
Inflow := S[1] + '=' + S[2] + #13 + S[3] + #13 + S[4] + #13 +
S[5] + #13 + S[6] + #13 + S[7];
I := aNode.DXInflow.IndexOfName(S[1]);
if I < 0 then aNode.DXInflow.Add(Inflow)
else aNode.DXInflow[I] := Inflow;
aNode.Data[NODE_INFLOWS_INDEX] := 'YES';
Result := 0;
end;
end;
end;

function ReadDWInflowData: Integer;
//-----------------------------------------------------------------------------
// Reads dry weather inflow data from a line of input.
//-----------------------------------------------------------------------------
var
M : Integer;
S : String;
S1 : String;
I : Integer;
aNode: TNode;
begin
if Ntoks < 3
then Result := ErrMsg(ITEMS_ERR, '')
else begin
aNode := FindNode(TokList[0]);
if (aNode = nil) then Result := ErrMsg(NODE_ERR, TokList[0])
else begin
S1 := TokList[1];
S := S1 + '=' + TokList[2];
for M := 3 to Ntoks-1 do S := S + #13 + TokList[M];
I := aNode.DWInflow.IndexOfName(S1);
if I < 0
then aNode.DWInflow.Add(S)
else aNode.DWInflow[I] := S;
aNode.Data[NODE_INFLOWS_INDEX] := 'YES';
Result := 0;
end;
end;
end;

function ReadPatternData: Integer;
//-----------------------------------------------------------------------------
// Reads time pattern data from a line of input.
//-----------------------------------------------------------------------------
var
ID: String;
Index: Integer;
aPattern: TPattern;
PatType: Integer;
J: Integer;
begin
if nToks < 2
then Result := ErrMsg(ITEMS_ERR, '')
else begin
J := 1;
ID := TokList[0];
Index := Project.Lists[PATTERN].IndexOf(ID);
if Index < 0 then
begin
aPattern := TPattern.Create;
aPattern.Comment := Comment;
Project.Lists[PATTERN].AddObject(ID, aPattern);
Project.HasItems[PATTERN] := True;
PatType := Uutils.FindKeyWord(TokList[1], PatternTypes, 7);
if PatType < 0 then
begin
Result := ErrMsg(KEYWORD_ERR, TokList[1]);
exit;
end;
aPattern.PatternType := PatType;
J := 2;
end
else aPattern := TPattern(Project.Lists[PATTERN].Objects[Index]);
while (J < nToks) and (aPattern.Count <= High(aPattern.Data)) do
begin
aPattern.Data[aPattern.Count] := TokList[J];
Inc(J);
Inc(aPattern.Count);
end;
Result := 0;
end;
end;

function ReadIIInflowData: Integer;
//-----------------------------------------------------------------------------
// Reads RDII inflow data from a line of input.
//-----------------------------------------------------------------------------
var
aNode: TNode;

begin
if Ntoks < 3
then Result := ErrMsg(ITEMS_ERR, '')
else begin
aNode := FindNode(TokList[0]);
if (aNode = nil) then Result := ErrMsg(NODE_ERR, TokList[0])
else begin
aNode.IIInflow.Clear;
aNode.IIInflow.Add(TokList[1]);
aNode.IIInflow.Add(TokList[2]);
aNode.Data[NODE_INFLOWS_INDEX] := 'YES';
Result := 0;
end;
end;
end;

function ReadLoadData: Integer;
//-----------------------------------------------------------------------------
// Reads initial pollutant loading data from a line of input.
//-----------------------------------------------------------------------------
var
X : Single;
S : TSubcatch;
S1 : String;
I : Integer;

begin
S := FindSubcatch(TokList[0]);
if S = nil
then Result := ErrMsg(SUBCATCH_ERR, TokList[0])
else if Project.Lists[POLLUTANT].IndexOf(TokList[1]) < 0
then Result := ErrMsg(POLLUT_ERR, TokList[1])
else if not Uutils.GetSingle(TokList[2], X)
then Result := ErrMsg(NUMBER_ERR, TokList[2])
else
begin
S1 := TokList[1] + '=' + TokList[2];
I := S.Loadings.IndexOfName(TokList[1]);
if I < 0
then S.Loadings.Add(S1)
else S.Loadings[I] := S1;
S.Data[SUBCATCH_LOADING_INDEX] := 'YES';
Result := 0;
end;
end;

function ReadCurveData: Integer;
//-----------------------------------------------------------------------------
// Reads curve data from a line of input.
//-----------------------------------------------------------------------------
var
Index : Integer;
K : Integer;
L : Integer;
M : Integer;
ObjType : Integer;
ID : String;
aCurve : TCurve;
begin
// Check for too few tokens
if Ntoks < 3
then Result := ErrMsg(ITEMS_ERR, '')
else begin

// Check if curve ID is same as for previous line
ID := TokList[0];
if (ID = PrevID) then
begin
Index := PrevIndex;
ObjType := CurveType;
end
else Project.FindCurve(ID, ObjType, Index);

// Create new curve if ID not in data base
K := 2;
if Index < 0 then
begin

// Check for valid curve type keyword
M := -1;
for L := 0 to High(CurveTypeOptions) do
begin
if SameText(TokList[1], CurveTypeOptions[L]) then
begin
M := L;
break;
end;
end;
if M < 0 then
begin
Result := ErrMsg(KEYWORD_ERR, TokList[1]);
Exit;
end;

// Convert curve type keyword index to a curve object category
case M of
0: ObjType := CONTROLCURVE;
1: ObjType := DIVERSIONCURVE;
2..5:
ObjType := PUMPCURVE;
6: ObjType := RATINGCURVE;
7: ObjType := SHAPECURVE;
8: ObjType := STORAGECURVE;
9: ObjType := TIDALCURVE;
end;

// Create a new curve object
aCurve := TCurve.Create;
aCurve.Comment := Comment;
aCurve.CurveType := TokList[1];
if ObjType = PUMPCURVE
then aCurve.CurveCode := M - 1
else aCurve.CurveCode := 0;
Project.Lists[ObjType].AddObject(ID, aCurve);
Project.HasItems[ObjType] := True;
Index := Project.Lists[ObjType].Count - 1;
PrevID := ID;
PrevIndex := Index;
CurveType := ObjType;
K := 3;
end;

// Add x,y values to the list maintained by the curve
aCurve := TCurve(Project.Lists[ObjType].Objects[Index]);
while K <= nToks-1 do
begin
aCurve.Xdata.Add(TokList[K-1]);
aCurve.Ydata.Add(TokList[K]);
K := K + 2;
end;
Result := 0;
end;
end;

function ReadTimeseriesData: Integer;
//-----------------------------------------------------------------------------
// Reads time series data from a line of input.
//-----------------------------------------------------------------------------
const
NEEDS_DATE = 1;
NEEDS_TIME = 2;
NEEDS_VALUE = 3;
var
Index : Integer;
State : Integer;
K : Integer;
ID : String;
StrDate : String;
aTseries : TTimeseries;
begin
// Check for too few tokens
Result := -1;
if Ntoks < 3 then Result := ErrMsg(ITEMS_ERR, '');

// Check if series ID is same as for previous line
ID := TokList[0];
if (ID = PrevID) then Index := PrevIndex
else Index := Project.Lists[TIMESERIES].IndexOf(ID);

// If starting input for a new series then create it
if Index < 0 then
begin
aTseries := TTimeseries.Create;
aTseries.Comment := Comment;
Project.Lists[TIMESERIES].AddObject(ID,aTseries);
Project.HasItems[TIMESERIES] := True;
Index := Project.Lists[TIMESERIES].Count - 1;
PrevID := ID;
PrevIndex := Index;
end;
aTseries := TTimeseries(Project.Lists[TIMESERIES].Objects[Index]);

// Check if external file name used
if SameText(TokList[1], 'FILE') then
begin
aTseries.Filename := TokList[2];
Result := 0;
Exit;
end;

// Add values to the list maintained by the timeseries
State := NEEDS_DATE;
K := 1;
while K < nToks do
begin
case State of

NEEDS_DATE:
begin
try
StrDate := Uutils.ConvertDate(TokList[K]);
StrToDate(StrDate, MyFormatSettings);
aTseries.Dates.Add(StrDate);
Inc(K);
if K >= nToks then break;
except
On EconvertError do aTseries.Dates.Add('');
end;
State := NEEDS_TIME;
end;

NEEDS_TIME:
begin
aTseries.Times.Add(TokList[K]);
Inc(K);
if K >= nToks then break;
State := NEEDS_VALUE;
end;

NEEDS_VALUE:
begin
aTseries.Values.Add(TokList[K]);
Result := 0;
State := NEEDS_DATE;
Inc(K);
end;
end;
end;
if Result = -1 then Result := ErrMsg(ITEMS_ERR, '');
end;

function ReadControlData(Line: String): Integer;
//-----------------------------------------------------------------------------
// Reads a control rule statement from line of input.
//-----------------------------------------------------------------------------
begin
Project.ControlRules.Add(Line);
Result := 0;
end;

function ReadLidUsageData: Integer;
//-----------------------------------------------------------------------------
// Reads LID usage data from line of input.
//-----------------------------------------------------------------------------
var
aSubcatch: TSubcatch;
begin
aSubcatch := FindSubcatch(TokList[0]);
if aSubcatch = nil then Result := ErrMsg(SUBCATCH_ERR, TokList[0])
else Result := Ulid.ReadLIDUsageData(aSubcatch, TokList, Ntoks);
end;

procedure ReadReportOption(Index: Integer);
begin
if (Ntoks >= 2) and SameText(TokList[1], 'YES') then
Project.Options.Data[Index] := 'YES'
else
Project.Options.Data[Index] := 'NO';
end;

function ReadReportData: Integer;
//-----------------------------------------------------------------------------
// Reads reporting options from a line of input.
//-----------------------------------------------------------------------------
begin
if SameText(TokList[0], 'CONTROLS')
then ReadReportOption(REPORT_CONTROLS_INDEX)
else if SameText(TokList[0], 'INPUT')
then ReadReportOption(REPORT_INPUT_INDEX)
else ReportingForm.Import(TokList, Ntoks);
Result := 0;
end;

function ReadFileData: Integer;
//-----------------------------------------------------------------------------
// Reads interface file usage from a line of input.
//-----------------------------------------------------------------------------
var
Fname: String;
begin
if Ntoks < 3
then Result := ErrMsg(ITEMS_ERR, '')
else begin
Fname := TokList[2];
if ExtractFilePath(Fname) = ''
then Fname := ExtractFilePath(Uglobals.InputFileName) + Fname;
Project.IfaceFiles.Add(TokList[0] + ' ' + TokList[1] + ' ' +
'"' + Fname + '"');
Result := 0;
end;
end;

//// This function was added to release 5.1.007. //// //(5.1.007)
function ReadAdjustmentData: Integer;
//-----------------------------------------------------------------------------
// Reads climate adjustments from a line of input.
//-----------------------------------------------------------------------------
var
I: Integer;
begin
Result := 0;
if Ntoks < 2 then exit;
if SameText(TokList[0], 'Temperature') then
begin
if Ntoks < 13 then Result := ErrMsg(ITEMS_ERR, '')
else with Project.Climatology do
begin
for I := 0 to 11 do
if StrToFloatDef(TokList[I+1], 0.0) = 0.0
then TempAdjust[I] := ''
else TempAdjust[I] := TokList[I+1];
end;
end
else if SameText(TokList[0], 'Evaporation') then
begin
if Ntoks < 13 then Result := ErrMsg(ITEMS_ERR, '')
else with Project.Climatology do
begin
for I := 0 to 11 do
if StrToFloatDef(TokList[I+1], 0.0) = 0.0
then EvapAdjust[I] := ''
else EvapAdjust[I] := TokList[I+1];
end;
end
else if SameText(TokList[0], 'Rainfall') then
begin
if Ntoks < 13 then Result := ErrMsg(ITEMS_ERR, '')
else with Project.Climatology do
begin
for I := 0 to 11 do
if StrToFloatDef(TokList[I+1], 1.0) = 1.0
then RainAdjust[I] := ''
else RainAdjust[I] := TokList[I+1];
end;
end

//// Added to release 5.1.008. //// //(5.1.008)
else if SameText(TokList[0], 'Conductivity') then
begin
if Ntoks < 13 then Result := ErrMsg(ITEMS_ERR, '')
else with Project.Climatology do
begin
for I := 0 to 11 do
if StrToFloatDef(TokList[I+1], 1.0) = 1.0
then CondAdjust[I] := ''
else CondAdjust[I] := TokList[I+1];
end;
end;
////////////////////////////////////////////////////////
end;

//// This function was added to release 5.1.011. //// //(5.1.011)
function ReadEventData(Line: String): Integer;
//-----------------------------------------------------------------------------
// Reads hydraulic event data from a line of input.
//-----------------------------------------------------------------------------
begin
Result := 0;
if Length(Line) = 0 then exit;
if LeftStr(Line,2) = ';;' then exit;
Project.Events.Add(Line);
end;

function ReadOptionData: Integer;
//-----------------------------------------------------------------------------
// Reads an analysis option from a line of input.
//-----------------------------------------------------------------------------
var
Index : Integer;
Keyword : String;
S : String;
S2: String;
I : Integer;
X : Single;
T : Extended;
begin
// Check which keyword applies
Result := 0;
if Ntoks < 2 then exit;
Keyword := TokList[0];
if SameText(Keyword, 'TEMPDIR') then exit;
Index := Uutils.FindKeyWord(Keyword, OptionLabels, 17);
case Index of

-1: Result := ErrMsg(KEYWORD_ERR, Keyword);

ROUTING_MODEL_INDEX:
begin
if SameText(TokList[1], 'NONE') then
begin
Project.Options.Data[IGNORE_ROUTING_INDEX] := 'YES';
Exit;
end;

I := Uutils.FindKeyWord(TokList[1], OldRoutingOptions, 3);
if I >= 0 then TokList[1] := RoutingOptions[I];
end;

START_DATE_INDEX, REPORT_START_DATE_INDEX, END_DATE_INDEX:
begin
S := Uutils.ConvertDate(TokList[1]);
try
StrToDate(S, MyFormatSettings);
TokList[1] := S;
except
on EConvertError do Result := ErrMsg(DATE_ERR, '');
end;
end;

START_TIME_INDEX, REPORT_START_TIME_INDEX, END_TIME_INDEX:
begin
S := TokList[1];
try
StrToTime(S, MyFormatSettings);
TokList[1] := S;
except
on EConvertError do Result := ErrMsg(DATE_ERR, '');
end;
end;

SWEEP_START_INDEX, SWEEP_END_INDEX:
begin
S := Uutils.ConvertDate(TokList[1]);
S2 := S + '/1947';
try
StrToDate(S2, MyFormatSettings);
TokList[1] := S;
except
on EConvertError do Result := ErrMsg(DATE_ERR, '');
end;
end;

WET_STEP_INDEX, DRY_STEP_INDEX, REPORT_STEP_INDEX:
begin
S := TokList[1];
if Uutils.StrHoursToTime(S) = -1 then Result := ErrMsg(TIMESTEP_ERR, '');
end;

ROUTING_STEP_INDEX:
begin
S := TokList[1];
T := 0.0;
if not Uutils.GetExtended(S, T) then
begin
T := Uutils.StrHoursToTime(S)*86400.;
if T <= 0.0 then Result := ErrMsg(TIMESTEP_ERR, '')
else TokList[1] := Format('%.0f',[T]);
end;
end;

VARIABLE_STEP_INDEX:
begin
if Uutils.GetSingle(TokList[1], X) then
TokList[1] := IntToStr(Round(100.0*X))
else
TokList[1] := '0';
end;

INERTIAL_DAMPING_INDEX:
begin
if Uutils.GetSingle(TokList[1], X) then
begin
if X = 0 then TokList[1] := 'NONE'
else TokList[1] := 'PARTIAL';
end;
end;

// This option is now fixed to SWMM 4.
COMPATIBILITY_INDEX:
begin
TokList[1] := '4';
end;

MIN_ROUTE_STEP_INDEX, //(5.1.008)
LENGTHEN_STEP_INDEX,
MIN_SURFAREA_INDEX,
MIN_SLOPE_INDEX,
MAX_TRIALS_INDEX,
HEAD_TOL_INDEX,
SYS_FLOW_TOL_INDEX,
LAT_FLOW_TOL_INDEX:
begin
Uutils.GetSingle(TokList[1], X);
if X <= 0 then TokList[1] := '0';
end;

NORMAL_FLOW_LTD_INDEX:
begin
if SameText(TokList[1], 'NO') or SameText(TokList[1], 'SLOPE')
then TokList[1] := 'SLOPE'
else if SameText(TokList[1], 'YES') or SameText(TokList[1], 'FROUDE')
then TokList[1] := 'FROUDE'
else if SameText(TokList[1], 'BOTH') then TokList[1] := 'BOTH'
else Result := ErrMsg(KEYWORD_ERR, TokList[1]);
end;

FORCE_MAIN_EQN_INDEX:
begin
I := Uutils.FindKeyWord(TokList[1], ForceMainEqnOptions, 3);
if I < 0 then Result := ErrMsg(KEYWORD_ERR, TokList[1])
else TokList[1] := ForceMainEqnOptions[I];
end;

LINK_OFFSETS_INDEX:
begin
I := Uutils.FindKeyWord(TokList[1], LinkOffsetsOptions, 10);
if I < 0 then Result := ErrMsg(KEYWORD_ERR, TokList[1])
else TokList[1] := LinkOffsetsOptions[I];
end;

IGNORE_RAINFALL_INDEX,
IGNORE_SNOWMELT_INDEX,
IGNORE_GRNDWTR_INDEX,
IGNORE_ROUTING_INDEX,
IGNORE_QUALITY_INDEX:
begin
if not SameText(TokList[1], 'YES') and not SameText(TokList[1], 'NO')
then Result := ErrMsg(KEYWORD_ERR, TokList[1]);
end;

//// Following section added to release 5.1.010. //// //(5.1.010)
NUM_THREADS_INDEX:
begin
I := StrToIntDef(TokList[1], 1);
if I < 0 then I := 1;
if (I = 0) or (I > Uutils.GetCPUs) then I := Uutils.GetCPUs;
TokList[1] := IntToStr(I);
end;
////

end;
if Result = 0 then Project.Options.Data[Index] := TokList[1];
end;

function ReadTagData: Integer;
//-----------------------------------------------------------------------------
// Reads in tag data from a line of input.
//-----------------------------------------------------------------------------
const
TagTypes: array[0..3] of PChar = ('Gage', 'Subcatch', 'Node', 'Link');
var
I, J : Integer;
aNode: TNode;
aLink: TLink;
begin
Result := 0;
if Ntoks < 3
then Result := ErrMsg(ITEMS_ERR, '')
else begin
I := Uutils.FindKeyWord(TokList[0], TagTypes, 4);
case I of

-1: Result := ErrMsg(KEYWORD_ERR, TokList[0]);

0: begin
J := Project.Lists[RAINGAGE].IndexOf(TokList[1]);
if J >= 0 then with Project.GetGage(J) do Data[TAG_INDEX] := TokList[2];
end;

1: begin
J := Project.Lists[SUBCATCH].IndexOf(TokList[1]);
if J >= 0 then with Project.GetSubcatch(SUBCATCH, J) do
Data[TAG_INDEX] := TokList[2];
end;

2: begin
aNode := FindNode(TokList[1]);
if (aNode <> nil) then aNode.Data[TAG_INDEX] := TokList[2];
end;

3: begin
aLink := FindLink(TokList[1]);
if (aLink <> nil) then aLink.Data[TAG_INDEX] := TokList[2];
end;
end;
end;
end;

function ReadSymbolData: Integer;
//-----------------------------------------------------------------------------
// Reads rain gage coordinate data from a line of input.
//-----------------------------------------------------------------------------
var
J : Integer;
X, Y : Extended;
aGage : TRaingage;
begin
Result := 0;
if (Ntoks < 3)
then Result := ErrMsg(ITEMS_ERR, '')
else begin

// Locate the gage ID in the database
J := Project.Lists[RAINGAGE].IndexOf(TokList[0]);

// If gage exists then assign it X & Y coordinates
if (J >= 0) then
begin
aGage := Project.GetGage(J);
if not Uutils.GetExtended(TokList[1], X) then
Result := ErrMsg(NUMBER_ERR, TokList[1])
else if not Uutils.GetExtended(TokList[2], Y) then
Result := ErrMsg(NUMBER_ERR, TokList[2])
else
begin
aGage.X := X;
aGage.Y := Y;
end;
end;
end;
end;

function ReadMapData: Integer;
//-----------------------------------------------------------------------------
// Reads map dimensions data from a line of input.
//-----------------------------------------------------------------------------
var
I : Integer;
Index : Integer;
Keyword : String;
X : array[1..4] of Extended;
begin
// Check which keyword applies
Result := 0;
Keyword := TokList[0];
Index := Uutils.FindKeyWord(Keyword, MapWords, 4);
case Index of

0: // Map dimensions
begin
if Ntoks < 5 then Result := ErrMsg(ITEMS_ERR, '')
else begin
for I := 1 to 4 do
if not Uutils.GetExtended(TokList[I], X[I]) then
Result := ErrMsg(NUMBER_ERR, TokList[I]);
if Result = 0 then with MapForm.Map.Dimensions do
begin
LowerLeft.X := X[1];
LowerLeft.Y := X[2];
UpperRight.X := X[3];
UpperRight.Y := X[4];
MapExtentSet := True;
end;
end;
end;

1: //Map units
if Ntoks > 1 then
begin
I := Uutils.FindKeyWord(Copy(TokList[1], 1, 1), MapUnits, 1);
if I < 0 then Result := ErrMsg(KEYWORD_ERR, TokList[1])
else MapForm.Map.Dimensions.Units := TMapUnits(I);
with MapForm.Map.Dimensions do
begin
if Units = muDegrees then Digits := MAXDEGDIGITS
else Digits := Umap.DefMapDimensions.Digits;
end;
end;

else Result := ErrMsg(KEYWORD_ERR, Keyword);
end;
end;

function ReadCoordData: Integer;
//-----------------------------------------------------------------------------
// Reads node coordinate data from a line of input.
//-----------------------------------------------------------------------------
var
X, Y : Extended;
aNode : TNode;
begin
Result := 0;
if (Ntoks < 3)
then Result := ErrMsg(ITEMS_ERR, '')
else begin

// Locate the node ID in the database
aNode := FindNode(TokList[0]);

// If node exists then assign it X & Y coordinates
if (aNode <> nil) then
begin
if not Uutils.GetExtended(TokList[1], X) then
Result := ErrMsg(NUMBER_ERR, TokList[1])
else if not Uutils.GetExtended(TokList[2], Y) then
Result := ErrMsg(NUMBER_ERR, TokList[2])
else
begin
aNode.X := X;
aNode.Y := Y;
end;
end;
end;
end;

function ReadVertexData: Integer;
//-----------------------------------------------------------------------------
// Reads link vertex coordinate data from a line of input.
//-----------------------------------------------------------------------------
var
X, Y : Extended;
aLink : TLink;

begin
Result := 0;
if (Ntoks < 3)
then Result := ErrMsg(ITEMS_ERR, '')
else begin

// Locate the link ID in the database
aLink := FindLink(TokList[0]);;

// If link exists then assign it X & Y coordinates
if (aLink <> nil) then
begin
if not Uutils.GetExtended(TokList[1], X) then
Result := ErrMsg(NUMBER_ERR, TokList[1])
else if not Uutils.GetExtended(TokList[2], Y) then
Result := ErrMsg(NUMBER_ERR, TokList[2])
else aLink.Vlist.Add(X, Y);
end;
end;
end;

function ReadPolygonData: Integer;
//-----------------------------------------------------------------------------
// Reads polygon coordinates associated with subcatchment outlines.
//-----------------------------------------------------------------------------
var
Index : Integer;
X, Y : Extended;
S : TSubcatch;
begin
Result := 0;
if (Ntoks < 3)
then Result := ErrMsg(ITEMS_ERR, '')
else begin

// Locate the subcatchment ID in the database
S := nil;
Index := Project.Lists[SUBCATCH].IndexOf(TokList[0]);
if Index >= 0 then S := Project.GetSubcatch(SUBCATCH, Index);

// If subcatchment exists then add a new vertex to it
if (S <> nil) then
begin
if not Uutils.GetExtended(TokList[1], X) then
Result := ErrMsg(NUMBER_ERR, TokList[1])
else if not Uutils.GetExtended(TokList[2], Y) then
Result := ErrMsg(NUMBER_ERR, TokList[2])
else S.Vlist.Add(X, Y);
end;
end;
end;

function ReadLabelData: Integer;
//-----------------------------------------------------------------------------
// Reads map label data from a line of input.
//-----------------------------------------------------------------------------
var
Ntype : Integer;
Index : Integer;
X, Y : Extended;
S : String;
aMapLabel: TMapLabel;
begin
if (Ntoks < 3)
then Result := ErrMsg(ITEMS_ERR, '')
else begin
if not Uutils.GetExtended(TokList[0], X) then
Result := ErrMsg(NUMBER_ERR, TokList[0])
else if not Uutils.GetExtended(TokList[1], Y) then
Result := ErrMsg(NUMBER_ERR, TokList[1])
else begin
S := TokList[2];
aMapLabel := TMapLabel.Create;
aMapLabel.X := X;
aMapLabel.Y := Y;
Project.Lists[MAPLABEL].AddObject(S, aMapLabel);
Index := Project.Lists[MAPLABEL].Count - 1;
aMapLabel.Text := PChar(Project.Lists[MAPLABEL].Strings[Index]);
Project.HasItems[MAPLABEL] := True;
if Ntoks >= 4 then
begin
if (Length(TokList[3]) > 0) and
Project.FindNode(TokList[3], Ntype, Index) then
aMapLabel.Anchor := Project.GetNode(Ntype, Index);
end;
if Ntoks >= 5 then aMapLabel.FontName := TokList[4];
if Ntoks >= 6 then aMapLabel.FontSize := StrToInt(TokList[5]);
if Ntoks >= 7 then
if StrToInt(TokList[6]) = 1 then aMapLabel.FontBold := True;
if Ntoks >= 8 then
if StrToInt(TokList[7]) = 1 then aMapLabel.FontItalic := True;
Result := 0;
end;
end;
end;

function ReadBackdropData: Integer;
//-----------------------------------------------------------------------------
// Reads map backdrop image information from a line of input.
//-----------------------------------------------------------------------------
var
Index : Integer;
Keyword : String;
I : Integer;
X : array[1..4] of Extended;
begin
// Check which keyword applies
Result := 0;
Keyword := TokList[0];
Index := Uutils.FindKeyWord(Keyword, BackdropWords, 4);
case Index of

0: //Backdrop file
if Ntoks > 1 then MapForm.Map.Backdrop.Filename := TokList[1];

1: // Backdrop dimensions
begin
if Ntoks < 5 then Result := ErrMsg(ITEMS_ERR, '')
else begin
for i := 1 to 4 do
if not Uutils.GetExtended(TokList[I], X[I]) then
Result := ErrMsg(NUMBER_ERR, TokList[I]);
if Result = 0 then with MapForm.Map.Backdrop do
begin
LowerLeft.X := X[1];
LowerLeft.Y := X[2];
UpperRight.X := X[3];
UpperRight.Y := X[4];
end;
end;
end;

2: //Map units - deprecated
if Ntoks > 1 then
begin
i := Uutils.FindKeyWord(Copy(TokList[1], 1, 1), MapUnits, 1);
if I < 0 then Result := ErrMsg(KEYWORD_ERR, TokList[1])
else MapForm.Map.Dimensions.Units := TMapUnits(I);
end;

3, 4: //Backdrop offset or scaling -- deprecated
begin
if Ntoks < 3 then Result := ErrMsg(ITEMS_ERR, '')
else if not Uutils.GetExtended(TokList[1], X[1]) then
Result := ErrMsg(NUMBER_ERR, TokList[1])
else if not Uutils.GetExtended(TokList[2], X[2]) then
Result := ErrMsg(NUMBER_ERR, TokList[2])
else
begin
if Index = 3 then
begin
BackdropX := X[1];
BackdropY := X[2];
end
else
begin
BackdropW := X[1];
BackdropH := X[2];
end;
end;
end;

else Result := ErrMsg(KEYWORD_ERR, Keyword);
end;
end;

function ReadProfileData: Integer;
//-----------------------------------------------------------------------------
// Reads profile plot data from a line of input.
//-----------------------------------------------------------------------------
var
I, J: Integer;
S : String;
begin
Result := 0;
if (Ntoks < 2) then Exit;

// Locate the profile name in the database
I := Project.ProfileNames.IndexOf(TokList[0]);

// If profile does not exist then create it
if (I < 0) then
begin
Project.ProfileNames.Add(TokList[0]);
I := Project.ProfileNames.Count-1;
S := '';
Project.ProfileLinks.Add(S);
end
else S := Project.ProfileLinks[I] + #13;

// Add each remaining token to the list of links in the profile
S := S + TokList[1];
for J := 2 to Ntoks-1 do
S := S + #13 + TokList[J];
Project.ProfileLinks[I] := S;
end;

procedure SetMapDimensions;
//-----------------------------------------------------------------------------
// Determines map dimensions based on range of object coordinates.
//-----------------------------------------------------------------------------
begin
with MapForm.Map do
begin
// Dimensions not provided in [MAP] section
if not MapExtentSet then
begin

// Dimensions were provided in [BACKDROP] section
if (Backdrop.LowerLeft.X <> Backdrop.UpperRight.X) then
begin

// Interpret these as map dimensions
Dimensions.LowerLeft := Backdrop.LowerLeft;
Dimensions.UpperRight := Backdrop.UpperRight;

// Compute backdrop dimensions from Offset and Scale values
Backdrop.LowerLeft.X := BackdropX;
Backdrop.LowerLeft.Y := BackdropY - BackdropH;
Backdrop.UpperRight.X := BackdropX + BackdropW;
Backdrop.UpperRight.Y := BackdropY;
end

// No dimensions of any kind provided
else with Dimensions do
Ucoords.GetCoordExtents(LowerLeft.X, LowerLeft.Y,
UpperRight.X, UpperRight.Y);
end;
end;
end;

function ParseInpLine(S: String): Integer;
//-----------------------------------------------------------------------------
// Parses current input line depending on current section of input file.
//-----------------------------------------------------------------------------
begin
case Section of
1: Result := ReadOptionData;
2: Result := ReadRaingageData;
3: Result := ReadHydrographData;
4: Result := ReadEvaporationData;
5: Result := ReadSubcatchmentData;
6: Result := ReadSubareaData;
7: Result := ReadInfiltrationData;
8: Result := ReadAquiferData;
9: Result := ReadGroundwaterData;
10: Result := ReadJunctionData;
11: Result := ReadOutfallData;
12: Result := ReadStorageData;
13: Result := ReadDividerData;
14: Result := ReadConduitData;
15: Result := ReadPumpData;
16: Result := ReadOrificeData;
17: Result := ReadWeirData;
18: Result := ReadOutletData;
19: Result := ReadXsectionData;
20: Result := ReadTransectData;
21: Result := ReadLossData;
//22: ReadControlData called directly from ReadFile
23: Result := ReadPollutantData;
24: Result := ReadLanduseData;
25: Result := ReadBuildupData;
26: Result := ReadWashoffData;
27: Result := ReadCoverageData;
28: Result := ReadExInflowData;
29: Result := ReadDWInflowData;
30: Result := ReadPatternData;
31: Result := ReadIIInflowData;
32: Result := ReadLoadData;
33: Result := ReadCurveData;
34: Result := ReadTimeseriesData;
35: Result := ReadReportData;
36: Result := ReadFileData;
37: Result := ReadMapData;
38: Result := ReadCoordData;
39: Result := ReadVertexdata;
40: Result := ReadPolygonData;
41: Result := ReadSymbolData;
42: Result := ReadLabelData;
43: Result := ReadBackdropData;
44: Result := ReadProfileData;
45: Result := ReadCurveData;
46: Result := ReadTemperatureData;
47: Result := ReadSnowpackData;
48: Result := ReadTreatmentData(S);
49: Result := ReadTagData;
50: Result := Ulid.ReadLidData(TokList, Ntoks);
51: Result := ReadLidUsageData;
52: Result := ReadGroundwaterFlowEqn(S);
53: Result := ReadAdjustmentData; //(5.1.007)
else Result := 0;
end;
end;

function ParseImportLine(Line: String): Integer;
//-----------------------------------------------------------------------------
// Processes line of input from imported scenario or map file.
// (Not currently used.)
//-----------------------------------------------------------------------------
begin
Result := 0;
end;

procedure StripComment(const Line: String; var S: String);
//-----------------------------------------------------------------------------
// Strips comment (text following a ';') from a line of input.
// Ignores comment if it begins with ';;'.
//-----------------------------------------------------------------------------
var
P: Integer;
N: Integer;
C: String;
begin
C := '';
S := Trim(Line);
P := Pos(';', S);
if P > 0 then
begin
N := Length(S);
C := Copy(S, P+1, N);
if (Length(C) >= 1) and (C[1] <> ';') then
begin
if Length(Comment) > 0 then Comment := Comment + #13;
Comment := Comment + C;
end;
Delete(S, P, N);
end;
end;

function FindNewSection(const S: String): Integer;
//-----------------------------------------------------------------------------
// Checks if S matches any of the section heading key words.
//-----------------------------------------------------------------------------
var
K: Integer;
begin
for K := 0 to High(SectionWords) do
begin
if Pos(SectionWords[K], S) = 1 then
begin
Result := K;
Exit;
end;
end;
Result := -1;
end;

function StartNewSection(S: String): Integer;
//-----------------------------------------------------------------------------
// Begins reading a new section of the input file.
//-----------------------------------------------------------------------------
var
K : Integer;

begin
// Determine which new section to begin
K := FindNewSection(UpperCase(S));
if (K >= 0) then
begin

//Update section code
Section := K;
PrevID := '';
Result := 0;
end
else Result := ErrMsg(KEYWORD_ERR, S);
Comment := '';
end;

function ReadFile(var F: Textfile; const Fsize: Int64):Boolean;
//-----------------------------------------------------------------------------
// Reads each line of a SWMM input file.
//-----------------------------------------------------------------------------
var
Err : Integer;
ByteCount : Integer;
StepCount : Integer;
StepSize : Integer;
S : String;
begin
Result := True;
ErrCount := 0;
LineCount := 0;
Comment := '';

// Initialize progress meter settings
StepCount := MainForm.ProgressBar.Max div MainForm.ProgressBar.Step;
StepSize := Fsize div StepCount;
if StepSize < 1000 then StepSize := 0;
ByteCount := 0;

// Read each line of input file
Reset(F);
while not Eof(F) do
begin
Err := 0;
Readln(F, Line);
Inc(LineCount);
if StepSize > 0 then
begin
Inc(ByteCount, Length(Line));
MainForm.UpdateProgressBar(ByteCount, StepSize);
end;

// Strip out trailing spaces, control characters & comment
Line := TrimRight(Line);
StripComment(Line, S);

// Check if line begins a new input section
if (Pos('[', S) = 1) then Err := StartNewSection(S)
else
begin

//// Following code section modified for release 5.1.011. //// //(5.1.011)
// Check if line contains project title/notes
if (Section = 0) and (Length(Line) > 0) then
begin
if LeftStr(Line,2) <> ';;' then Err := ReadTitleData(Line);
end

// Check if line contains a control rule clause
else if (Section = 22) then Err := ReadControlData(Line)

// Check if line contains an event start/end dates
else if (Section = 54) then Err := ReadEventData(Trim(Line))

// If in some section, then process the input line
else
begin
// Break line into string tokens and parse their contents
Uutils.Tokenize(S, TokList, Ntoks);
if (Ntoks > 0) and (Section >= 0) then
begin
Err := ParseInpLine(S);
Comment := '';
end

// No current section -- file was probably not an EPA-SWMM file
else if (Ntoks > 0) then
begin
Result := False;
Exit;
end;
end;
end;
////

// Increment error count
if Err > 0 then Inc(ErrCount);
end; //End of file.

if ErrCount > MAX_ERRORS then ErrList.Add(
IntToStr(ErrCount-MAX_ERRORS) + TXT_MORE_ERRORS);
end;

procedure DisplayInpErrForm(const Fname: String);
//-----------------------------------------------------------------------------
// Displays Status Report form that lists any error messages.
//-----------------------------------------------------------------------------
begin
SysUtils.DeleteFile((TempReportFile));
TempReportFile := Uutils.GetTempFile(TempDir,'swmm');
ErrList.Insert(0, TXT_ERROR_REPORT + Fname + #13);
ErrList.SaveToFile(TempReportFile);
MainForm.MnuReportStatusClick(MainForm);
end;

procedure ReverseVertexLists;
//-----------------------------------------------------------------------------
// Reverses list of vertex points for each link in the project.
//-----------------------------------------------------------------------------
var
I, J: Integer;
begin
for I := 0 to MAXCLASS do
begin
if not Project.IsLink(I) then continue;
for J := 0 to Project.Lists[I].Count-1 do
if Project.GetLink(I, J).Vlist <> nil then
Project.GetLink(I, J).Vlist.Reverse;
end;
end;

procedure SetSubcatchCentroids;
//-----------------------------------------------------------------------------
// Determines the centroid of each subcatchment polygon.
//-----------------------------------------------------------------------------
var
I : Integer;
begin
for I := 0 to Project.Lists[SUBCATCH].Count - 1 do
begin
Project.GetSubcatch(SUBCATCH, I).SetCentroid;
end;
end;

procedure SetIDPtrs;
//-----------------------------------------------------------------------------
// Makes pointers to ID strings the ID property of objects.
//-----------------------------------------------------------------------------
var
I, J : Integer;
C : TSubcatch;
S : String;

begin
for I := 0 to MAXCLASS do
begin
if I = RAINGAGE then with Project.Lists[RAINGAGE] do
begin
for J := 0 to Count-1 do TRaingage(Objects[J]).ID := PChar(Strings[J]);
end
else if Project.IsSubcatch(I) then with Project.Lists[SUBCATCH] do
begin
for J := 0 to Count-1 do
begin
C := TSubcatch(Objects[J]);
C.ID := PChar(Strings[J]);
S := Trim(C.Data[SUBCATCH_OUTLET_INDEX]);
C.OutSubcatch := FindSubcatch(S);
if C.OutSubcatch = nil then C.OutNode := FindNode(S);
end;
end
else if Project.IsNode(I) then with Project.Lists[I] do
begin
for J := 0 to Count-1 do TNode(Objects[J]).ID := PChar(Strings[J]);
end
else if Project.IsLink(I) then with Project.Lists[I] do
begin
for J := 0 to Count-1 do TLink(Objects[J]).ID := PChar(Strings[J]);
end
else if I = TRANSECT then with Project.Lists[I] do
begin
for J := 0 to Count-1 do
begin
TTransect(Objects[J]).CheckData;
TTransect(Objects[J]).SetMaxDepth;
Project.SetTransectConduitDepth(Strings[J],
TTransect(Objects[J]).Data[TRANSECT_MAX_DEPTH]);
end;
end
else continue;
end;
end;

function ReadInpFile(const Fname: String):Boolean;
//-----------------------------------------------------------------------------
// Reads SWMM input data from a text file.
//-----------------------------------------------------------------------------
var
F : Textfile;
begin
// Try to open the file
Result := False;
AssignFile(F,Fname);
{$I-}
Reset(F);
{$I+}
if (IOResult = 0) then
begin

// Create stringlists
Screen.Cursor := crHourGlass;
MapExtentSet := False;
ErrList := TStringList.Create;
TokList := TStringList.Create;
SubcatchList := TStringList.Create;
NodeList := TStringList.Create;
LinkList := TStringList.Create;
FileType := ftInput;
InpFile := Fname;
try

// Read the file
MainForm.ShowProgressBar(MSG_READING_PROJECT_DATA);
SubcatchList.Sorted := True;
NodeList.Sorted := True;
LinkList.Sorted := True;
Section := -1;
Result := ReadFile(F, Uutils.GetFileSize(Fname));
if (Result = True) then
begin
// Establish pointers to ID names
SetIDPtrs;
end;

finally
// Free the stringlists
SubcatchList.Free;
NodeList.Free;
LinkList.Free;
TokList.Free;
MainForm.PageSetupDialog.Header.Text := Project.Title;
MainForm.HideProgressBar;
Screen.Cursor := crDefault;

// Display errors if found & set map dimensions
if Result = True then
begin
if ErrList.Count > 0 then DisplayInpErrForm(Fname);
SetSubcatchCentroids;
SetMapDimensions;
end;
ErrList.Free;
end;
end;

// Close the input file
CloseFile(F);
end;

procedure ClearDefaultDates;
//-----------------------------------------------------------------------------
// Clears project's date/time settings.
//-----------------------------------------------------------------------------
begin
with Project.Options do
begin
Data[START_DATE_INDEX] := '';
Data[START_TIME_INDEX] := '';
Data[REPORT_START_DATE_INDEX] := '';
Data[REPORT_START_TIME_INDEX] := '';
Data[END_DATE_INDEX] := '';
Data[END_TIME_INDEX] := '';
end;
end;

procedure SetDefaultDates;
//-----------------------------------------------------------------------------
// Sets default values for project's date/time settings.
//-----------------------------------------------------------------------------
var
StartTime: TDateTime;
StartDate: TDateTime;
T: TDateTime;
D: TDateTime;
begin
with Project.Options do
begin

// Process starting date/time
try
StartDate := StrToDate(Data[START_DATE_INDEX], MyFormatSettings);
except
On EConvertError do StartDate := Date;
end;
StartTime := Uutils.StrHoursToTime(Data[START_TIME_INDEX]);
if StartTime < 0 then StartTime := 0;
D := StartDate + StartTime;
Data[START_DATE_INDEX] := DateToStr(D, MyFormatSettings);
Data[START_TIME_INDEX] := TimeToStr(D, MyFormatSettings);

// Process reporting start date/time
try
D := StrToDate(Data[REPORT_START_DATE_INDEX], MyFormatSettings);
except
On EConvertError do D := StartDate;
end;
T := Uutils.StrHoursToTime(Data[REPORT_START_TIME_INDEX]);
if T < 0 then T := StartTime;
D := D + T;
Data[REPORT_START_DATE_INDEX] := DateToStr(D, MyFormatSettings);
Data[REPORT_START_TIME_INDEX] := TimeToStr(D, MyFormatSettings);

// Process ending date/time
try
D := StrToDate(Data[END_DATE_INDEX], MyFormatSettings);
except
On EConvertError do D := StartDate;
end;
T := Uutils.StrHoursToTime(Data[END_TIME_INDEX]);
if T < 0 then T := StartTime;
D := D + T;
Data[END_DATE_INDEX] := DateToStr(D, MyFormatSettings);
Data[END_TIME_INDEX] := TimeToStr(D, MyFormatSettings);
end;
end;

function OpenProject(const Fname: String): TInputFileType;
//-----------------------------------------------------------------------------
// Reads in project data from a file.
//-----------------------------------------------------------------------------
begin
// Show progress meter
ClearDefaultDates;
Screen.Cursor := crHourGlass;
MainForm.ShowProgressBar(MSG_READING_PROJECT_DATA);

// Use default map dimensions and backdrop settings
MapForm.Map.Dimensions := DefMapDimensions;
MapForm.Map.Backdrop := DefMapBackdrop;

// Do the following for non-temporary input files
if not SameText(Fname, Uglobals.TempInputFile) then
begin

// Create a backup file
if AutoBackup
then CopyFile(PChar(Fname), PChar(ChangeFileExt(Fname, '.bak')), FALSE);

// Retrieve project defaults from .INI file
if CompareText(ExtractFileExt(Fname), '.ini') <> 0
then Uinifile.ReadProjIniFile(ChangeFileExt(Fname, '.ini'));
end;

// Read and parse each line of input file
Result := iftNone;
if ReadInpFile(Fname) then Result := iftINP;

// Finish processing the input dataunit Uimport;

{-------------------------------------------------------------------}
{ Unit: Uimport.pas }
{ Project: EPA SWMM }
{ Version: 5.1 }
{ Date: 12/02/13 (5.1.001) }
{ 04/04/14 (5.1.003) }
{ 04/14/14 (5.1.004) }
{ 09/15/14 (5.1.007) }
{ 03/19/15 (5.1.008) }
{ 08/05/15 (5.1.010) }
{ 08/01/16 (5.1.011) }
{ Author: L. Rossman }
{ }
{ Delphi Pascal unit that imports a SWMM project's data from a }
{ a formatted text file. }
{ }
{ 5.1.011 - Support for reading [EVENTS] section added. }
{-------------------------------------------------------------------}

interface

uses
Classes, Forms, Controls, Dialogs, SysUtils, Windows, Math, StrUtils,
Uutils, Uglobals;

const
ITEMS_ERR = 1;
KEYWORD_ERR = 2;
SUBCATCH_ERR = 3;
NODE_ERR = 4;
LINK_ERR = 5;
LANDUSE_ERR = 6;
POLLUT_ERR = 7;
NUMBER_ERR = 8;
XSECT_ERR = 9;
TRANSECT_ERR = 10;
TIMESTEP_ERR = 11;
DATE_ERR = 12;
LID_ERR = 13;
MAX_ERRORS = 50;

type
TFileType = (ftInput, ftImport);

// These routines can be called from other units
function ErrMsg(const ErrCode: Integer; const Name: String): Integer;
function OpenProject(const Fname: String): TInputFileType;
function ReadInpFile(const Fname: String):Boolean;
procedure SetDefaultDates;

implementation

uses
Fmain, Fmap, Fstatus, Dxsect, Uexport, Uinifile, Uproject, Umap,
Ucoords, Uvertex, Uupdate, Dreporting, Ulid;

const
MSG_READING_PROJECT_DATA = 'Reading project data... ';
TXT_ERROR = 'Error ';
TXT_AT_LINE = ' at line ';
TXT_MORE_ERRORS = ' more errors found in file.';
TXT_ERROR_REPORT = 'Error Report for File ';

SectionWords : array[0..54] of PChar = //(5.1.011)
('[TITLE', //0
'[OPTION', //1
'[RAINGAGE', //2
'[HYDROGRAPH', //3
'[EVAPORATION', //4
'[SUBCATCHMENT', //5
'[SUBAREA', //6
'[INFILTRATION', //7
'[AQUIFER', //8
'[GROUNDWATER', //9
'[JUNCTION', //10
'[OUTFALL', //11
'[STORAGE', //12
'[DIVIDER', //13
'[CONDUIT', //14
'[PUMP', //15
'[ORIFICE', //16
'[WEIR', //17
'[OUTLET', //18
'[XSECTION', //19
'[TRANSECT', //20
'[LOSS', //21
'[CONTROL', //22
'[POLLUTANT', //23
'[LANDUSE', //24
'[BUILDUP', //25
'[WASHOFF', //26
'[COVERAGE', //27
'[INFLOW', //28
'[DWF', //29
'[PATTERN', //30
'[RDII', //31
'[LOAD', //32
'[CURVE', //33
'[TIMESERIES', //34
'[REPORT', //35
'[FILE', //36
'[MAP', //37
'[COORDINATES', //38
'[VERTICES', //39
'[POLYGONS', //40
'[SYMBOLS', //41
'[LABELS', //42
'[BACKDROP', //43
'[PROFILE', //44
'[TABLE', //45
'[TEMPERATURE', //46
'[SNOWPACK', //47
'[TREATMENT', //48
'[TAG', //49
'[LID_CONTROL', //50
'[LID_USAGE', //51
'[GWF', //52 //(5.1.007)
'[ADJUSTMENTS', //53 //(5.1.007)
'[EVENT'); //54 //(5.1.011)

var
FileType : TFileType;
InpFile : String;
ErrList : TStringlist;
SubcatchList : TStringlist;
NodeList : TStringlist;
LinkList : TStringlist;
TokList : TStringlist;
Ntoks : Integer;
Section : Integer;
LineCount : LongInt;
ErrCount : LongInt;
Line : String;
Comment : String;
TsectComment : String;
PrevID : String;
PrevIndex : Integer;
CurveType : Integer;
MapExtentSet : Boolean;
ManningsN : array[1..3] of String;

// These are deprecated attributes of a backdrop image
BackdropX : Extended;
BackdropY : Extended;
BackdropW : Extended;
BackdropH : Extended;

function ErrMsg(const ErrCode: Integer; const Name: String): Integer;
//-----------------------------------------------------------------------------
// Adds an error message for a specific error code to the list
// of errors encountered when reading an input file.
//-----------------------------------------------------------------------------
var
S: String;
begin
if ErrCount <= MAX_ERRORS then
begin
case ErrCode of
ITEMS_ERR: S := 'Too few items ';
KEYWORD_ERR: S := 'Unrecognized keyword (' + Name + ') ';
SUBCATCH_ERR: S := 'Undefined Subcatchment (' + Name + ') referenced ';
NODE_ERR: S := 'Undefined Node (' + Name + ') referenced ';
LINK_ERR: S := 'Undefined Link (' + Name + ') referenced ';
LANDUSE_ERR: S := 'Undefined Land Use (' + Name + ') referenced ';
POLLUT_ERR: S := 'Undefined Pollutant (' + Name + ') referenced ';
NUMBER_ERR: S := 'Illegal numeric value (' + Name + ') ';
XSECT_ERR: S := 'Illegal cross section for Link ' + Name + ' ';
TRANSECT_ERR: S := 'No Transect defined for these data ';
TIMESTEP_ERR: S := 'Illegal time step value ';
DATE_ERR: S := 'Illegal date/time value ';
LID_ERR: S := 'Undefined LID process (' + Name + ') referenced ';
else S := 'Unknown error ';
end;
S := S + 'at line ' + IntToStr(LineCount) + ':';
ErrList.Add(S);
if Section >= 0 then ErrList.Add(SectionWords[Section] + ']');
ErrList.Add(Line);
ErrList.Add('');
end;
Result := ErrCode;
end;

function FindSubcatch(const ID: String): TSubcatch;
//-----------------------------------------------------------------------------
// Finds a Subcatchment object given its ID name.
//-----------------------------------------------------------------------------
var
Index: Integer;
Atype: Integer;
begin
Result := nil;
if (FileType = ftInput) then
begin
if SubcatchList.Find(ID, Index)
then Result := TSubcatch(SubcatchList.Objects[Index]);
end
else
begin
if (Project.FindSubcatch(ID, Atype, Index))
then Result := Project.GetSubcatch(Atype, Index);
end;
end;

function FindNode(const ID: String): TNode;
//-----------------------------------------------------------------------------
// Finds a Node object given its ID name.
//-----------------------------------------------------------------------------
var
Index: Integer;
Ntype: Integer;
begin
Result := nil;
if (FileType = ftInput) then
begin
if NodeList.Find(ID, Index)
then Result := TNode(NodeList.Objects[Index]);
end
else
begin
if (Project.FindNode(ID, Ntype, Index))
then Result := Project.GetNode(Ntype, Index);
end;
end;

function FindLink(const ID: String): TLink;
//-----------------------------------------------------------------------------
// Finds a Link object given its ID name.
//-----------------------------------------------------------------------------
var
Index : Integer;
Ltype : Integer;
begin
Result := nil;
if (FileType = ftInput) then
begin
if LinkList.Find(ID, Index)
then Result := TLink(LinkList.Objects[Index]);
end
else
begin
if (Project.FindLink(ID, Ltype, Index))
then Result := Project.GetLink(Ltype, Index);
end;
end;

function ReadTitleData(Line: String): Integer;
//-----------------------------------------------------------------------------
// Adds Line of text to a project's title and notes.
//-----------------------------------------------------------------------------
begin
if Project.Lists[NOTES].Count = 0 then Project.Title := Line;
Project.Lists[NOTES].Add(Line);
Project.HasItems[NOTES] := True;
Result := 0;
end;

procedure ReadOldRaingageData(I: Integer; aGage: TRaingage);
//-----------------------------------------------------------------------------
// Reads a line of parsed rain gage data using older format.
//-----------------------------------------------------------------------------
begin
if I = 0 then
begin
aGage.Data[GAGE_DATA_SOURCE] := RaingageOptions[0];
if Ntoks > 2 then aGage.Data[GAGE_SERIES_NAME] := TokList[2];
if Ntoks > 3 then aGage.Data[GAGE_DATA_FORMAT] := TokList[3];
if Ntoks > 4 then aGage.Data[GAGE_DATA_FREQ] := TokList[4];
end;
if I = 1 then
begin
aGage.Data[GAGE_DATA_SOURCE] := RaingageOptions[1];
if Ntoks > 2 then aGage.Data[GAGE_FILE_NAME] := TokList[2];
if Ntoks > 3 then aGage.Data[GAGE_STATION_NUM] := TokList[3];
end;
end;

procedure ReadNewRaingageData(aGage: TRaingage);
//-----------------------------------------------------------------------------
// Reads a line of rain gage data using newer format.
//-----------------------------------------------------------------------------
var
I: Integer;
Fname: String;
begin
if Ntoks > 1 then aGage.Data[GAGE_DATA_FORMAT] := TokList[1];
if Ntoks > 2 then aGage.Data[GAGE_DATA_FREQ] := TokList[2];
if Ntoks > 3 then aGage.Data[GAGE_SNOW_CATCH] := TokList[3];
if Ntoks > 4 then
begin
I := Uutils.FindKeyWord(TokList[4], RaingageOptions, 4);
if I = 0 then
begin
aGage.Data[GAGE_DATA_SOURCE] := RaingageOptions[0];
if Ntoks > 5 then aGage.Data[GAGE_SERIES_NAME] := TokList[5];
end;
if I = 1 then
begin
aGage.Data[GAGE_DATA_SOURCE] := RaingageOptions[1];
if Ntoks > 5 then
begin
Fname := TokList[5];
if ExtractFilePath(Fname) = ''
then Fname := ExtractFilePath(Uglobals.InputFileName) + Fname;
aGage.Data[GAGE_FILE_NAME] := Fname;
end;
if Ntoks > 6 then aGage.Data[GAGE_STATION_NUM] := TokList[6];
if Ntoks > 7 then aGage.Data[GAGE_RAIN_UNITS] := TokList[7];
end;
end;
end;

function ReadRaingageData: Integer;
//-----------------------------------------------------------------------------
// Parses rain gage data from the input line.
//-----------------------------------------------------------------------------
var
aGage : TRaingage;
ID : String;
I : Integer;
begin
if Ntoks < 2 then
begin
Result := ErrMsg(ITEMS_ERR, '');
Exit;
end;
ID := TokList[0];
aGage := TRaingage.Create;
Uutils.CopyStringArray(Project.DefProp[RAINGAGE].Data, aGage.Data);
aGage.X := MISSING;
aGage.Y := MISSING;
aGage.Data[COMMENT_INDEX ] := Comment;
Project.Lists[RAINGAGE].AddObject(ID, aGage);
Project.HasItems[RAINGAGE] := True;
I := Uutils.FindKeyWord(TokList[1], RaingageOptions, 4);
if I >= 0
then ReadOldRaingageData(I, aGage)
else ReadNewRaingageData(aGage);
Result := 0;
end;

function ReadOldHydrographFormat(const I: Integer; UH: THydrograph): Integer;
//-----------------------------------------------------------------------------
// Reads older format of unit hydrograph parameters from a line of input.
//-----------------------------------------------------------------------------
var
J, K, N: Integer;
begin
Result := 0;
if Ntoks < 2 then Result := ErrMsg(ITEMS_ERR, '')
else
begin
N := 2;
for K := 1 to 3 do
begin
for J := 1 to 3 do
begin
UH.Params[I,J,K] := TokList[N];
Inc(N);
end;
end;
for J := 1 to 3 do
begin
UH.InitAbs[I,J,1] := '';
if Ntoks > N then UH.InitAbs[I,J,1] := TokList[N];
Inc(N);
for K := 2 to 3 do UH.InitAbs[I,J,K] := UH.InitAbs[I,J,1];
end;
end;
end;

function ReadHydrographData: Integer;
//-----------------------------------------------------------------------------
// Reads RDII unit hydrograph data from a line of input.
//-----------------------------------------------------------------------------
var
I, J, K: Integer;
ID: String;
aUnitHyd: THydrograph;
Index: Integer;
begin
Result := 0;
if Ntoks < 2 then Result := ErrMsg(ITEMS_ERR, '')
else
begin

// Check if hydrograph ID is same as for previous line
ID := TokList[0];
if (ID = PrevID)
then Index := PrevIndex
else Index := Project.Lists[HYDROGRAPH].IndexOf(ID);

// If starting input for a new hydrograph then create it
if Index < 0 then
begin
aUnitHyd := THydrograph.Create;
Project.Lists[HYDROGRAPH].AddObject(ID, aUnitHyd);
Project.HasItems[HYDROGRAPH] := True;
Index := Project.Lists[HYDROGRAPH].Count - 1;
PrevID := ID;
PrevIndex := Index;
end
else aUnitHyd := THydrograph(Project.Lists[HYDROGRAPH].Objects[Index]);

// Parse rain gage name for 2-token line
if Ntoks = 2 then
begin
aUnitHyd.Raingage := TokList[1];
end

// Extract remaining hydrograph parameters
else if Ntoks < 6 then Result := ErrMsg(ITEMS_ERR, '')
else
begin
// Determine month of year
I := Uutils.FindKeyWord(TokList[1], MonthLabels, 3);
if I < 0 then Result := ErrMsg(KEYWORD_ERR, TokList[1]);

// Determine if response type present - if not, process old format
K := Uutils.FindKeyWord(TokList[2], ResponseTypes, 3) + 1;
if K < 1 then Result := ReadOldHydrographFormat(I, aUnitHyd)
else
begin
// Extract R-T-K values
for J := 3 to 5 do
begin
aUnitHyd.Params[I,J-2,K] := TokList[J];
end;
// Extract IA parameters
for J := 6 to 8 do
begin
if J >= Ntoks then break
else aUnitHyd.InitAbs[I,J-5,K] := TokList[J];
end;
end;
end;
end;
end;

function ReadTemperatureData: Integer;
//-----------------------------------------------------------------------------
// Reads description of air temperature data from a line of input.
//-----------------------------------------------------------------------------
var
I: Integer;
begin
Result := 0;
if Ntoks < 2 then Result := ErrMsg(ITEMS_ERR, '')
else with Project.Climatology do
begin
I := Uutils.FindKeyWord(TokList[0], TempKeywords, 10);
if I < 0 then Result := ErrMsg(KEYWORD_ERR, TokList[0])
else case I of
0: begin // Time series
TempDataSource := 1;
TempTseries := TokList[1];
end;
1: begin // File
TempDataSource := 2;
TempFile := TokList[1];
if ExtractFilePath(TempFile) = '' then
TempFile := ExtractFilePath(Uglobals.InputFileName) + TempFile;
if Ntoks >= 3 then TempStartDate := TokList[2];
end;
2: begin // Wind speed
if SameText(TokList[1], 'MONTHLY') then
begin
if Ntoks < 14 then Result := ErrMsg(ITEMS_ERR, '')
else
begin
WindType := MONTHLY_WINDSPEED;
for I := 1 to 12 do WindSpeed[I] := TokList[I+1];
end;
end
else if SameText(TokList[1], 'FILE') then WindType := FILE_WINDSPEED
else Result := ErrMsg(KEYWORD_ERR, TokList[1]);
end;
3: begin
if Ntoks < 7 then Result := ErrMsg(ITEMS_ERR, '')
else for I := 1 to 6 do SnowMelt[I] := TokList[I];
end;
4: begin
if Ntoks < 12 then Result := ErrMsg(ITEMS_ERR, '')
else
begin
if SameText(TokList[1], 'IMPERVIOUS') then
for I := 1 to 10 do ADCurve[1][I] := TokList[I+1]
else if SameText(TokList[1], 'PERVIOUS') then
for I := 1 to 10 do ADCurve[2][I] := TokList[I+1]
else Result := ErrMsg(KEYWORD_ERR, TokList[1]);
end;
end;
end;
end;
end;

function ReadEvaporationRates(Etype: Integer): Integer;
var
J: Integer;
begin
if (Etype <> TEMP_EVAP) and (Ntoks < 2)
then Result := ErrMsg(ITEMS_ERR, '')

else with Project.Climatology do
begin
EvapType := Etype;

case EvapType of

CONSTANT_EVAP:
for J := 0 to 11 do EvapData[J] := TokList[1];

TSERIES_EVAP:
EvapTseries := TokList[1];

FILE_EVAP:
for J := 1 to 12 do
begin
if J >= Ntoks then break;
PanData[J-1] := TokList[J];
end;

MONTHLY_EVAP:
for J := 1 to 12 do
begin
if J >= Ntoks then break;
EvapData[J-1] := TokList[J];
end;
end;

Result := 0;
end;

end;

function ReadEvaporationData: Integer;
//-----------------------------------------------------------------------------
// Reads evaporation data from a line of input.
//-----------------------------------------------------------------------------
var
I: Integer;
begin
Result := 0;
I := Uutils.FindKeyWord(TokList[0], EvapOptions, 4);
if I >= 0 then Result := ReadEvaporationRates(I)

else if (I <> TEMP_EVAP) and (Ntoks < 2)
then Result := ErrMsg(ITEMS_ERR, '')

else with Project.Climatology do
begin

if SameText(TokList[0], 'RECOVERY')
then RecoveryPat := TokList[1]

else if SameText(TokList[0], 'DRY_ONLY') then
begin
if SameText(TokList[1], 'NO') then EvapDryOnly := False
else if SameText(TokList[1], 'YES') then EvapDryOnly := True
else Result := ErrMsg(KEYWORD_ERR, TokList[1]);
end

else Result := ErrMsg(KEYWORD_ERR, TokList[0]);

end;
end;

function ReadSubcatchmentData: Integer;
//-----------------------------------------------------------------------------
// Reads subcatchment data from a line of input.
//-----------------------------------------------------------------------------
var
S : TSubcatch;
ID : String;
begin
if Ntoks < 8
then Result := ErrMsg(ITEMS_ERR, '')
else begin
ID := TokList[0];
S := TSubcatch.Create;
SubcatchList.AddObject(ID, S);
S.X := MISSING;
S.Y := MISSING;
S.Zindex := -1;
Uutils.CopyStringArray(Project.DefProp[SUBCATCH].Data, S.Data);
S.Data[SUBCATCH_RAINGAGE_INDEX] := TokList[1];
S.Data[SUBCATCH_OUTLET_INDEX] := TokList[2];
S.Data[SUBCATCH_AREA_INDEX] := TokList[3];
S.Data[SUBCATCH_IMPERV_INDEX] := TokList[4];
S.Data[SUBCATCH_WIDTH_INDEX] := TokList[5];
S.Data[SUBCATCH_SLOPE_INDEX] := TokList[6];
S.Data[SUBCATCH_CURBLENGTH_INDEX] := TokList[7];
if Ntoks >= 9
then S.Data[SUBCATCH_SNOWPACK_INDEX] := TokList[8];
S.Data[COMMENT_INDEX ] := Comment;
Project.Lists[SUBCATCH].AddObject(ID, S);
Project.HasItems[SUBCATCH] := True;
Result := 0;
end;
end;

function ReadSubareaData: Integer;
//-----------------------------------------------------------------------------
// Reads subcatchment sub-area data from a line of input.
//-----------------------------------------------------------------------------
var
S : TSubcatch;
ID : String;
begin
if Ntoks < 7
then Result := ErrMsg(ITEMS_ERR, '')
else begin
ID := TokList[0];
S := FindSubcatch(ID);
if S = nil
then Result := ErrMsg(SUBCATCH_ERR, ID)
else begin
S.Data[SUBCATCH_IMPERV_N_INDEX] := TokList[1];
S.Data[SUBCATCH_PERV_N_INDEX] := TokList[2];
S.Data[SUBCATCH_IMPERV_DS_INDEX] := TokList[3];
S.Data[SUBCATCH_PERV_DS_INDEX] := TokList[4];
S.Data[SUBCATCH_PCTZERO_INDEX] := TokList[5];
S.Data[SUBCATCH_ROUTE_TO_INDEX] := TokList[6];
if Ntoks >= 8
then S.Data[SUBCATCH_PCT_ROUTED_INDEX] := TokList[7];
Result := 0;
end;
end;
end;

function ReadInfiltrationData: Integer;
//-----------------------------------------------------------------------------
// Reads subcatchment infiltration data from a line of input.
//-----------------------------------------------------------------------------
var
S : TSubcatch;
ID : String;
J : Integer;
Jmax : Integer;
begin
ID := TokList[0];
S := FindSubcatch(ID);
if S = nil
then Result := ErrMsg(SUBCATCH_ERR, ID)
else begin
Jmax := Ntoks-1;
if Jmax > MAXINFILPROPS then Jmax := MAXINFILPROPS;
for J := 1 to Jmax do S.InfilData[J-1] := TokList[J];
Result := 0;
end;
end;

function ReadAquiferData: Integer;
//-----------------------------------------------------------------------------
// Reads aquifer data from a line of input.
//-----------------------------------------------------------------------------
var
ID : String;
A : TAquifer;
I : Integer;
begin
if nToks < MAXAQUIFERPROPS then Result := ErrMsg(ITEMS_ERR, '') //(5.1.003)
else begin
ID := TokList[0];
A := TAquifer.Create;
//Uutils.CopyStringArray(Project.DefProp[AQUIFER].Data, A.Data); //(5.1.004)
Project.Lists[AQUIFER].AddObject(ID, A);
Project.HasItems[AQUIFER] := True;
for I := 0 to MAXAQUIFERPROPS-1 do A.Data[I] := TokList[I+1]; //(5.1.003)
if nToks >= MAXAQUIFERPROPS + 2 //(5.1.004)
then A.Data[MAXAQUIFERPROPS] := TokList[MAXAQUIFERPROPS+1] //(5.1.003)
else A.Data[MAXAQUIFERPROPS] := ''; //(5.1.003)
Result := 0;
end;
end;

function ReadGroundwaterData: Integer;
//-----------------------------------------------------------------------------
// Reads subcatchment groundwater data from a line of input.
//-----------------------------------------------------------------------------
var
S: TSubcatch;
ID: String;
P: String;
J: Integer;
K: Integer;

begin
// Get subcatchment name
ID := TokList[0];
S := FindSubcatch(ID);
if S = nil
then Result := ErrMsg(SUBCATCH_ERR, ID)
else
begin

// Line contains GW flow parameters
if Ntoks < 10 then Result := ErrMsg(ITEMS_ERR, '')
else begin
S.Groundwater.Clear;

// Read required parameters
for J := 1 to 9 do S.Groundwater.Add(TokList[J]);

// Read optional parameters
for K := 10 to 13 do
begin
if Ntoks > K then
begin
P := TokList[K];
if P = '*' then P := '';
S.Groundwater.Add(P);
end
else S.Groundwater.Add('');
end;
S.Data[SUBCATCH_GWATER_INDEX] := 'YES';
Result := 0;
end;
end;
end;

//// This function was re-written for release 5.1.007. //// //(5.1.007)
function ReadGroundwaterFlowEqn(Line: String): Integer;
//-----------------------------------------------------------------------------
// Reads GW flow math expression from a line of input.
//-----------------------------------------------------------------------------
var
S: TSubcatch;
N: Integer;
begin
// Check for enough tokens in line
if Ntoks < 3 then Result := ErrMsg(ITEMS_ERR, '')
// Get subcatchment object referred to by name
else begin
Result := 0;
S := FindSubcatch(TokList[0]);
if S = nil then Result := ErrMsg(SUBCATCH_ERR, TokList[0])
else begin
// Find position in Line where second token ends
N := Pos(TokList[1], Line) + Length(TokList[1]);
// Save remainder of line to correct type of GW flow equation
if SameText(TokList[1], 'LATERAL') then
S.GwLatFlowEqn := Trim(AnsiRightStr(Line, Length(Line)-N))
else if SameText(TokList[1], 'DEEP') then
S.GwDeepFlowEqn := Trim(AnsiRightStr(Line, Length(Line)-N))
else Result := ErrMsg(KEYWORD_ERR, TokList[1]);
end;
end;
end;

function ReadSnowpackData: Integer;
//-----------------------------------------------------------------------------
// Reads snowpack data from a line of input.
//-----------------------------------------------------------------------------
var
ID : String;
P : TSnowpack;
I : Integer;
J : Integer;
Index: Integer;
begin
Result := 0;
if Ntoks < 8
then Result := ErrMsg(ITEMS_ERR, '')
else begin
I := Uutils.FindKeyWord(TokList[1], SnowpackOptions, 7);
if I < 0
then Result := ErrMsg(KEYWORD_ERR, TokList[1])
else begin

// Check if snow pack ID is same as for previous line
ID := TokList[0];
if (ID = PrevID)
then Index := PrevIndex
else Index := Project.Lists[SNOWPACK].IndexOf(ID);

// If starting input for a new snow pack then create it
if Index < 0 then
begin
P := TSnowpack.Create;
Project.Lists[SNOWPACK].AddObject(ID, P);
Project.HasItems[SNOWPACK] := True;
Index := Project.Lists[SNOWPACK].Count - 1;
PrevID := ID;
PrevIndex := Index;
end
else P := TSnowpack(Project.Lists[SNOWPACK].Objects[Index]);

// Parse line depending on data type
case I of

// Plowable area
0: begin
if Ntoks < 9 then Result := ErrMsg(ITEMS_ERR, '')
else
begin
for J := 1 to 6 do P.Data[1][J] := TokList[J+1];
P.FracPlowable := TokList[8];
end;
end;

// Impervious or Pervious area
1,
2: begin
if Ntoks < 9 then Result := ErrMsg(ITEMS_ERR, '')
else for J := 1 to 7 do P.Data[I+1][J] := TokList[J+1];
end;

// Plowing parameters
3: begin
for J := 1 to 6 do P.Plowing[J] := TokList[J+1];
if Ntoks >= 9 then P.Plowing[7] := TokList[8];
end;
end;
end;
end;
end;

function ReadJunctionData: Integer;
//-----------------------------------------------------------------------------
// Reads junction data from a line of input.
//-----------------------------------------------------------------------------
var
aNode: TNode;
ID : String;
begin
if Ntoks < 2
then Result := ErrMsg(ITEMS_ERR, '')
else begin
ID := TokList[0];
aNode := TNode.Create;
NodeList.AddObject(ID, aNode);
aNode.Ntype := JUNCTION;
aNode.X := MISSING;
aNode.Y := MISSING;
aNode.Zindex := -1;
Uutils.CopyStringArray(Project.DefProp[JUNCTION].Data, aNode.Data);
aNode.Data[NODE_INVERT_INDEX] := TokList[1];
if Ntoks > 2 then aNode.Data[JUNCTION_MAX_DEPTH_INDEX] := TokList[2];
if Ntoks > 3 then aNode.Data[JUNCTION_INIT_DEPTH_INDEX] := TokList[3];
if Ntoks > 4 then aNode.Data[JUNCTION_SURCHARGE_DEPTH_INDEX] := TokList[4];
if Ntoks > 5 then aNode.Data[JUNCTION_PONDED_AREA_INDEX] := TokList[5];
aNode.Data[COMMENT_INDEX ] := Comment;
Project.Lists[JUNCTION].AddObject(ID, aNode);
Project.HasItems[JUNCTION] := True;
Result := 0;
end;
end;

function ReadOutfallData: Integer;
//-----------------------------------------------------------------------------
// Reads outfall data from a line of input.
//-----------------------------------------------------------------------------
var
aNode: TNode;
ID : String;
I : Integer;
N : Integer; //(5.1.008)
begin
if Ntoks < 3
then Result := ErrMsg(ITEMS_ERR, '')
else begin
N := 4; //(5.1.008)
ID := TokList[0];
aNode := TNode.Create;
NodeList.AddObject(ID, aNode);
aNode.Ntype := OUTFALL;
aNode.X := MISSING;
aNode.Y := MISSING;
aNode.Zindex := -1;
Uutils.CopyStringArray(Project.DefProp[OUTFALL].Data, aNode.Data);
aNode.Data[NODE_INVERT_INDEX] := TokList[1];
I := Uutils.FindKeyWord(TokList[2], OutfallOptions, 4);
if I < 0 then I := FREE_OUTFALL;
if (I > NORMAL_OUTFALL) and (Ntoks >= 4) then
begin
case I of
FIXED_OUTFALL: aNode.Data[OUTFALL_FIXED_STAGE_INDEX] := TokList[3];
TIDAL_OUTFALL: aNode.Data[OUTFALL_TIDE_TABLE_INDEX] := TokList[3];
TIMESERIES_OUTFALL: aNode.Data[OUTFALL_TIME_SERIES_INDEX] := TokList[3];
end;
N := 5;
if Ntoks >= 5 then aNode.Data[OUTFALL_TIDE_GATE_INDEX] := TokList[4]; // (5.1.008)
end
else if Ntoks >= 4 then aNode.Data[OUTFALL_TIDE_GATE_INDEX] := TokList[3]; //(5.1.008)
if Ntoks > N then aNode.Data[OUTFALL_ROUTETO_INDEX] := TokList[N]; //(5.1.008)
aNode.Data[OUTFALL_TYPE_INDEX] := OutfallOptions[I];
aNode.Data[COMMENT_INDEX ] := Comment;
Project.Lists[OUTFALL].AddObject(ID, aNode);
Project.HasItems[OUTFALL] := True;
Result := 0;
end;
end;

//// The following function was modified for release 5.1.007. //// //(5.1.007)

function ReadStorageData: Integer;
//-----------------------------------------------------------------------------
// Reads storage unit data from a line of input.
//-----------------------------------------------------------------------------
var
aNode: TNode;
ID : String;
N : Integer;
X : Single;
begin
Result := 0;
N := 6;
if Ntoks < 6
then Result := ErrMsg(ITEMS_ERR, '')
else begin
ID := TokList[0];
aNode := TNode.Create;
NodeList.AddObject(ID, aNode);
aNode.Ntype := STORAGE;
aNode.X := MISSING;
aNode.Y := MISSING;
aNode.Zindex := -1;
Uutils.CopyStringArray(Project.DefProp[STORAGE].Data, aNode.Data);
Project.Lists[STORAGE].AddObject(ID, aNode);
aNode.Data[NODE_INVERT_INDEX] := TokList[1];
aNode.Data[STORAGE_MAX_DEPTH_INDEX] := TokList[2];
aNode.Data[STORAGE_INIT_DEPTH_INDEX] := TokList[3];
aNode.Data[STORAGE_GEOMETRY_INDEX] := TokList[4];
if CompareText(TokList[4], 'TABULAR') = 0 then
begin
aNode.Data[STORAGE_ATABLE_INDEX] := TokList[5];
end
else begin
if Ntoks < 7
then Result := ErrMsg(ITEMS_ERR, '')
else begin
aNode.Data[STORAGE_ACOEFF_INDEX] := TokList[5];
aNode.Data[STORAGE_AEXPON_INDEX] := TokList[6];
if Ntoks >= 8 then aNode.Data[STORAGE_ACONST_INDEX] := TokList[7];
N := 8;
end;
end;

// Optional items
if (Result = 0) and (Ntoks > N) then
begin
// Ponded area
aNode.Data[STORAGE_PONDED_AREA_INDEX] := TokList[N];
// Evaporation factor
if Ntoks > N+1 then aNode.Data[STORAGE_EVAP_FACTOR_INDEX] := TokList[N+1];
// Constant seepage rate
if Ntoks = N+3 then
begin
aNode.InfilData[STORAGE_KSAT_INDEX] := TokList[N+2];
end
// Green-Ampt seepage parameters
else if Ntoks = N+5 then
begin
aNode.InfilData[STORAGE_SUCTION_INDEX] := TokList[N+2];
aNode.InfilData[STORAGE_KSAT_INDEX] := TokList[N+3];
aNode.InfilData[STORAGE_IMDMAX_INDEX] := TokList[N+4];
end;
end;
Uutils.GetSingle(aNode.InfilData[STORAGE_KSAT_INDEX ], X);
if (X > 0) then aNode.Data[STORAGE_SEEPAGE_INDEX] := 'YES'
else aNode.Data[STORAGE_SEEPAGE_INDEX] := 'NO';
aNode.Data[COMMENT_INDEX ] := Comment;
Project.HasItems[STORAGE] := True;
end;
end;

function ReadDividerData: Integer;
//-----------------------------------------------------------------------------
// Reads flow divider data from a line of input.
// (Corrected on 6/14/05)
//-----------------------------------------------------------------------------
var
N, J : Integer;
aNode: TNode;
ID : String;
begin
if Ntoks < 4
then Result := ErrMsg(ITEMS_ERR, '')
else begin
Result := 0;
ID := TokList[0];
aNode := TNode.Create;
NodeList.AddObject(ID, aNode);
aNode.Ntype := DIVIDER;
aNode.X := MISSING;
aNode.Y := MISSING;
aNode.Zindex := -1;
Uutils.CopyStringArray(Project.DefProp[DIVIDER].Data, aNode.Data);
Project.Lists[DIVIDER].AddObject(ID, aNode);
Project.HasItems[DIVIDER] := True;
aNode.Data[COMMENT_INDEX ] := Comment;
aNode.Data[NODE_INVERT_INDEX] := TokList[1];
aNode.Data[DIVIDER_LINK_INDEX] := TokList[2];
aNode.Data[DIVIDER_TYPE_INDEX] := TokList[3];
N := 5;
if SameText(TokList[3], 'OVERFLOW') then
begin
N := 4;
end
else if SameText(TokList[3], 'CUTOFF') then
begin
aNode.Data[DIVIDER_CUTOFF_INDEX] := TokList[4];
end
else if SameText(TokList[3], 'TABULAR') then
begin
aNode.Data[DIVIDER_TABLE_INDEX] := TokList[4];
end
else if SameText(TokList[3], 'WEIR') and (Ntoks >= 7) then
begin
aNode.Data[DIVIDER_QMIN_INDEX] := TokList[4];
aNode.Data[DIVIDER_DMAX_INDEX] := TokList[5];
aNode.Data[DIVIDER_QCOEFF_INDEX] := TokList[6];
N := 7;
end
else Result := ErrMsg(KEYWORD_ERR, TokList[3]);
if (Result = 0) and (Ntoks > N) then
begin
for J := N to Ntoks-1 do
aNode.Data[DIVIDER_MAX_DEPTH_INDEX + J - N] := TokList[J];
end;
end;
end;

function ReadConduitData: Integer;
//-----------------------------------------------------------------------------
// Reads conduit data from a line of input.
//-----------------------------------------------------------------------------
var
aLink : TLink;
aNode1: TNode;
aNode2: TNode;
ID : String;
begin
if Ntoks < 7 then Result := ErrMsg(ITEMS_ERR, '')
else begin
ID := TokList[0];
aNode1 := FindNode(TokList[1]);
aNode2 := FindNode(TokList[2]);
if (aNode1 = nil) then Result := ErrMsg(NODE_ERR, TokList[1])
else if (aNode2 = nil) then Result := ErrMsg(NODE_ERR, TokList[2])
else begin
aLink := TLink.Create;
LinkList.AddObject(ID, aLink);
aLink.Ltype := CONDUIT;
aLink.Node1 := aNode1;
aLink.Node2 := aNode2;
aLink.Zindex := -1;
Uutils.CopyStringArray(Project.DefProp[CONDUIT].Data, aLink.Data);
Project.Lists[CONDUIT].AddObject(ID, aLink);
Project.HasItems[CONDUIT] := True;
aLink.Data[CONDUIT_LENGTH_INDEX] := TokList[3];
aLink.Data[CONDUIT_ROUGHNESS_INDEX] := TokList[4];
aLink.Data[CONDUIT_INLET_HT_INDEX] := TokList[5];
aLink.Data[CONDUIT_OUTLET_HT_INDEX] := TokList[6];
if Ntoks > 7 then aLink.Data[CONDUIT_INIT_FLOW_INDEX] := TokList[7];
if Ntoks > 8 then aLink.Data[CONDUIT_MAX_FLOW_INDEX] := TokList[8];
aLink.Data[COMMENT_INDEX ] := Comment;
Result := 0;
end;
end;
end;

function ReadPumpData: Integer;
//-----------------------------------------------------------------------------
// Reads pump data from a line of input.
//-----------------------------------------------------------------------------
var
aLink : TLink;
aNode1: TNode;
aNode2: TNode;
ID : String;
N : Integer;
begin
if nToks < 4
then Result := ErrMsg(ITEMS_ERR, '')
else begin
ID := TokList[0];
aNode1 := FindNode(TokList[1]);
aNode2 := FindNode(TokList[2]);
if (aNode1 = nil) then Result := ErrMsg(NODE_ERR, TokList[1])
else if (aNode2 = nil) then Result := ErrMsg(NODE_ERR, TokList[2])
else begin
aLink := TLink.Create;
LinkList.AddObject(ID, aLink);
aLink.Ltype := PUMP;
aLink.Node1 := aNode1;
aLink.Node2 := aNode2;
aLink.Zindex := -1;
Uutils.CopyStringArray(Project.DefProp[PUMP].Data, aLink.Data);
Project.Lists[PUMP].AddObject(ID, aLink);
Project.HasItems[PUMP] := True;

// Skip over PumpType if line has old format
if Uutils.FindKeyWord(TokList[3], PumpTypes, 5) >= 0 then N := 4
else N := 3;
if Ntoks <= N then Result := ErrMsg(ITEMS_ERR, '')
else
begin
aLink.Data[PUMP_CURVE_INDEX] := TokList[N];
if nToks > N+1 then aLink.Data[PUMP_STATUS_INDEX] := TokList[N+1];
if nToks > N+2 then aLink.Data[PUMP_STARTUP_INDEX] := TokList[N+2];
if nToks > N+3 then aLink.Data[PUMP_SHUTOFF_INDEX] := TokList[N+3];
aLink.Data[COMMENT_INDEX ] := Comment;
Result := 0;
end;
end;
end;
end;

function ReadOrificeData: Integer;
//-----------------------------------------------------------------------------
// Reads orifice data from a line of input.
//-----------------------------------------------------------------------------
var
aLink : TLink;
aNode1: TNode;
aNode2: TNode;
ID : String;
begin
if nToks < 6
then Result := ErrMsg(ITEMS_ERR, '')
else begin
ID := TokList[0];
aNode1 := FindNode(TokList[1]);
aNode2 := FindNode(TokList[2]);
if (aNode1 = nil) then Result := ErrMsg(NODE_ERR, TokList[1])
else if (aNode2 = nil) then Result := ErrMsg(NODE_ERR, TokList[2])
else begin
aLink := TLink.Create;
LinkList.AddObject(ID, aLink);
aLink.Ltype := ORIFICE;
aLink.Node1 := aNode1;
aLink.Node2 := aNode2;
aLink.Zindex := -1;
Uutils.CopyStringArray(Project.DefProp[ORIFICE].Data, aLink.Data);
Project.Lists[ORIFICE].AddObject(ID, aLink);
Project.HasItems[ORIFICE] := True;
aLink.Data[ORIFICE_TYPE_INDEX] := TokList[3];
aLink.Data[ORIFICE_BOTTOM_HT_INDEX] := TokList[4];
aLink.Data[ORIFICE_COEFF_INDEX] := TokList[5];
if nToks >= 7
then aLink.Data[ORIFICE_FLAPGATE_INDEX] := TokList[6];
if nToks >= 8
then aLink.Data[ORIFICE_ORATE_INDEX] := TokList[7];
aLink.Data[COMMENT_INDEX ] := Comment;
Result := 0;
end;
end;
end;

function ReadWeirData: Integer;
//-----------------------------------------------------------------------------
// Reads weir data from a line of input.
//-----------------------------------------------------------------------------
var
aLink : TLink;
aNode1: TNode;
aNode2: TNode;
ID : String;
begin
if nToks < 6
then Result := ErrMsg(ITEMS_ERR, '')
else begin
ID := TokList[0];
aNode1 := FindNode(TokList[1]);
aNode2 := FindNode(TokList[2]);
if (aNode1 = nil) then Result := ErrMsg(NODE_ERR, TokList[1])
else if (aNode2 = nil) then Result := ErrMsg(NODE_ERR, TokList[2])
else begin
aLink := TLink.Create;
LinkList.AddObject(ID, aLink);
aLink.Ltype := WEIR;
aLink.Node1 := aNode1;
aLink.Node2 := aNode2;
aLink.Zindex := -1;
Uutils.CopyStringArray(Project.DefProp[WEIR].Data, aLink.Data);
Project.Lists[WEIR].AddObject(ID, aLink);
Project.HasItems[WEIR] := True;
aLink.Data[WEIR_TYPE_INDEX] := TokList[3];
aLink.Data[WEIR_CREST_INDEX] := TokList[4];
aLink.Data[WEIR_COEFF_INDEX] := TokList[5];

//// Following section modified for release 5.1.007. //// //(5.1.007)
if (nToks >= 7) and not SameText(TokList[6], '*') then
aLink.Data[WEIR_FLAPGATE_INDEX] := TokList[6];
if (nToks >= 8) and not SameText(TokList[7], '*') then
aLink.Data[WEIR_CONTRACT_INDEX] := TokList[7];
if (nToks >= 9) and not SameText(TokList[8], '*') then
aLink.Data[WEIR_END_COEFF_INDEX] := TokList[8];
if (nToks >= 10) and not SameText(TokList[9], '*') then
aLink.Data[WEIR_SURCHARGE_INDEX] := TokList[9];

//// Following section added for release 5.1.010. //(5.1.010)
if (nToks >= 11) and not SameText(TokList[10], '*') then
aLink.Data[WEIR_ROAD_WIDTH_INDEX] := TokList[10];
if (nToks >= 12) and not SameText(TokList[11], '*') then
aLink.Data[WEIR_ROAD_SURF_INDEX] := TokList[11];
////

aLink.Data[COMMENT_INDEX] := Comment;
Result := 0;
end;
end;
end;

function ReadOutletData: Integer;
//-----------------------------------------------------------------------------
// Reads outlet data from a line of input.
//-----------------------------------------------------------------------------
var
aLink : TLink;
aNode1: TNode;
aNode2: TNode;
ID : String;
N : Integer;
begin
if nToks < 6
then Result := ErrMsg(ITEMS_ERR, '')
else begin
ID := TokList[0];
aNode1 := FindNode(TokList[1]);
aNode2 := FindNode(TokList[2]);
if (aNode1 = nil) then Result := ErrMsg(NODE_ERR, TokList[1])
else if (aNode2 = nil) then Result := ErrMsg(NODE_ERR, TokList[2])
else begin
aLink := TLink.Create;
LinkList.AddObject(ID, aLink);
aLink.Ltype := OUTLET;
aLink.Node1 := aNode1;
aLink.Node2 := aNode2;
aLink.Zindex := -1;
Uutils.CopyStringArray(Project.DefProp[OUTLET].Data, aLink.Data);
Project.Lists[OUTLET].AddObject(ID, aLink);
Project.HasItems[OUTLET] := True;
aLink.Data[OUTLET_CREST_INDEX] := TokList[3];

//... added for backwards compatibility
if SameText(TokList[4], 'TABULAR') then TokList[4] := 'TABULAR/DEPTH';
if SameText(TokList[4], 'FUNCTIONAL') then TokList[4] := 'FUNCTIONAL/DEPTH';
aLink.Data[OUTLET_TYPE_INDEX] := TokList[4];

if AnsiContainsText(TokList[4], 'TABULAR') then
begin
aLink.Data[OUTLET_QTABLE_INDEX] := TokList[5];
N := 6;
end
else begin
if Ntoks < 7 then
begin
Result := ErrMsg(ITEMS_ERR, '');
Exit;
end
else
begin
aLink.Data[OUTLET_QCOEFF_INDEX] := TokList[5];
aLink.Data[OUTLET_QEXPON_INDEX] := TokList[6];
N := 7;
end;
end;
if Ntoks > N then aLink.Data[OUTLET_FLAPGATE_INDEX] := TokList[N];
aLink.Data[COMMENT_INDEX ] := Comment;
Result := 0;
end;
end;
end;

function GetXsectShape(const S: String): Integer;
//-----------------------------------------------------------------------------
// Finds the code number corresponding to cross section shape S.
//-----------------------------------------------------------------------------
var
I: Integer;
begin
for I := 0 to High(Dxsect.XsectShapes) do
begin
if CompareText(S, Dxsect.XsectShapes[I].Text[1]) = 0 then
begin
Result := I;
Exit;
end;
end;
Result := -1;
end;

//// New procedure added to release 5.1.008. //// //(5.1.008)
procedure CheckForStdSize;
//-----------------------------------------------------------------------------
// Converts from old format for standard size ellipse and arch pipes
// to new format.
//-----------------------------------------------------------------------------
var
J: Integer;
X: Extended;
begin
// Old format had size code as 3rd token and 0 for 4th token
J := StrToIntDef(TokList[2], 0);
Uutils.GetExtended(TokList[3], X);
if (J > 0) and (X = 0) then
begin
// New format has 5th token as size code
TokList[4] := TokList[2];
TokList[2] := '0';
TokList[3] := '0';
end;
end;

function ReadXsectionData: Integer;
//-----------------------------------------------------------------------------
// Reads cross section data froma line of input.
//-----------------------------------------------------------------------------
var
I : Integer;
ID : String;
aLink : TLink;
begin
if nToks < 3
then Result := ErrMsg(ITEMS_ERR, '')
else begin
ID := TokList[0];
aLink := FindLink(ID);
if (aLink = nil)
then Result := ErrMsg(LINK_ERR, TokList[0])
else begin
I := GetXsectShape(TokList[1]);
if I < 0 then Result := ErrMsg(KEYWORD_ERR, TokList[1])
else case aLink.Ltype of

CONDUIT:
begin
aLink.Data[CONDUIT_SHAPE_INDEX] := TokList[1];
if I = Dxsect.IRREG_SHAPE_INDEX then
begin
aLink.Data[CONDUIT_TSECT_INDEX] := TokList[2];
aLink.Data[CONDUIT_GEOM1_INDEX] := ''; //(5.1.008)
Result := 0;
end

else begin
if nToks < 6 then Result := ErrMsg(ITEMS_ERR, '')
else begin
{
//// Added to release 5.1.008. //// //(5.1.008)
if I in [Dxsect.HORIZ_ELLIPSE_SHAPE_INDEX,
Dxsect.VERT_ELLIPSE_SHAPE_INDEX,
Dxsect.ARCH_SHAPE_INDEX]
then CheckForStdSize;
}
aLink.Data[CONDUIT_GEOM1_INDEX] := TokList[2];
aLink.Data[CONDUIT_GEOM2_INDEX] := TokList[3];
aLink.Data[CONDUIT_GEOM3_INDEX] := TokList[4];
aLink.Data[CONDUIT_GEOM4_INDEX] := TokList[5];
if Ntoks > 6 then aLink.Data[CONDUIT_BARRELS_INDEX] := TokList[6];
if Ntoks > 7 then aLink.Data[CONDUIT_CULVERT_INDEX] := TokList[7];
if I = Dxsect.CUSTOM_SHAPE_INDEX then
aLink.Data[CONDUIT_TSECT_INDEX] := TokList[3];
Result := 0;
end;
end;
end;

ORIFICE:
begin
if not I in [0, 1] then Result := ErrMsg(XSECT_ERR, TokList[0])
else begin
aLink.Data[ORIFICE_SHAPE_INDEX] := TokList[1];
aLink.Data[ORIFICE_HEIGHT_INDEX] := TokList[2];
aLink.Data[ORIFICE_WIDTH_INDEX] := TokList[3];
Result := 0;
end;
end;

WEIR:
begin
if not I in [2, 3, 4] then Result := ErrMsg(XSECT_ERR, TokList[0])
else begin
aLink.Data[WEIR_SHAPE_INDEX] := TokList[1];
aLink.Data[WEIR_HEIGHT_INDEX] := TokList[2];
aLink.Data[WEIR_WIDTH_INDEX] := TokList[3];
aLink.Data[WEIR_SLOPE_INDEX] := TokList[4];
Result := 0;
end;
end;

else Result := 0;
end;
end;
end;
end;

function ReadTransectData: Integer;
//-----------------------------------------------------------------------------
// Reads transect data from a line of input.
//-----------------------------------------------------------------------------
var
I : Integer;
K : Integer;
N : Integer;
ID : String;
Tsect : TTransect;
begin
Result := 0;
if SameText(TokList[0], 'NC') then
begin
if nToks < 4 then Result := ErrMsg(ITEMS_ERR, '')
else for I := 1 to 3 do ManningsN[I] := TokList[I];
TsectComment := Comment;
Exit;
end;

if SameText(TokList[0], 'X1') then
begin
if nToks < 2 then Exit;
ID := TokList[1];
Tsect := TTransect.Create;

if Length(Comment) > 0 then TsectComment := Comment;
Tsect.Comment := TsectComment;

Project.Lists[TRANSECT].AddObject(ID, Tsect);
Project.HasItems[TRANSECT] := True;
Tsect.Data[TRANSECT_N_LEFT] := ManningsN[1];
Tsect.Data[TRANSECT_N_RIGHT] := ManningsN[2];
Tsect.Data[TRANSECT_N_CHANNEL] := ManningsN[3];
if nToks < 10 then Result := ErrMsg(ITEMS_ERR, '')
else
begin
Tsect.Data[TRANSECT_X_LEFT] := TokList[3];
Tsect.Data[TRANSECT_X_RIGHT] := TokList[4];
Tsect.Data[TRANSECT_L_FACTOR] := TokList[7];
Tsect.Data[TRANSECT_X_FACTOR] := TokList[8];
Tsect.Data[TRANSECT_Y_FACTOR] := TokList[9];
end;
Exit;
end;

if SameText(TokList[0], 'GR') then
begin
N := Project.Lists[TRANSECT].Count;
if N = 0 then Result := ErrMsg(TRANSECT_ERR, '')
else begin
Tsect := TTransect(Project.Lists[TRANSECT].Objects[N-1]);
K := 1;
while K + 1 < Ntoks do
begin
Tsect.Ydata.Add(TokList[K]);
Tsect.Xdata.Add(TokList[K+1]);
K := K + 2;
end;
end;
Exit;
end;
end;

function ReadLossData: Integer;
//-----------------------------------------------------------------------------
// Reads conduit loss data from a line of input.
//-----------------------------------------------------------------------------
var
ID : String;
aLink : TLink;
begin
if nToks < 4
then Result := ErrMsg(ITEMS_ERR, '')
else begin
ID := TokList[0];
aLink := FindLink(ID);
if (aLink = nil) then Result := ErrMsg(LINK_ERR, ID)
else if (aLink.Ltype <> CONDUIT) then Result := 0
else begin
aLink.Data[CONDUIT_ENTRY_LOSS_INDEX] := TokList[1];
aLink.Data[CONDUIT_EXIT_LOSS_INDEX] := TokList[2];
aLink.Data[CONDUIT_AVG_LOSS_INDEX] := TokList[3];
if nToks >= 5
then aLink.Data[CONDUIT_CHECK_VALVE_INDEX] := TokList[4];
if nToks >= 6
then aLink.Data[CONDUIT_SEEPAGE_INDEX] := TokList[5];
Result := 0;
end;
end;
end;

function ReadPollutantData: Integer;
//-----------------------------------------------------------------------------
// Reads pollutant data from a line of input.
//-----------------------------------------------------------------------------
var
ID : String;
aPollut : TPollutant;
X : Single;
begin
if nToks < 5
then Result := ErrMsg(ITEMS_ERR, '')
else begin

// Add new pollutant to project
ID := TokList[0];
aPollut := TPollutant.Create;
Uutils.CopyStringArray(Project.DefProp[POLLUTANT].Data, aPollut.Data);
Project.Lists[POLLUTANT].AddObject(ID, aPollut);
Project.HasItems[POLLUTANT] := True;

// Parse units & concens.
aPollut.Data[POLLUT_UNITS_INDEX] := TokList[1];
aPollut.Data[POLLUT_RAIN_INDEX] := TokList[2];
aPollut.Data[POLLUT_GW_INDEX] := TokList[3];

// This is for old format
if (Ntoks = 5)
or ( (Ntoks = 7) and Uutils.GetSingle(TokList[6], X) ) then
begin
aPollut.Data[POLLUT_DECAY_INDEX] := TokList[4];
if nToks >= 7 then
begin
aPollut.Data[POLLUT_COPOLLUT_INDEX] := TokList[5];
aPollut.Data[POLLUT_FRACTION_INDEX] := TokList[6];
end;
end

// This is for new format
else
begin
aPollut.Data[POLLUT_II_INDEX] := TokList[4];
if Ntoks >= 6 then aPollut.Data[POLLUT_DECAY_INDEX] := TokList[5];
if nToks >= 7 then aPollut.Data[POLLUT_SNOW_INDEX] := TokList[6];
if Ntoks >= 9 then
begin
aPollut.Data[POLLUT_COPOLLUT_INDEX] := TokList[7];
aPollut.Data[POLLUT_FRACTION_INDEX] := TokList[8];
end;
if Ntoks >= 10 then aPollut.Data[POLLUT_DWF_INDEX] := TokList[9];
if Ntoks >= 11 then aPollut.Data[POLLUT_INIT_INDEX] := TokList[10];
end;
Result := 0;
end;
end;

function ReadLanduseData: Integer;
//-----------------------------------------------------------------------------
// Reads land use data from a line of input.
//-----------------------------------------------------------------------------
var
ID : String;
aLanduse : TLanduse;
aNonPtSource : TNonpointSource;
J : Integer;
begin
ID := TokList[0];
aLanduse := TLanduse.Create;
for J := 0 to Project.Lists[POLLUTANT].Count - 1 do
begin
aNonPtSource := TNonpointSource.Create;
aLanduse.NonpointSources.AddObject(Project.Lists[POLLUTANT].Strings[J],
aNonPtSource);
end;
Project.Lists[LANDUSE].AddObject(ID, aLanduse);
Project.HasItems[LANDUSE] := True;
if Ntoks > 1 then aLanduse.Data[LANDUSE_CLEANING_INDEX] := TokList[1];
if Ntoks > 2 then aLanduse.Data[LANDUSE_AVAILABLE_INDEX] := TokList[2];
if Ntoks > 3 then aLanduse.Data[LANDUSE_LASTCLEAN_INDEX] := TokList[3];
aLanduse.Data[COMMENT_INDEX ] := Comment;
Result := 0;
end;

function ReadBuildupData: Integer;
//-----------------------------------------------------------------------------
// Reads pollutant buildup function data from a line of input.
//-----------------------------------------------------------------------------
var
LanduseIndex : Integer;
PollutIndex : Integer;
aLanduse : TLanduse;
aNonpointSource: TNonpointSource;
J : Integer;
begin
if nToks < 7
then Result := ErrMsg(ITEMS_ERR, '')
else begin
LanduseIndex := Project.Lists[LANDUSE].IndexOf(TokList[0]);
PollutIndex := Project.Lists[POLLUTANT].IndexOf(TokList[1]);
if (LanduseIndex < 0) then Result := ErrMsg(LANDUSE_ERR, TokList[0])
else if (PollutIndex < 0) then Result := ErrMsg(POLLUT_ERR, TokList[1])
else begin
aLanduse := TLanduse(Project.Lists[LANDUSE].Objects[LanduseIndex]);
aNonpointSource :=
TNonpointSource(aLanduse.NonpointSources.Objects[PollutIndex]);
for J := 2 to 6 do
aNonpointSource.BuildupData[J-2] := TokList[J];
Result := 0;
end;
end;
end;

function ReadWashoffData: Integer;
//-----------------------------------------------------------------------------
// Reads pollutant washoff function data from a line of input.
//-----------------------------------------------------------------------------
var
LanduseIndex : Integer;
PollutIndex : Integer;
aLanduse : TLanduse;
aNonpointSource: TNonpointSource;
J : Integer;
begin
if nToks < 7
then Result := ErrMsg(ITEMS_ERR, '')
else begin
LanduseIndex := Project.Lists[LANDUSE].IndexOf(TokList[0]);
PollutIndex := Project.Lists[POLLUTANT].IndexOf(TokList[1]);
if (LanduseIndex < 0) then Result := ErrMsg(LANDUSE_ERR, TokList[0])
else if (PollutIndex < 0) then Result := ErrMsg(POLLUT_ERR, TokList[1])
else begin
aLanduse := TLanduse(Project.Lists[LANDUSE].Objects[LanduseIndex]);
aNonpointSource :=
TNonpointSource(aLanduse.NonpointSources.Objects[PollutIndex]);
for J := 2 to 6 do
aNonpointSource.WashoffData[J-2] := TokList[J];
Result := 0;
end;
end;
end;

function ReadCoverageData: Integer;
//-----------------------------------------------------------------------------
// Reads land use coverage data from a line of input.
//-----------------------------------------------------------------------------
var
MaxToks: Integer;
X : Single;
S : TSubcatch;
S1 : String;
I : Integer;
begin
Result := 0;
S := FindSubcatch(TokList[0]);
if S = nil
then Result := ErrMsg(SUBCATCH_ERR, TokList[0])
else begin
MaxToks := 3;
while (MaxToks <= nToks) do
begin
if not Uutils.GetSingle(TokList[MaxToks-1], X) then
begin
Result := ErrMsg(NUMBER_ERR, TokList[MaxToks-1]);
break;
end;
S1 := TokList[MaxToks-2];
I := S.LandUses.IndexOfName(S1);
S1 := TokList[MaxToks-2] + '=' + TokList[MaxToks-1];
if I < 0
then S.LandUses.Add(S1)
else S.Landuses[I] := S1;
MaxToks := MaxToks + 2;
end;
S.Data[SUBCATCH_LANDUSE_INDEX] := IntToStr(S.LandUses.Count);
end;
end;

function ReadTreatmentData(Line: String): Integer;
//-----------------------------------------------------------------------------
// Reads pollutant treatment function from a line of input.
//-----------------------------------------------------------------------------
var
S : String;
aNode : TNode;
I : Integer;
begin
if Ntoks < 3
then Result := ErrMsg(ITEMS_ERR, '')
else begin
aNode := FindNode(TokList[0]);
if (aNode = nil) then Result := ErrMsg(NODE_ERR, TokList[0])
else if Project.Lists[POLLUTANT].IndexOf(TokList[1]) < 0 then
Result := ErrMsg(POLLUT_ERR, TokList[1])
else begin
I := aNode.Treatment.IndexOfName(TokList[1]);
S := Copy(Line, Pos(TokList[1], Line)+Length(TokList[1]), Length(Line));
S := TokList[1] + '=' + Trim(S);
if I < 0 then
aNode.Treatment.Add(S)
else
aNode.Treatment[I] := S;
aNode.Data[NODE_TREAT_INDEX] := 'YES';
Result := 0;
end;
end;
end;

function ReadExInflowData: Integer;
//-----------------------------------------------------------------------------
// Reads external inflow data from a line of input.
//-----------------------------------------------------------------------------
var
S : array[1..7] of String;
Inflow: String;
I : Integer;
aNode : TNode;
begin

if Ntoks < 3
then Result := ErrMsg(ITEMS_ERR, '')
else begin
aNode := FindNode(TokList[0]);
if (aNode = nil) then Result := ErrMsg(NODE_ERR, TokList[0])
else begin
S[1] := TokList[1]; // Constituent name
S[2] := TokList[2]; // Time Series name
S[3] := 'FLOW';
S[4] := '1.0';
if not SameText(S[1], 'FLOW') then
begin
if nToks >= 4 then S[3] := TokList[3] else S[3] := 'CONCEN';
if nToks >= 5 then S[4] := TokList[4] else S[4] := '1.0';
end;
if nToks >= 6 then S[5] := TokList[5] else S[5] := '1.0';
if nToks >= 7 then S[6] := TokList[6] else S[6] := '';
if nToks >= 8 then S[7] := TokList[7] else S[7] := '';
Inflow := S[1] + '=' + S[2] + #13 + S[3] + #13 + S[4] + #13 +
S[5] + #13 + S[6] + #13 + S[7];
I := aNode.DXInflow.IndexOfName(S[1]);
if I < 0 then aNode.DXInflow.Add(Inflow)
else aNode.DXInflow[I] := Inflow;
aNode.Data[NODE_INFLOWS_INDEX] := 'YES';
Result := 0;
end;
end;
end;

function ReadDWInflowData: Integer;
//-----------------------------------------------------------------------------
// Reads dry weather inflow data from a line of input.
//-----------------------------------------------------------------------------
var
M : Integer;
S : String;
S1 : String;
I : Integer;
aNode: TNode;
begin
if Ntoks < 3
then Result := ErrMsg(ITEMS_ERR, '')
else begin
aNode := FindNode(TokList[0]);
if (aNode = nil) then Result := ErrMsg(NODE_ERR, TokList[0])
else begin
S1 := TokList[1];
S := S1 + '=' + TokList[2];
for M := 3 to Ntoks-1 do S := S + #13 + TokList[M];
I := aNode.DWInflow.IndexOfName(S1);
if I < 0
then aNode.DWInflow.Add(S)
else aNode.DWInflow[I] := S;
aNode.Data[NODE_INFLOWS_INDEX] := 'YES';
Result := 0;
end;
end;
end;

function ReadPatternData: Integer;
//-----------------------------------------------------------------------------
// Reads time pattern data from a line of input.
//-----------------------------------------------------------------------------
var
ID: String;
Index: Integer;
aPattern: TPattern;
PatType: Integer;
J: Integer;
begin
if nToks < 2
then Result := ErrMsg(ITEMS_ERR, '')
else begin
J := 1;
ID := TokList[0];
Index := Project.Lists[PATTERN].IndexOf(ID);
if Index < 0 then
begin
aPattern := TPattern.Create;
aPattern.Comment := Comment;
Project.Lists[PATTERN].AddObject(ID, aPattern);
Project.HasItems[PATTERN] := True;
PatType := Uutils.FindKeyWord(TokList[1], PatternTypes, 7);
if PatType < 0 then
begin
Result := ErrMsg(KEYWORD_ERR, TokList[1]);
exit;
end;
aPattern.PatternType := PatType;
J := 2;
end
else aPattern := TPattern(Project.Lists[PATTERN].Objects[Index]);
while (J < nToks) and (aPattern.Count <= High(aPattern.Data)) do
begin
aPattern.Data[aPattern.Count] := TokList[J];
Inc(J);
Inc(aPattern.Count);
end;
Result := 0;
end;
end;

function ReadIIInflowData: Integer;
//-----------------------------------------------------------------------------
// Reads RDII inflow data from a line of input.
//-----------------------------------------------------------------------------
var
aNode: TNode;

begin
if Ntoks < 3
then Result := ErrMsg(ITEMS_ERR, '')
else begin
aNode := FindNode(TokList[0]);
if (aNode = nil) then Result := ErrMsg(NODE_ERR, TokList[0])
else begin
aNode.IIInflow.Clear;
aNode.IIInflow.Add(TokList[1]);
aNode.IIInflow.Add(TokList[2]);
aNode.Data[NODE_INFLOWS_INDEX] := 'YES';
Result := 0;
end;
end;
end;

function ReadLoadData: Integer;
//-----------------------------------------------------------------------------
// Reads initial pollutant loading data from a line of input.
//-----------------------------------------------------------------------------
var
X : Single;
S : TSubcatch;
S1 : String;
I : Integer;

begin
S := FindSubcatch(TokList[0]);
if S = nil
then Result := ErrMsg(SUBCATCH_ERR, TokList[0])
else if Project.Lists[POLLUTANT].IndexOf(TokList[1]) < 0
then Result := ErrMsg(POLLUT_ERR, TokList[1])
else if not Uutils.GetSingle(TokList[2], X)
then Result := ErrMsg(NUMBER_ERR, TokList[2])
else
begin
S1 := TokList[1] + '=' + TokList[2];
I := S.Loadings.IndexOfName(TokList[1]);
if I < 0
then S.Loadings.Add(S1)
else S.Loadings[I] := S1;
S.Data[SUBCATCH_LOADING_INDEX] := 'YES';
Result := 0;
end;
end;

function ReadCurveData: Integer;
//-----------------------------------------------------------------------------
// Reads curve data from a line of input.
//-----------------------------------------------------------------------------
var
Index : Integer;
K : Integer;
L : Integer;
M : Integer;
ObjType : Integer;
ID : String;
aCurve : TCurve;
begin
// Check for too few tokens
if Ntoks < 3
then Result := ErrMsg(ITEMS_ERR, '')
else begin

// Check if curve ID is same as for previous line
ID := TokList[0];
if (ID = PrevID) then
begin
Index := PrevIndex;
ObjType := CurveType;
end
else Project.FindCurve(ID, ObjType, Index);

// Create new curve if ID not in data base
K := 2;
if Index < 0 then
begin

// Check for valid curve type keyword
M := -1;
for L := 0 to High(CurveTypeOptions) do
begin
if SameText(TokList[1], CurveTypeOptions[L]) then
begin
M := L;
break;
end;
end;
if M < 0 then
begin
Result := ErrMsg(KEYWORD_ERR, TokList[1]);
Exit;
end;

// Convert curve type keyword index to a curve object category
case M of
0: ObjType := CONTROLCURVE;
1: ObjType := DIVERSIONCURVE;
2..5:
ObjType := PUMPCURVE;
6: ObjType := RATINGCURVE;
7: ObjType := SHAPECURVE;
8: ObjType := STORAGECURVE;
9: ObjType := TIDALCURVE;
end;

// Create a new curve object
aCurve := TCurve.Create;
aCurve.Comment := Comment;
aCurve.CurveType := TokList[1];
if ObjType = PUMPCURVE
then aCurve.CurveCode := M - 1
else aCurve.CurveCode := 0;
Project.Lists[ObjType].AddObject(ID, aCurve);
Project.HasItems[ObjType] := True;
Index := Project.Lists[ObjType].Count - 1;
PrevID := ID;
PrevIndex := Index;
CurveType := ObjType;
K := 3;
end;

// Add x,y values to the list maintained by the curve
aCurve := TCurve(Project.Lists[ObjType].Objects[Index]);
while K <= nToks-1 do
begin
aCurve.Xdata.Add(TokList[K-1]);
aCurve.Ydata.Add(TokList[K]);
K := K + 2;
end;
Result := 0;
end;
end;

function ReadTimeseriesData: Integer;
//-----------------------------------------------------------------------------
// Reads time series data from a line of input.
//-----------------------------------------------------------------------------
const
NEEDS_DATE = 1;
NEEDS_TIME = 2;
NEEDS_VALUE = 3;
var
Index : Integer;
State : Integer;
K : Integer;
ID : String;
StrDate : String;
aTseries : TTimeseries;
begin
// Check for too few tokens
Result := -1;
if Ntoks < 3 then Result := ErrMsg(ITEMS_ERR, '');

// Check if series ID is same as for previous line
ID := TokList[0];
if (ID = PrevID) then Index := PrevIndex
else Index := Project.Lists[TIMESERIES].IndexOf(ID);

// If starting input for a new series then create it
if Index < 0 then
begin
aTseries := TTimeseries.Create;
aTseries.Comment := Comment;
Project.Lists[TIMESERIES].AddObject(ID,aTseries);
Project.HasItems[TIMESERIES] := True;
Index := Project.Lists[TIMESERIES].Count - 1;
PrevID := ID;
PrevIndex := Index;
end;
aTseries := TTimeseries(Project.Lists[TIMESERIES].Objects[Index]);

// Check if external file name used
if SameText(TokList[1], 'FILE') then
begin
aTseries.Filename := TokList[2];
Result := 0;
Exit;
end;

// Add values to the list maintained by the timeseries
State := NEEDS_DATE;
K := 1;
while K < nToks do
begin
case State of

NEEDS_DATE:
begin
try
StrDate := Uutils.ConvertDate(TokList[K]);
StrToDate(StrDate, MyFormatSettings);
aTseries.Dates.Add(StrDate);
Inc(K);
if K >= nToks then break;
except
On EconvertError do aTseries.Dates.Add('');
end;
State := NEEDS_TIME;
end;

NEEDS_TIME:
begin
aTseries.Times.Add(TokList[K]);
Inc(K);
if K >= nToks then break;
State := NEEDS_VALUE;
end;

NEEDS_VALUE:
begin
aTseries.Values.Add(TokList[K]);
Result := 0;
State := NEEDS_DATE;
Inc(K);
end;
end;
end;
if Result = -1 then Result := ErrMsg(ITEMS_ERR, '');
end;

function ReadControlData(Line: String): Integer;
//-----------------------------------------------------------------------------
// Reads a control rule statement from line of input.
//-----------------------------------------------------------------------------
begin
Project.ControlRules.Add(Line);
Result := 0;
end;

function ReadLidUsageData: Integer;
//-----------------------------------------------------------------------------
// Reads LID usage data from line of input.
//-----------------------------------------------------------------------------
var
aSubcatch: TSubcatch;
begin
aSubcatch := FindSubcatch(TokList[0]);
if aSubcatch = nil then Result := ErrMsg(SUBCATCH_ERR, TokList[0])
else Result := Ulid.ReadLIDUsageData(aSubcatch, TokList, Ntoks);
end;

procedure ReadReportOption(Index: Integer);
begin
if (Ntoks >= 2) and SameText(TokList[1], 'YES') then
Project.Options.Data[Index] := 'YES'
else
Project.Options.Data[Index] := 'NO';
end;

function ReadReportData: Integer;
//-----------------------------------------------------------------------------
// Reads reporting options from a line of input.
//-----------------------------------------------------------------------------
begin
if SameText(TokList[0], 'CONTROLS')
then ReadReportOption(REPORT_CONTROLS_INDEX)
else if SameText(TokList[0], 'INPUT')
then ReadReportOption(REPORT_INPUT_INDEX)
else ReportingForm.Import(TokList, Ntoks);
Result := 0;
end;

function ReadFileData: Integer;
//-----------------------------------------------------------------------------
// Reads interface file usage from a line of input.
//-----------------------------------------------------------------------------
var
Fname: String;
begin
if Ntoks < 3
then Result := ErrMsg(ITEMS_ERR, '')
else begin
Fname := TokList[2];
if ExtractFilePath(Fname) = ''
then Fname := ExtractFilePath(Uglobals.InputFileName) + Fname;
Project.IfaceFiles.Add(TokList[0] + ' ' + TokList[1] + ' ' +
'"' + Fname + '"');
Result := 0;
end;
end;

//// This function was added to release 5.1.007. //// //(5.1.007)
function ReadAdjustmentData: Integer;
//-----------------------------------------------------------------------------
// Reads climate adjustments from a line of input.
//-----------------------------------------------------------------------------
var
I: Integer;
begin
Result := 0;
if Ntoks < 2 then exit;
if SameText(TokList[0], 'Temperature') then
begin
if Ntoks < 13 then Result := ErrMsg(ITEMS_ERR, '')
else with Project.Climatology do
begin
for I := 0 to 11 do
if StrToFloatDef(TokList[I+1], 0.0) = 0.0
then TempAdjust[I] := ''
else TempAdjust[I] := TokList[I+1];
end;
end
else if SameText(TokList[0], 'Evaporation') then
begin
if Ntoks < 13 then Result := ErrMsg(ITEMS_ERR, '')
else with Project.Climatology do
begin
for I := 0 to 11 do
if StrToFloatDef(TokList[I+1], 0.0) = 0.0
then EvapAdjust[I] := ''
else EvapAdjust[I] := TokList[I+1];
end;
end
else if SameText(TokList[0], 'Rainfall') then
begin
if Ntoks < 13 then Result := ErrMsg(ITEMS_ERR, '')
else with Project.Climatology do
begin
for I := 0 to 11 do
if StrToFloatDef(TokList[I+1], 1.0) = 1.0
then RainAdjust[I] := ''
else RainAdjust[I] := TokList[I+1];
end;
end

//// Added to release 5.1.008. //// //(5.1.008)
else if SameText(TokList[0], 'Conductivity') then
begin
if Ntoks < 13 then Result := ErrMsg(ITEMS_ERR, '')
else with Project.Climatology do
begin
for I := 0 to 11 do
if StrToFloatDef(TokList[I+1], 1.0) = 1.0
then CondAdjust[I] := ''
else CondAdjust[I] := TokList[I+1];
end;
end;
////////////////////////////////////////////////////////
end;

//// This function was added to release 5.1.011. //// //(5.1.011)
function ReadEventData(Line: String): Integer;
//-----------------------------------------------------------------------------
// Reads hydraulic event data from a line of input.
//-----------------------------------------------------------------------------
begin
Result := 0;
if Length(Line) = 0 then exit;
if LeftStr(Line,2) = ';;' then exit;
Project.Events.Add(Line);
end;

function ReadOptionData: Integer;
//-----------------------------------------------------------------------------
// Reads an analysis option from a line of input.
//-----------------------------------------------------------------------------
var
Index : Integer;
Keyword : String;
S : String;
S2: String;
I : Integer;
X : Single;
T : Extended;
begin
// Check which keyword applies
Result := 0;
if Ntoks < 2 then exit;
Keyword := TokList[0];
if SameText(Keyword, 'TEMPDIR') then exit;
Index := Uutils.FindKeyWord(Keyword, OptionLabels, 17);
case Index of

-1: Result := ErrMsg(KEYWORD_ERR, Keyword);

ROUTING_MODEL_INDEX:
begin
if SameText(TokList[1], 'NONE') then
begin
Project.Options.Data[IGNORE_ROUTING_INDEX] := 'YES';
Exit;
end;

I := Uutils.FindKeyWord(TokList[1], OldRoutingOptions, 3);
if I >= 0 then TokList[1] := RoutingOptions[I];
end;

START_DATE_INDEX, REPORT_START_DATE_INDEX, END_DATE_INDEX:
begin
S := Uutils.ConvertDate(TokList[1]);
try
StrToDate(S, MyFormatSettings);
TokList[1] := S;
except
on EConvertError do Result := ErrMsg(DATE_ERR, '');
end;
end;

START_TIME_INDEX, REPORT_START_TIME_INDEX, END_TIME_INDEX:
begin
S := TokList[1];
try
StrToTime(S, MyFormatSettings);
TokList[1] := S;
except
on EConvertError do Result := ErrMsg(DATE_ERR, '');
end;
end;

SWEEP_START_INDEX, SWEEP_END_INDEX:
begin
S := Uutils.ConvertDate(TokList[1]);
S2 := S + '/1947';
try
StrToDate(S2, MyFormatSettings);
TokList[1] := S;
except
on EConvertError do Result := ErrMsg(DATE_ERR, '');
end;
end;

WET_STEP_INDEX, DRY_STEP_INDEX, REPORT_STEP_INDEX:
begin
S := TokList[1];
if Uutils.StrHoursToTime(S) = -1 then Result := ErrMsg(TIMESTEP_ERR, '');
end;

ROUTING_STEP_INDEX:
begin
S := TokList[1];
T := 0.0;
if not Uutils.GetExtended(S, T) then
begin
T := Uutils.StrHoursToTime(S)*86400.;
if T <= 0.0 then Result := ErrMsg(TIMESTEP_ERR, '')
else TokList[1] := Format('%.0f',[T]);
end;
end;

VARIABLE_STEP_INDEX:
begin
if Uutils.GetSingle(TokList[1], X) then
TokList[1] := IntToStr(Round(100.0*X))
else
TokList[1] := '0';
end;

INERTIAL_DAMPING_INDEX:
begin
if Uutils.GetSingle(TokList[1], X) then
begin
if X = 0 then TokList[1] := 'NONE'
else TokList[1] := 'PARTIAL';
end;
end;

// This option is now fixed to SWMM 4.
COMPATIBILITY_INDEX:
begin
TokList[1] := '4';
end;

MIN_ROUTE_STEP_INDEX, //(5.1.008)
LENGTHEN_STEP_INDEX,
MIN_SURFAREA_INDEX,
MIN_SLOPE_INDEX,
MAX_TRIALS_INDEX,
HEAD_TOL_INDEX,
SYS_FLOW_TOL_INDEX,
LAT_FLOW_TOL_INDEX:
begin
Uutils.GetSingle(TokList[1], X);
if X <= 0 then TokList[1] := '0';
end;

NORMAL_FLOW_LTD_INDEX:
begin
if SameText(TokList[1], 'NO') or SameText(TokList[1], 'SLOPE')
then TokList[1] := 'SLOPE'
else if SameText(TokList[1], 'YES') or SameText(TokList[1], 'FROUDE')
then TokList[1] := 'FROUDE'
else if SameText(TokList[1], 'BOTH') then TokList[1] := 'BOTH'
else Result := ErrMsg(KEYWORD_ERR, TokList[1]);
end;

FORCE_MAIN_EQN_INDEX:
begin
I := Uutils.FindKeyWord(TokList[1], ForceMainEqnOptions, 3);
if I < 0 then Result := ErrMsg(KEYWORD_ERR, TokList[1])
else TokList[1] := ForceMainEqnOptions[I];
end;

LINK_OFFSETS_INDEX:
begin
I := Uutils.FindKeyWord(TokList[1], LinkOffsetsOptions, 10);
if I < 0 then Result := ErrMsg(KEYWORD_ERR, TokList[1])
else TokList[1] := LinkOffsetsOptions[I];
end;

IGNORE_RAINFALL_INDEX,
IGNORE_SNOWMELT_INDEX,
IGNORE_GRNDWTR_INDEX,
IGNORE_ROUTING_INDEX,
IGNORE_QUALITY_INDEX:
begin
if not SameText(TokList[1], 'YES') and not SameText(TokList[1], 'NO')
then Result := ErrMsg(KEYWORD_ERR, TokList[1]);
end;

//// Following section added to release 5.1.010. //// //(5.1.010)
NUM_THREADS_INDEX:
begin
I := StrToIntDef(TokList[1], 1);
if I < 0 then I := 1;
if (I = 0) or (I > Uutils.GetCPUs) then I := Uutils.GetCPUs;
TokList[1] := IntToStr(I);
end;
////

end;
if Result = 0 then Project.Options.Data[Index] := TokList[1];
end;

function ReadTagData: Integer;
//-----------------------------------------------------------------------------
// Reads in tag data from a line of input.
//-----------------------------------------------------------------------------
const
TagTypes: array[0..3] of PChar = ('Gage', 'Subcatch', 'Node', 'Link');
var
I, J : Integer;
aNode: TNode;
aLink: TLink;
begin
Result := 0;
if Ntoks < 3
then Result := ErrMsg(ITEMS_ERR, '')
else begin
I := Uutils.FindKeyWord(TokList[0], TagTypes, 4);
case I of

-1: Result := ErrMsg(KEYWORD_ERR, TokList[0]);

0: begin
J := Project.Lists[RAINGAGE].IndexOf(TokList[1]);
if J >= 0 then with Project.GetGage(J) do Data[TAG_INDEX] := TokList[2];
end;

1: begin
J := Project.Lists[SUBCATCH].IndexOf(TokList[1]);
if J >= 0 then with Project.GetSubcatch(SUBCATCH, J) do
Data[TAG_INDEX] := TokList[2];
end;

2: begin
aNode := FindNode(TokList[1]);
if (aNode <> nil) then aNode.Data[TAG_INDEX] := TokList[2];
end;

3: begin
aLink := FindLink(TokList[1]);
if (aLink <> nil) then aLink.Data[TAG_INDEX] := TokList[2];
end;
end;
end;
end;

function ReadSymbolData: Integer;
//-----------------------------------------------------------------------------
// Reads rain gage coordinate data from a line of input.
//-----------------------------------------------------------------------------
var
J : Integer;
X, Y : Extended;
aGage : TRaingage;
begin
Result := 0;
if (Ntoks < 3)
then Result := ErrMsg(ITEMS_ERR, '')
else begin

// Locate the gage ID in the database
J := Project.Lists[RAINGAGE].IndexOf(TokList[0]);

// If gage exists then assign it X & Y coordinates
if (J >= 0) then
begin
aGage := Project.GetGage(J);
if not Uutils.GetExtended(TokList[1], X) then
Result := ErrMsg(NUMBER_ERR, TokList[1])
else if not Uutils.GetExtended(TokList[2], Y) then
Result := ErrMsg(NUMBER_ERR, TokList[2])
else
begin
aGage.X := X;
aGage.Y := Y;
end;
end;
end;
end;

function ReadMapData: Integer;
//-----------------------------------------------------------------------------
// Reads map dimensions data from a line of input.
//-----------------------------------------------------------------------------
var
I : Integer;
Index : Integer;
Keyword : String;
X : array[1..4] of Extended;
begin
// Check which keyword applies
Result := 0;
Keyword := TokList[0];
Index := Uutils.FindKeyWord(Keyword, MapWords, 4);
case Index of

0: // Map dimensions
begin
if Ntoks < 5 then Result := ErrMsg(ITEMS_ERR, '')
else begin
for I := 1 to 4 do
if not Uutils.GetExtended(TokList[I], X[I]) then
Result := ErrMsg(NUMBER_ERR, TokList[I]);
if Result = 0 then with MapForm.Map.Dimensions do
begin
LowerLeft.X := X[1];
LowerLeft.Y := X[2];
UpperRight.X := X[3];
UpperRight.Y := X[4];
MapExtentSet := True;
end;
end;
end;

1: //Map units
if Ntoks > 1 then
begin
I := Uutils.FindKeyWord(Copy(TokList[1], 1, 1), MapUnits, 1);
if I < 0 then Result := ErrMsg(KEYWORD_ERR, TokList[1])
else MapForm.Map.Dimensions.Units := TMapUnits(I);
with MapForm.Map.Dimensions do
begin
if Units = muDegrees then Digits := MAXDEGDIGITS
else Digits := Umap.DefMapDimensions.Digits;
end;
end;

else Result := ErrMsg(KEYWORD_ERR, Keyword);
end;
end;

function ReadCoordData: Integer;
//-----------------------------------------------------------------------------
// Reads node coordinate data from a line of input.
//-----------------------------------------------------------------------------
var
X, Y : Extended;
aNode : TNode;
begin
Result := 0;
if (Ntoks < 3)
then Result := ErrMsg(ITEMS_ERR, '')
else begin

// Locate the node ID in the database
aNode := FindNode(TokList[0]);

// If node exists then assign it X & Y coordinates
if (aNode <> nil) then
begin
if not Uutils.GetExtended(TokList[1], X) then
Result := ErrMsg(NUMBER_ERR, TokList[1])
else if not Uutils.GetExtended(TokList[2], Y) then
Result := ErrMsg(NUMBER_ERR, TokList[2])
else
begin
aNode.X := X;
aNode.Y := Y;
end;
end;
end;
end;

function ReadVertexData: Integer;
//-----------------------------------------------------------------------------
// Reads link vertex coordinate data from a line of input.
//-----------------------------------------------------------------------------
var
X, Y : Extended;
aLink : TLink;

begin
Result := 0;
if (Ntoks < 3)
then Result := ErrMsg(ITEMS_ERR, '')
else begin

// Locate the link ID in the database
aLink := FindLink(TokList[0]);;

// If link exists then assign it X & Y coordinates
if (aLink <> nil) then
begin
if not Uutils.GetExtended(TokList[1], X) then
Result := ErrMsg(NUMBER_ERR, TokList[1])
else if not Uutils.GetExtended(TokList[2], Y) then
Result := ErrMsg(NUMBER_ERR, TokList[2])
else aLink.Vlist.Add(X, Y);
end;
end;
end;

function ReadPolygonData: Integer;
//-----------------------------------------------------------------------------
// Reads polygon coordinates associated with subcatchment outlines.
//-----------------------------------------------------------------------------
var
Index : Integer;
X, Y : Extended;
S : TSubcatch;
begin
Result := 0;
if (Ntoks < 3)
then Result := ErrMsg(ITEMS_ERR, '')
else begin

// Locate the subcatchment ID in the database
S := nil;
Index := Project.Lists[SUBCATCH].IndexOf(TokList[0]);
if Index >= 0 then S := Project.GetSubcatch(SUBCATCH, Index);

// If subcatchment exists then add a new vertex to it
if (S <> nil) then
begin
if not Uutils.GetExtended(TokList[1], X) then
Result := ErrMsg(NUMBER_ERR, TokList[1])
else if not Uutils.GetExtended(TokList[2], Y) then
Result := ErrMsg(NUMBER_ERR, TokList[2])
else S.Vlist.Add(X, Y);
end;
end;
end;

function ReadLabelData: Integer;
//-----------------------------------------------------------------------------
// Reads map label data from a line of input.
//-----------------------------------------------------------------------------
var
Ntype : Integer;
Index : Integer;
X, Y : Extended;
S : String;
aMapLabel: TMapLabel;
begin
if (Ntoks < 3)
then Result := ErrMsg(ITEMS_ERR, '')
else begin
if not Uutils.GetExtended(TokList[0], X) then
Result := ErrMsg(NUMBER_ERR, TokList[0])
else if not Uutils.GetExtended(TokList[1], Y) then
Result := ErrMsg(NUMBER_ERR, TokList[1])
else begin
S := TokList[2];
aMapLabel := TMapLabel.Create;
aMapLabel.X := X;
aMapLabel.Y := Y;
Project.Lists[MAPLABEL].AddObject(S, aMapLabel);
Index := Project.Lists[MAPLABEL].Count - 1;
aMapLabel.Text := PChar(Project.Lists[MAPLABEL].Strings[Index]);
Project.HasItems[MAPLABEL] := True;
if Ntoks >= 4 then
begin
if (Length(TokList[3]) > 0) and
Project.FindNode(TokList[3], Ntype, Index) then
aMapLabel.Anchor := Project.GetNode(Ntype, Index);
end;
if Ntoks >= 5 then aMapLabel.FontName := TokList[4];
if Ntoks >= 6 then aMapLabel.FontSize := StrToInt(TokList[5]);
if Ntoks >= 7 then
if StrToInt(TokList[6]) = 1 then aMapLabel.FontBold := True;
if Ntoks >= 8 then
if StrToInt(TokList[7]) = 1 then aMapLabel.FontItalic := True;
Result := 0;
end;
end;
end;

function ReadBackdropData: Integer;
//-----------------------------------------------------------------------------
// Reads map backdrop image information from a line of input.
//-----------------------------------------------------------------------------
var
Index : Integer;
Keyword : String;
I : Integer;
X : array[1..4] of Extended;
begin
// Check which keyword applies
Result := 0;
Keyword := TokList[0];
Index := Uutils.FindKeyWord(Keyword, BackdropWords, 4);
case Index of

0: //Backdrop file
if Ntoks > 1 then MapForm.Map.Backdrop.Filename := TokList[1];

1: // Backdrop dimensions
begin
if Ntoks < 5 then Result := ErrMsg(ITEMS_ERR, '')
else begin
for i := 1 to 4 do
if not Uutils.GetExtended(TokList[I], X[I]) then
Result := ErrMsg(NUMBER_ERR, TokList[I]);
if Result = 0 then with MapForm.Map.Backdrop do
begin
LowerLeft.X := X[1];
LowerLeft.Y := X[2];
UpperRight.X := X[3];
UpperRight.Y := X[4];
end;
end;
end;

2: //Map units - deprecated
if Ntoks > 1 then
begin
i := Uutils.FindKeyWord(Copy(TokList[1], 1, 1), MapUnits, 1);
if I < 0 then Result := ErrMsg(KEYWORD_ERR, TokList[1])
else MapForm.Map.Dimensions.Units := TMapUnits(I);
end;

3, 4: //Backdrop offset or scaling -- deprecated
begin
if Ntoks < 3 then Result := ErrMsg(ITEMS_ERR, '')
else if not Uutils.GetExtended(TokList[1], X[1]) then
Result := ErrMsg(NUMBER_ERR, TokList[1])
else if not Uutils.GetExtended(TokList[2], X[2]) then
Result := ErrMsg(NUMBER_ERR, TokList[2])
else
begin
if Index = 3 then
begin
BackdropX := X[1];
BackdropY := X[2];
end
else
begin
BackdropW := X[1];
BackdropH := X[2];
end;
end;
end;

else Result := ErrMsg(KEYWORD_ERR, Keyword);
end;
end;

function ReadProfileData: Integer;
//-----------------------------------------------------------------------------
// Reads profile plot data from a line of input.
//-----------------------------------------------------------------------------
var
I, J: Integer;
S : String;
begin
Result := 0;
if (Ntoks < 2) then Exit;

// Locate the profile name in the database
I := Project.ProfileNames.IndexOf(TokList[0]);

// If profile does not exist then create it
if (I < 0) then
begin
Project.ProfileNames.Add(TokList[0]);
I := Project.ProfileNames.Count-1;
S := '';
Project.ProfileLinks.Add(S);
end
else S := Project.ProfileLinks[I] + #13;

// Add each remaining token to the list of links in the profile
S := S + TokList[1];
for J := 2 to Ntoks-1 do
S := S + #13 + TokList[J];
Project.ProfileLinks[I] := S;
end;

procedure SetMapDimensions;
//-----------------------------------------------------------------------------
// Determines map dimensions based on range of object coordinates.
//-----------------------------------------------------------------------------
begin
with MapForm.Map do
begin
// Dimensions not provided in [MAP] section
if not MapExtentSet then
begin

// Dimensions were provided in [BACKDROP] section
if (Backdrop.LowerLeft.X <> Backdrop.UpperRight.X) then
begin

// Interpret these as map dimensions
Dimensions.LowerLeft := Backdrop.LowerLeft;
Dimensions.UpperRight := Backdrop.UpperRight;

// Compute backdrop dimensions from Offset and Scale values
Backdrop.LowerLeft.X := BackdropX;
Backdrop.LowerLeft.Y := BackdropY - BackdropH;
Backdrop.UpperRight.X := BackdropX + BackdropW;
Backdrop.UpperRight.Y := BackdropY;
end

// No dimensions of any kind provided
else with Dimensions do
Ucoords.GetCoordExtents(LowerLeft.X, LowerLeft.Y,
UpperRight.X, UpperRight.Y);
end;
end;
end;

function ParseInpLine(S: String): Integer;
//-----------------------------------------------------------------------------
// Parses current input line depending on current section of input file.
//-----------------------------------------------------------------------------
begin
case Section of
1: Result := ReadOptionData;
2: Result := ReadRaingageData;
3: Result := ReadHydrographData;
4: Result := ReadEvaporationData;
5: Result := ReadSubcatchmentData;
6: Result := ReadSubareaData;
7: Result := ReadInfiltrationData;
8: Result := ReadAquiferData;
9: Result := ReadGroundwaterData;
10: Result := ReadJunctionData;
11: Result := ReadOutfallData;
12: Result := ReadStorageData;
13: Result := ReadDividerData;
14: Result := ReadConduitData;
15: Result := ReadPumpData;
16: Result := ReadOrificeData;
17: Result := ReadWeirData;
18: Result := ReadOutletData;
19: Result := ReadXsectionData;
20: Result := ReadTransectData;
21: Result := ReadLossData;
//22: ReadControlData called directly from ReadFile
23: Result := ReadPollutantData;
24: Result := ReadLanduseData;
25: Result := ReadBuildupData;
26: Result := ReadWashoffData;
27: Result := ReadCoverageData;
28: Result := ReadExInflowData;
29: Result := ReadDWInflowData;
30: Result := ReadPatternData;
31: Result := ReadIIInflowData;
32: Result := ReadLoadData;
33: Result := ReadCurveData;
34: Result := ReadTimeseriesData;
35: Result := ReadReportData;
36: Result := ReadFileData;
37: Result := ReadMapData;
38: Result := ReadCoordData;
39: Result := ReadVertexdata;
40: Result := ReadPolygonData;
41: Result := ReadSymbolData;
42: Result := ReadLabelData;
43: Result := ReadBackdropData;
44: Result := ReadProfileData;
45: Result := ReadCurveData;
46: Result := ReadTemperatureData;
47: Result := ReadSnowpackData;
48: Result := ReadTreatmentData(S);
49: Result := ReadTagData;
50: Result := Ulid.ReadLidData(TokList, Ntoks);
51: Result := ReadLidUsageData;
52: Result := ReadGroundwaterFlowEqn(S);
53: Result := ReadAdjustmentData; //(5.1.007)
else Result := 0;
end;
end;

function ParseImportLine(Line: String): Integer;
//-----------------------------------------------------------------------------
// Processes line of input from imported scenario or map file.
// (Not currently used.)
//-----------------------------------------------------------------------------
begin
Result := 0;
end;

procedure StripComment(const Line: String; var S: String);
//-----------------------------------------------------------------------------
// Strips comment (text following a ';') from a line of input.
// Ignores comment if it begins with ';;'.
//-----------------------------------------------------------------------------
var
P: Integer;
N: Integer;
C: String;
begin
C := '';
S := Trim(Line);
P := Pos(';', S);
if P > 0 then
begin
N := Length(S);
C := Copy(S, P+1, N);
if (Length(C) >= 1) and (C[1] <> ';') then
begin
if Length(Comment) > 0 then Comment := Comment + #13;
Comment := Comment + C;
end;
Delete(S, P, N);
end;
end;

function FindNewSection(const S: String): Integer;
//-----------------------------------------------------------------------------
// Checks if S matches any of the section heading key words.
//-----------------------------------------------------------------------------
var
K: Integer;
begin
for K := 0 to High(SectionWords) do
begin
if Pos(SectionWords[K], S) = 1 then
begin
Result := K;
Exit;
end;
end;
Result := -1;
end;

function StartNewSection(S: String): Integer;
//-----------------------------------------------------------------------------
// Begins reading a new section of the input file.
//-----------------------------------------------------------------------------
var
K : Integer;

begin
// Determine which new section to begin
K := FindNewSection(UpperCase(S));
if (K >= 0) then
begin

//Update section code
Section := K;
PrevID := '';
Result := 0;
end
else Result := ErrMsg(KEYWORD_ERR, S);
Comment := '';
end;

function ReadFile(var F: Textfile; const Fsize: Int64):Boolean;
//-----------------------------------------------------------------------------
// Reads each line of a SWMM input file.
//-----------------------------------------------------------------------------
var
Err : Integer;
ByteCount : Integer;
StepCount : Integer;
StepSize : Integer;
S : String;
begin
Result := True;
ErrCount := 0;
LineCount := 0;
Comment := '';

// Initialize progress meter settings
StepCount := MainForm.ProgressBar.Max div MainForm.ProgressBar.Step;
StepSize := Fsize div StepCount;
if StepSize < 1000 then StepSize := 0;
ByteCount := 0;

// Read each line of input file
Reset(F);
while not Eof(F) do
begin
Err := 0;
Readln(F, Line);
Inc(LineCount);
if StepSize > 0 then
begin
Inc(ByteCount, Length(Line));
MainForm.UpdateProgressBar(ByteCount, StepSize);
end;

// Strip out trailing spaces, control characters & comment
Line := TrimRight(Line);
StripComment(Line, S);

// Check if line begins a new input section
if (Pos('[', S) = 1) then Err := StartNewSection(S)
else
begin

//// Following code section modified for release 5.1.011. //// //(5.1.011)
// Check if line contains project title/notes
if (Section = 0) and (Length(Line) > 0) then
begin
if LeftStr(Line,2) <> ';;' then Err := ReadTitleData(Line);
end

// Check if line contains a control rule clause
else if (Section = 22) then Err := ReadControlData(Line)

// Check if line contains an event start/end dates
else if (Section = 54) then Err := ReadEventData(Trim(Line))

// If in some section, then process the input line
else
begin
// Break line into string tokens and parse their contents
Uutils.Tokenize(S, TokList, Ntoks);
if (Ntoks > 0) and (Section >= 0) then
begin
Err := ParseInpLine(S);
Comment := '';
end

// No current section -- file was probably not an EPA-SWMM file
else if (Ntoks > 0) then
begin
Result := False;
Exit;
end;
end;
end;
////

// Increment error count
if Err > 0 then Inc(ErrCount);
end; //End of file.

if ErrCount > MAX_ERRORS then ErrList.Add(
IntToStr(ErrCount-MAX_ERRORS) + TXT_MORE_ERRORS);
end;

procedure DisplayInpErrForm(const Fname: String);
//-----------------------------------------------------------------------------
// Displays Status Report form that lists any error messages.
//-----------------------------------------------------------------------------
begin
SysUtils.DeleteFile((TempReportFile));
TempReportFile := Uutils.GetTempFile(TempDir,'swmm');
ErrList.Insert(0, TXT_ERROR_REPORT + Fname + #13);
ErrList.SaveToFile(TempReportFile);
MainForm.MnuReportStatusClick(MainForm);
end;

procedure ReverseVertexLists;
//-----------------------------------------------------------------------------
// Reverses list of vertex points for each link in the project.
//-----------------------------------------------------------------------------
var
I, J: Integer;
begin
for I := 0 to MAXCLASS do
begin
if not Project.IsLink(I) then continue;
for J := 0 to Project.Lists[I].Count-1 do
if Project.GetLink(I, J).Vlist <> nil then
Project.GetLink(I, J).Vlist.Reverse;
end;
end;

procedure SetSubcatchCentroids;
//-----------------------------------------------------------------------------
// Determines the centroid of each subcatchment polygon.
//-----------------------------------------------------------------------------
var
I : Integer;
begin
for I := 0 to Project.Lists[SUBCATCH].Count - 1 do
begin
Project.GetSubcatch(SUBCATCH, I).SetCentroid;
end;
end;

procedure SetIDPtrs;
//-----------------------------------------------------------------------------
// Makes pointers to ID strings the ID property of objects.
//-----------------------------------------------------------------------------
var
I, J : Integer;
C : TSubcatch;
S : String;

begin
for I := 0 to MAXCLASS do
begin
if I = RAINGAGE then with Project.Lists[RAINGAGE] do
begin
for J := 0 to Count-1 do TRaingage(Objects[J]).ID := PChar(Strings[J]);
end
else if Project.IsSubcatch(I) then with Project.Lists[SUBCATCH] do
begin
for J := 0 to Count-1 do
begin
C := TSubcatch(Objects[J]);
C.ID := PChar(Strings[J]);
S := Trim(C.Data[SUBCATCH_OUTLET_INDEX]);
C.OutSubcatch := FindSubcatch(S);
if C.OutSubcatch = nil then C.OutNode := FindNode(S);
end;
end
else if Project.IsNode(I) then with Project.Lists[I] do
begin
for J := 0 to Count-1 do TNode(Objects[J]).ID := PChar(Strings[J]);
end
else if Project.IsLink(I) then with Project.Lists[I] do
begin
for J := 0 to Count-1 do TLink(Objects[J]).ID := PChar(Strings[J]);
end
else if I = TRANSECT then with Project.Lists[I] do
begin
for J := 0 to Count-1 do
begin
TTransect(Objects[J]).CheckData;
TTransect(Objects[J]).SetMaxDepth;
Project.SetTransectConduitDepth(Strings[J],
TTransect(Objects[J]).Data[TRANSECT_MAX_DEPTH]);
end;
end
else continue;
end;
end;

function ReadInpFile(const Fname: String):Boolean;
//-----------------------------------------------------------------------------
// Reads SWMM input data from a text file.
//-----------------------------------------------------------------------------
var
F : Textfile;
begin
// Try to open the file
Result := False;
AssignFile(F,Fname);
{$I-}
Reset(F);
{$I+}
if (IOResult = 0) then
begin

// Create stringlists
Screen.Cursor := crHourGlass;
MapExtentSet := False;
ErrList := TStringList.Create;
TokList := TStringList.Create;
SubcatchList := TStringList.Create;
NodeList := TStringList.Create;
LinkList := TStringList.Create;
FileType := ftInput;
InpFile := Fname;
try

// Read the file
MainForm.ShowProgressBar(MSG_READING_PROJECT_DATA);
SubcatchList.Sorted := True;
NodeList.Sorted := True;
LinkList.Sorted := True;
Section := -1;
Result := ReadFile(F, Uutils.GetFileSize(Fname));
if (Result = True) then
begin
// Establish pointers to ID names
SetIDPtrs;
end;

finally
// Free the stringlists
SubcatchList.Free;
NodeList.Free;
LinkList.Free;
TokList.Free;
MainForm.PageSetupDialog.Header.Text := Project.Title;
MainForm.HideProgressBar;
Screen.Cursor := crDefault;

// Display errors if found & set map dimensions
if Result = True then
begin
if ErrList.Count > 0 then DisplayInpErrForm(Fname);
SetSubcatchCentroids;
SetMapDimensions;
end;
ErrList.Free;
end;
end;

// Close the input file
CloseFile(F);
end;

procedure ClearDefaultDates;
//-----------------------------------------------------------------------------
// Clears project's date/time settings.
//-----------------------------------------------------------------------------
begin
with Project.Options do
begin
Data[START_DATE_INDEX] := '';
Data[START_TIME_INDEX] := '';
Data[REPORT_START_DATE_INDEX] := '';
Data[REPORT_START_TIME_INDEX] := '';
Data[END_DATE_INDEX] := '';
Data[END_TIME_INDEX] := '';
end;
end;

procedure SetDefaultDates;
//-----------------------------------------------------------------------------
// Sets default values for project's date/time settings.
//-----------------------------------------------------------------------------
var
StartTime: TDateTime;
StartDate: TDateTime;
T: TDateTime;
D: TDateTime;
begin
with Project.Options do
begin

// Process starting date/time
try
StartDate := StrToDate(Data[START_DATE_INDEX], MyFormatSettings);
except
On EConvertError do StartDate := Date;
end;
StartTime := Uutils.StrHoursToTime(Data[START_TIME_INDEX]);
if StartTime < 0 then StartTime := 0;
D := StartDate + StartTime;
Data[START_DATE_INDEX] := DateToStr(D, MyFormatSettings);
Data[START_TIME_INDEX] := TimeToStr(D, MyFormatSettings);

// Process reporting start date/time
try
D := StrToDate(Data[REPORT_START_DATE_INDEX], MyFormatSettings);
except
On EConvertError do D := StartDate;
end;
T := Uutils.StrHoursToTime(Data[REPORT_START_TIME_INDEX]);
if T < 0 then T := StartTime;
D := D + T;
Data[REPORT_START_DATE_INDEX] := DateToStr(D, MyFormatSettings);
Data[REPORT_START_TIME_INDEX] := TimeToStr(D, MyFormatSettings);

// Process ending date/time
try
D := StrToDate(Data[END_DATE_INDEX], MyFormatSettings);
except
On EConvertError do D := StartDate;
end;
T := Uutils.StrHoursToTime(Data[END_TIME_INDEX]);
if T < 0 then T := StartTime;
D := D + T;
Data[END_DATE_INDEX] := DateToStr(D, MyFormatSettings);
Data[END_TIME_INDEX] := TimeToStr(D, MyFormatSettings);
end;
end;

function OpenProject(const Fname: String): TInputFileType;
//-----------------------------------------------------------------------------
// Reads in project data from a file.
//-----------------------------------------------------------------------------
begin
// Show progress meter
ClearDefaultDates;
Screen.Cursor := crHourGlass;
MainForm.ShowProgressBar(MSG_READING_PROJECT_DATA);

// Use default map dimensions and backdrop settings
MapForm.Map.Dimensions := DefMapDimensions;
MapForm.Map.Backdrop := DefMapBackdrop;

// Do the following for non-temporary input files
if not SameText(Fname, Uglobals.TempInputFile) then
begin

// Create a backup file
if AutoBackup
then CopyFile(PChar(Fname), PChar(ChangeFileExt(Fname, '.bak')), FALSE);

// Retrieve project defaults from .INI file
if CompareText(ExtractFileExt(Fname), '.ini') <> 0
then Uinifile.ReadProjIniFile(ChangeFileExt(Fname, '.ini'));
end;

// Read and parse each line of input file
Result := iftNone;
if ReadInpFile(Fname) then Result := iftINP;

// Finish processing the input data
if Result <> iftNone then
begin
SetDefaultDates; // set any missing analysis dates
Uglobals.RegisterCalibData; // register calibration data files
Uupdate.UpdateUnits; // update choice of unit system
Uupdate.UpdateDefOptions; // update default analysis options
Uupdate.UpdateLinkHints; // update hints used for offsets
Project.GetControlRuleNames; // store control ruunit Uimport;

{-------------------------------------------------------------------}
{ Unit: Uimport.pas }
{ Project: EPA SWMM }
{ Version: 5.1 }
{ Date: 12/02/13 (5.1.001) }
{ 04/04/14 (5.1.003) }
{ 04/14/14 (5.1.004) }
{ 09/15/14 (5.1.007) }
{ 03/19/15 (5.1.008) }
{ 08/05/15 (5.1.010) }
{ 08/01/16 (5.1.011) }
{ Author: L. Rossman }
{ }
{ Delphi Pascal unit that imports a SWMM project's data from a }
{ a formatted text file. }
{ }
{ 5.1.011 - Support for reading [EVENTS] section added. }
{-------------------------------------------------------------------}

interface

uses
Classes, Forms, Controls, Dialogs, SysUtils, Windows, Math, StrUtils,
Uutils, Uglobals;

const
ITEMS_ERR = 1;
KEYWORD_ERR = 2;
SUBCATCH_ERR = 3;
NODE_ERR = 4;
LINK_ERR = 5;
LANDUSE_ERR = 6;
POLLUT_ERR = 7;
NUMBER_ERR = 8;
XSECT_ERR = 9;
TRANSECT_ERR = 10;
TIMESTEP_ERR = 11;
DATE_ERR = 12;
LID_ERR = 13;
MAX_ERRORS = 50;

type
TFileType = (ftInput, ftImport);

// These routines can be called from other units
function ErrMsg(const ErrCode: Integer; const Name: String): Integer;
function OpenProject(const Fname: String): TInputFileType;
function ReadInpFile(const Fname: String):Boolean;
procedure SetDefaultDates;

implementation

uses
Fmain, Fmap, Fstatus, Dxsect, Uexport, Uinifile, Uproject, Umap,
Ucoords, Uvertex, Uupdate, Dreporting, Ulid;

const
MSG_READING_PROJECT_DATA = 'Reading project data... ';
TXT_ERROR = 'Error ';
TXT_AT_LINE = ' at line ';
TXT_MORE_ERRORS = ' more errors found in file.';
TXT_ERROR_REPORT = 'Error Report for File ';

SectionWords : array[0..54] of PChar = //(5.1.011)
('[TITLE', //0
'[OPTION', //1
'[RAINGAGE', //2
'[HYDROGRAPH', //3
'[EVAPORATION', //4
'[SUBCATCHMENT', //5
'[SUBAREA', //6
'[INFILTRATION', //7
'[AQUIFER', //8
'[GROUNDWATER', //9
'[JUNCTION', //10
'[OUTFALL', //11
'[STORAGE', //12
'[DIVIDER', //13
'[CONDUIT', //14
'[PUMP', //15
'[ORIFICE', //16
'[WEIR', //17
'[OUTLET', //18
'[XSECTION', //19
'[TRANSECT', //20
'[LOSS', //21
'[CONTROL', //22
'[POLLUTANT', //23
'[LANDUSE', //24
'[BUILDUP', //25
'[WASHOFF', //26
'[COVERAGE', //27
'[INFLOW', //28
'[DWF', //29
'[PATTERN', //30
'[RDII', //31
'[LOAD', //32
'[CURVE', //33
'[TIMESERIES', //34
'[REPORT', //35
'[FILE', //36
'[MAP', //37
'[COORDINATES', //38
'[VERTICES', //39
'[POLYGONS', //40
'[SYMBOLS', //41
'[LABELS', //42
'[BACKDROP', //43
'[PROFILE', //44
'[TABLE', //45
'[TEMPERATURE', //46
'[SNOWPACK', //47
'[TREATMENT', //48
'[TAG', //49
'[LID_CONTROL', //50
'[LID_USAGE', //51
'[GWF', //52 //(5.1.007)
'[ADJUSTMENTS', //53 //(5.1.007)
'[EVENT'); //54 //(5.1.011)

var
FileType : TFileType;
InpFile : String;
ErrList : TStringlist;
SubcatchList : TStringlist;
NodeList : TStringlist;
LinkList : TStringlist;
TokList : TStringlist;
Ntoks : Integer;
Section : Integer;
LineCount : LongInt;
ErrCount : LongInt;
Line : String;
Comment : String;
TsectComment : String;
PrevID : String;
PrevIndex : Integer;
CurveType : Integer;
MapExtentSet : Boolean;
ManningsN : array[1..3] of String;

// These are deprecated attributes of a backdrop image
BackdropX : Extended;
BackdropY : Extended;
BackdropW : Extended;
BackdropH : Extended;

function ErrMsg(const ErrCode: Integer; const Name: String): Integer;
//-----------------------------------------------------------------------------
// Adds an error message for a specific error code to the list
// of errors encountered when reading an input file.
//-----------------------------------------------------------------------------
var
S: String;
begin
if ErrCount <= MAX_ERRORS then
begin
case ErrCode of
ITEMS_ERR: S := 'Too few items ';
KEYWORD_ERR: S := 'Unrecognized keyword (' + Name + ') ';
SUBCATCH_ERR: S := 'Undefined Subcatchment (' + Name + ') referenced ';
NODE_ERR: S := 'Undefined Node (' + Name + ') referenced ';
LINK_ERR: S := 'Undefined Link (' + Name + ') referenced ';
LANDUSE_ERR: S := 'Undefined Land Use (' + Name + ') referenced ';
POLLUT_ERR: S := 'Undefined Pollutant (' + Name + ') referenced ';
NUMBER_ERR: S := 'Illegal numeric value (' + Name + ') ';
XSECT_ERR: S := 'Illegal cross section for Link ' + Name + ' ';
TRANSECT_ERR: S := 'No Transect defined for these data ';
TIMESTEP_ERR: S := 'Illegal time step value ';
DATE_ERR: S := 'Illegal date/time value ';
LID_ERR: S := 'Undefined LID process (' + Name + ') referenced ';
else S := 'Unknown error ';
end;
S := S + 'at line ' + IntToStr(LineCount) + ':';
ErrList.Add(S);
if Section >= 0 then ErrList.Add(SectionWords[Section] + ']');
ErrList.Add(Line);
ErrList.Add('');
end;
Result := ErrCode;
end;

function FindSubcatch(const ID: String): TSubcatch;
//-----------------------------------------------------------------------------
// Finds a Subcatchment object given its ID name.
//-----------------------------------------------------------------------------
var
Index: Integer;
Atype: Integer;
begin
Result := nil;
if (FileType = ftInput) then
begin
if SubcatchList.Find(ID, Index)
then Result := TSubcatch(SubcatchList.Objects[Index]);
end
else
begin
if (Project.FindSubcatch(ID, Atype, Index))
then Result := Project.GetSubcatch(Atype, Index);
end;
end;

function FindNode(const ID: String): TNode;
//-----------------------------------------------------------------------------
// Finds a Node object given its ID name.
//-----------------------------------------------------------------------------
var
Index: Integer;
Ntype: Integer;
begin
Result := nil;
if (FileType = ftInput) then
begin
if NodeList.Find(ID, Index)
then Result := TNode(NodeList.Objects[Index]);
end
else
begin
if (Project.FindNode(ID, Ntype, Index))
then Result := Project.GetNode(Ntype, Index);
end;
end;

function FindLink(const ID: String): TLink;
//-----------------------------------------------------------------------------
// Finds a Link object given its ID name.
//-----------------------------------------------------------------------------
var
Index : Integer;
Ltype : Integer;
begin
Result := nil;
if (FileType = ftInput) then
begin
if LinkList.Find(ID, Index)
then Result := TLink(LinkList.Objects[Index]);
end
else
begin
if (Project.FindLink(ID, Ltype, Index))
then Result := Project.GetLink(Ltype, Index);
end;
end;

function ReadTitleData(Line: String): Integer;
//-----------------------------------------------------------------------------
// Adds Line of text to a project's title and notes.
//-----------------------------------------------------------------------------
begin
if Project.Lists[NOTES].Count = 0 then Project.Title := Line;
Project.Lists[NOTES].Add(Line);
Project.HasItems[NOTES] := True;
Result := 0;
end;

procedure ReadOldRaingageData(I: Integer; aGage: TRaingage);
//-----------------------------------------------------------------------------
// Reads a line of parsed rain gage data using older format.
//-----------------------------------------------------------------------------
begin
if I = 0 then
begin
aGage.Data[GAGE_DATA_SOURCE] := RaingageOptions[0];
if Ntoks > 2 then aGage.Data[GAGE_SERIES_NAME] := TokList[2];
if Ntoks > 3 then aGage.Data[GAGE_DATA_FORMAT] := TokList[3];
if Ntoks > 4 then aGage.Data[GAGE_DATA_FREQ] := TokList[4];
end;
if I = 1 then
begin
aGage.Data[GAGE_DATA_SOURCE] := RaingageOptions[1];
if Ntoks > 2 then aGage.Data[GAGE_FILE_NAME] := TokList[2];
if Ntoks > 3 then aGage.Data[GAGE_STATION_NUM] := TokList[3];
end;
end;

procedure ReadNewRaingageData(aGage: TRaingage);
//-----------------------------------------------------------------------------
// Reads a line of rain gage data using newer format.
//-----------------------------------------------------------------------------
var
I: Integer;
Fname: String;
begin
if Ntoks > 1 then aGage.Data[GAGE_DATA_FORMAT] := TokList[1];
if Ntoks > 2 then aGage.Data[GAGE_DATA_FREQ] := TokList[2];
if Ntoks > 3 then aGage.Data[GAGE_SNOW_CATCH] := TokList[3];
if Ntoks > 4 then
begin
I := Uutils.FindKeyWord(TokList[4], RaingageOptions, 4);
if I = 0 then
begin
aGage.Data[GAGE_DATA_SOURCE] := RaingageOptions[0];
if Ntoks > 5 then aGage.Data[GAGE_SERIES_NAME] := TokList[5];
end;
if I = 1 then
begin
aGage.Data[GAGE_DATA_SOURCE] := RaingageOptions[1];
if Ntoks > 5 then
begin
Fname := TokList[5];
if ExtractFilePath(Fname) = ''
then Fname := ExtractFilePath(Uglobals.InputFileName) + Fname;
aGage.Data[GAGE_FILE_NAME] := Fname;
end;
if Ntoks > 6 then aGage.Data[GAGE_STATION_NUM] := TokList[6];
if Ntoks > 7 then aGage.Data[GAGE_RAIN_UNITS] := TokList[7];
end;
end;
end;

function ReadRaingageData: Integer;
//-----------------------------------------------------------------------------
// Parses rain gage data from the input line.
//-----------------------------------------------------------------------------
var
aGage : TRaingage;
ID : String;
I : Integer;
begin
if Ntoks < 2 then
begin
Result := ErrMsg(ITEMS_ERR, '');
Exit;
end;
ID := TokList[0];
aGage := TRaingage.Create;
Uutils.CopyStringArray(Project.DefProp[RAINGAGE].Data, aGage.Data);
aGage.X := MISSING;
aGage.Y := MISSING;
aGage.Data[COMMENT_INDEX ] := Comment;
Project.Lists[RAINGAGE].AddObject(ID, aGage);
Project.HasItems[RAINGAGE] := True;
I := Uutils.FindKeyWord(TokList[1], RaingageOptions, 4);
if I >= 0
then ReadOldRaingageData(I, aGage)
else ReadNewRaingageData(aGage);
Result := 0;
end;

function ReadOldHydrographFormat(const I: Integer; UH: THydrograph): Integer;
//-----------------------------------------------------------------------------
// Reads older format of unit hydrograph parameters from a line of input.
//-----------------------------------------------------------------------------
var
J, K, N: Integer;
begin
Result := 0;
if Ntoks < 2 then Result := ErrMsg(ITEMS_ERR, '')
else
begin
N := 2;
for K := 1 to 3 do
begin
for J := 1 to 3 do
begin
UH.Params[I,J,K] := TokList[N];
Inc(N);
end;
end;
for J := 1 to 3 do
begin
UH.InitAbs[I,J,1] := '';
if Ntoks > N then UH.InitAbs[I,J,1] := TokList[N];
Inc(N);
for K := 2 to 3 do UH.InitAbs[I,J,K] := UH.InitAbs[I,J,1];
end;
end;
end;

function ReadHydrographData: Integer;
//-----------------------------------------------------------------------------
// Reads RDII unit hydrograph data from a line of input.
//-----------------------------------------------------------------------------
var
I, J, K: Integer;
ID: String;
aUnitHyd: THydrograph;
Index: Integer;
begin
Result := 0;
if Ntoks < 2 then Result := ErrMsg(ITEMS_ERR, '')
else
begin

// Check if hydrograph ID is same as for previous line
ID := TokList[0];
if (ID = PrevID)
then Index := PrevIndex
else Index := Project.Lists[HYDROGRAPH].IndexOf(ID);

// If starting input for a new hydrograph then create it
if Index < 0 then
begin
aUnitHyd := THydrograph.Create;
Project.Lists[HYDROGRAPH].AddObject(ID, aUnitHyd);
Project.HasItems[HYDROGRAPH] := True;
Index := Project.Lists[HYDROGRAPH].Count - 1;
PrevID := ID;
PrevIndex := Index;
end
else aUnitHyd := THydrograph(Project.Lists[HYDROGRAPH].Objects[Index]);

// Parse rain gage name for 2-token line
if Ntoks = 2 then
begin
aUnitHyd.Raingage := TokList[1];
end

// Extract remaining hydrograph parameters
else if Ntoks < 6 then Result := ErrMsg(ITEMS_ERR, '')
else
begin
// Determine month of year
I := Uutils.FindKeyWord(TokList[1], MonthLabels, 3);
if I < 0 then Result := ErrMsg(KEYWORD_ERR, TokList[1]);

// Determine if response type present - if not, process old format
K := Uutils.FindKeyWord(TokList[2], ResponseTypes, 3) + 1;
if K < 1 then Result := ReadOldHydrographFormat(I, aUnitHyd)
else
begin
// Extract R-T-K values
for J := 3 to 5 do
begin
aUnitHyd.Params[I,J-2,K] := TokList[J];
end;
// Extract IA parameters
for J := 6 to 8 do
begin
if J >= Ntoks then break
else aUnitHyd.InitAbs[I,J-5,K] := TokList[J];
end;
end;
end;
end;
end;

function ReadTemperatureData: Integer;
//-----------------------------------------------------------------------------
// Reads description of air temperature data from a line of input.
//-----------------------------------------------------------------------------
var
I: Integer;
begin
Result := 0;
if Ntoks < 2 then Result := ErrMsg(ITEMS_ERR, '')
else with Project.Climatology do
begin
I := Uutils.FindKeyWord(TokList[0], TempKeywords, 10);
if I < 0 then Result := ErrMsg(KEYWORD_ERR, TokList[0])
else case I of
0: begin // Time series
TempDataSource := 1;
TempTseries := TokList[1];
end;
1: begin // File
TempDataSource := 2;
TempFile := TokList[1];
if ExtractFilePath(TempFile) = '' then
TempFile := ExtractFilePath(Uglobals.InputFileName) + TempFile;
if Ntoks >= 3 then TempStartDate := TokList[2];
end;
2: begin // Wind speed
if SameText(TokList[1], 'MONTHLY') then
begin
if Ntoks < 14 then Result := ErrMsg(ITEMS_ERR, '')
else
begin
WindType := MONTHLY_WINDSPEED;
for I := 1 to 12 do WindSpeed[I] := TokList[I+1];
end;
end
else if SameText(TokList[1], 'FILE') then WindType := FILE_WINDSPEED
else Result := ErrMsg(KEYWORD_ERR, TokList[1]);
end;
3: begin
if Ntoks < 7 then Result := ErrMsg(ITEMS_ERR, '')
else for I := 1 to 6 do SnowMelt[I] := TokList[I];
end;
4: begin
if Ntoks < 12 then Result := ErrMsg(ITEMS_ERR, '')
else
begin
if SameText(TokList[1], 'IMPERVIOUS') then
for I := 1 to 10 do ADCurve[1][I] := TokList[I+1]
else if SameText(TokList[1], 'PERVIOUS') then
for I := 1 to 10 do ADCurve[2][I] := TokList[I+1]
else Result := ErrMsg(KEYWORD_ERR, TokList[1]);
end;
end;
end;
end;
end;

function ReadEvaporationRates(Etype: Integer): Integer;
var
J: Integer;
begin
if (Etype <> TEMP_EVAP) and (Ntoks < 2)
then Result := ErrMsg(ITEMS_ERR, '')

else with Project.Climatology do
begin
EvapType := Etype;

case EvapType of

CONSTANT_EVAP:
for J := 0 to 11 do EvapData[J] := TokList[1];

TSERIES_EVAP:
EvapTseries := TokList[1];

FILE_EVAP:
for J := 1 to 12 do
begin
if J >= Ntoks then break;
PanData[J-1] := TokList[J];
end;

MONTHLY_EVAP:
for J := 1 to 12 do
begin
if J >= Ntoks then break;
EvapData[J-1] := TokList[J];
end;
end;

Result := 0;
end;

end;

function ReadEvaporationData: Integer;
//-----------------------------------------------------------------------------
// Reads evaporation data from a line of input.
//-----------------------------------------------------------------------------
var
I: Integer;
begin
Result := 0;
I := Uutils.FindKeyWord(TokList[0], EvapOptions, 4);
if I >= 0 then Result := ReadEvaporationRates(I)

else if (I <> TEMP_EVAP) and (Ntoks < 2)
then Result := ErrMsg(ITEMS_ERR, '')

else with Project.Climatology do
begin

if SameText(TokList[0], 'RECOVERY')
then RecoveryPat := TokList[1]

else if SameText(TokList[0], 'DRY_ONLY') then
begin
if SameText(TokList[1], 'NO') then EvapDryOnly := False
else if SameText(TokList[1], 'YES') then EvapDryOnly := True
else Result := ErrMsg(KEYWORD_ERR, TokList[1]);
end

else Result := ErrMsg(KEYWORD_ERR, TokList[0]);

end;
end;

function ReadSubcatchmentData: Integer;
//-----------------------------------------------------------------------------
// Reads subcatchment data from a line of input.
//-----------------------------------------------------------------------------
var
S : TSubcatch;
ID : String;
begin
if Ntoks < 8
then Result := ErrMsg(ITEMS_ERR, '')
else begin
ID := TokList[0];
S := TSubcatch.Create;
SubcatchList.AddObject(ID, S);
S.X := MISSING;
S.Y := MISSING;
S.Zindex := -1;
Uutils.CopyStringArray(Project.DefProp[SUBCATCH].Data, S.Data);
S.Data[SUBCATCH_RAINGAGE_INDEX] := TokList[1];
S.Data[SUBCATCH_OUTLET_INDEX] := TokList[2];
S.Data[SUBCATCH_AREA_INDEX] := TokList[3];
S.Data[SUBCATCH_IMPERV_INDEX] := TokList[4];
S.Data[SUBCATCH_WIDTH_INDEX] := TokList[5];
S.Data[SUBCATCH_SLOPE_INDEX] := TokList[6];
S.Data[SUBCATCH_CURBLENGTH_INDEX] := TokList[7];
if Ntoks >= 9
then S.Data[SUBCATCH_SNOWPACK_INDEX] := TokList[8];
S.Data[COMMENT_INDEX ] := Comment;
Project.Lists[SUBCATCH].AddObject(ID, S);
Project.HasItems[SUBCATCH] := True;
Result := 0;
end;
end;

function ReadSubareaData: Integer;
//-----------------------------------------------------------------------------
// Reads subcatchment sub-area data from a line of input.
//-----------------------------------------------------------------------------
var
S : TSubcatch;
ID : String;
begin
if Ntoks < 7
then Result := ErrMsg(ITEMS_ERR, '')
else begin
ID := TokList[0];
S := FindSubcatch(ID);
if S = nil
then Result := ErrMsg(SUBCATCH_ERR, ID)
else begin
S.Data[SUBCATCH_IMPERV_N_INDEX] := TokList[1];
S.Data[SUBCATCH_PERV_N_INDEX] := TokList[2];
S.Data[SUBCATCH_IMPERV_DS_INDEX] := TokList[3];
S.Data[SUBCATCH_PERV_DS_INDEX] := TokList[4];
S.Data[SUBCATCH_PCTZERO_INDEX] := TokList[5];
S.Data[SUBCATCH_ROUTE_TO_INDEX] := TokList[6];
if Ntoks >= 8
then S.Data[SUBCATCH_PCT_ROUTED_INDEX] := TokList[7];
Result := 0;
end;
end;
end;

function ReadInfiltrationData: Integer;
//-----------------------------------------------------------------------------
// Reads subcatchment infiltration data from a line of input.
//-----------------------------------------------------------------------------
var
S : TSubcatch;
ID : String;
J : Integer;
Jmax : Integer;
begin
ID := TokList[0];
S := FindSubcatch(ID);
if S = nil
then Result := ErrMsg(SUBCATCH_ERR, ID)
else begin
Jmax := Ntoks-1;
if Jmax > MAXINFILPROPS then Jmax := MAXINFILPROPS;
for J := 1 to Jmax do S.InfilData[J-1] := TokList[J];
Result := 0;
end;
end;

function ReadAquiferData: Integer;
//-----------------------------------------------------------------------------
// Reads aquifer data from a line of input.
//-----------------------------------------------------------------------------
var
ID : String;
A : TAquifer;
I : Integer;
begin
if nToks < MAXAQUIFERPROPS then Result := ErrMsg(ITEMS_ERR, '') //(5.1.003)
else begin
ID := TokList[0];
A := TAquifer.Create;
//Uutils.CopyStringArray(Project.DefProp[AQUIFER].Data, A.Data); //(5.1.004)
Project.Lists[AQUIFER].AddObject(ID, A);
Project.HasItems[AQUIFER] := True;
for I := 0 to MAXAQUIFERPROPS-1 do A.Data[I] := TokList[I+1]; //(5.1.003)
if nToks >= MAXAQUIFERPROPS + 2 //(5.1.004)
then A.Data[MAXAQUIFERPROPS] := TokList[MAXAQUIFERPROPS+1] //(5.1.003)
else A.Data[MAXAQUIFERPROPS] := ''; //(5.1.003)
Result := 0;
end;
end;

function ReadGroundwaterData: Integer;
//-----------------------------------------------------------------------------
// Reads subcatchment groundwater data from a line of input.
//-----------------------------------------------------------------------------
var
S: TSubcatch;
ID: String;
P: String;
J: Integer;
K: Integer;

begin
// Get subcatchment name
ID := TokList[0];
S := FindSubcatch(ID);
if S = nil
then Result := ErrMsg(SUBCATCH_ERR, ID)
else
begin

// Line contains GW flow parameters
if Ntoks < 10 then Result := ErrMsg(ITEMS_ERR, '')
else begin
S.Groundwater.Clear;

// Read required parameters
for J := 1 to 9 do S.Groundwater.Add(TokList[J]);

// Read optional parameters
for K := 10 to 13 do
begin
if Ntoks > K then
begin
P := TokList[K];
if P = '*' then P := '';
S.Groundwater.Add(P);
end
else S.Groundwater.Add('');
end;
S.Data[SUBCATCH_GWATER_INDEX] := 'YES';
Result := 0;
end;
end;
end;

//// This function was re-written for release 5.1.007. //// //(5.1.007)
function ReadGroundwaterFlowEqn(Line: String): Integer;
//-----------------------------------------------------------------------------
// Reads GW flow math expression from a line of input.
//-----------------------------------------------------------------------------
var
S: TSubcatch;
N: Integer;
begin
// Check for enough tokens in line
if Ntoks < 3 then Result := ErrMsg(ITEMS_ERR, '')
// Get subcatchment object referred to by name
else begin
Result := 0;
S := FindSubcatch(TokList[0]);
if S = nil then Result := ErrMsg(SUBCATCH_ERR, TokList[0])
else begin
// Find position in Line where second token ends
N := Pos(TokList[1], Line) + Length(TokList[1]);
// Save remainder of line to correct type of GW flow equation
if SameText(TokList[1], 'LATERAL') then
S.GwLatFlowEqn := Trim(AnsiRightStr(Line, Length(Line)-N))
else if SameText(TokList[1], 'DEEP') then
S.GwDeepFlowEqn := Trim(AnsiRightStr(Line, Length(Line)-N))
else Result := ErrMsg(KEYWORD_ERR, TokList[1]);
end;
end;
end;

function ReadSnowpackData: Integer;
//-----------------------------------------------------------------------------
// Reads snowpack data from a line of input.
//-----------------------------------------------------------------------------
var
ID : String;
P : TSnowpack;
I : Integer;
J : Integer;
Index: Integer;
begin
Result := 0;
if Ntoks < 8
then Result := ErrMsg(ITEMS_ERR, '')
else begin
I := Uutils.FindKeyWord(TokList[1], SnowpackOptions, 7);
if I < 0
then Result := ErrMsg(KEYWORD_ERR, TokList[1])
else begin

// Check if snow pack ID is same as for previous line
ID := TokList[0];
if (ID = PrevID)
then Index := PrevIndex
else Index := Project.Lists[SNOWPACK].IndexOf(ID);

// If starting input for a new snow pack then create it
if Index < 0 then
begin
P := TSnowpack.Create;
Project.Lists[SNOWPACK].AddObject(ID, P);
Project.HasItems[SNOWPACK] := True;
Index := Project.Lists[SNOWPACK].Count - 1;
PrevID := ID;
PrevIndex := Index;
end
else P := TSnowpack(Project.Lists[SNOWPACK].Objects[Index]);

// Parse line depending on data type
case I of

// Plowable area
0: begin
if Ntoks < 9 then Result := ErrMsg(ITEMS_ERR, '')
else
begin
for J := 1 to 6 do P.Data[1][J] := TokList[J+1];
P.FracPlowable := TokList[8];
end;
end;

// Impervious or Pervious area
1,
2: begin
if Ntoks < 9 then Result := ErrMsg(ITEMS_ERR, '')
else for J := 1 to 7 do P.Data[I+1][J] := TokList[J+1];
end;

// Plowing parameters
3: begin
for J := 1 to 6 do P.Plowing[J] := TokList[J+1];
if Ntoks >= 9 then P.Plowing[7] := TokList[8];
end;
end;
end;
end;
end;

function ReadJunctionData: Integer;
//-----------------------------------------------------------------------------
// Reads junction data from a line of input.
//-----------------------------------------------------------------------------
var
aNode: TNode;
ID : String;
begin
if Ntoks < 2
then Result := ErrMsg(ITEMS_ERR, '')
else begin
ID := TokList[0];
aNode := TNode.Create;
NodeList.AddObject(ID, aNode);
aNode.Ntype := JUNCTION;
aNode.X := MISSING;
aNode.Y := MISSING;
aNode.Zindex := -1;
Uutils.CopyStringArray(Project.DefProp[JUNCTION].Data, aNode.Data);
aNode.Data[NODE_INVERT_INDEX] := TokList[1];
if Ntoks > 2 then aNode.Data[JUNCTION_MAX_DEPTH_INDEX] := TokList[2];
if Ntoks > 3 then aNode.Data[JUNCTION_INIT_DEPTH_INDEX] := TokList[3];
if Ntoks > 4 then aNode.Data[JUNCTION_SURCHARGE_DEPTH_INDEX] := TokList[4];
if Ntoks > 5 then aNode.Data[JUNCTION_PONDED_AREA_INDEX] := TokList[5];
aNode.Data[COMMENT_INDEX ] := Comment;
Project.Lists[JUNCTION].AddObject(ID, aNode);
Project.HasItems[JUNCTION] := True;
Result := 0;
end;
end;

function ReadOutfallData: Integer;
//-----------------------------------------------------------------------------
// Reads outfall data from a line of input.
//-----------------------------------------------------------------------------
var
aNode: TNode;
ID : String;
I : Integer;
N : Integer; //(5.1.008)
begin
if Ntoks < 3
then Result := ErrMsg(ITEMS_ERR, '')
else begin
N := 4; //(5.1.008)
ID := TokList[0];
aNode := TNode.Create;
NodeList.AddObject(ID, aNode);
aNode.Ntype := OUTFALL;
aNode.X := MISSING;
aNode.Y := MISSING;
aNode.Zindex := -1;
Uutils.CopyStringArray(Project.DefProp[OUTFALL].Data, aNode.Data);
aNode.Data[NODE_INVERT_INDEX] := TokList[1];
I := Uutils.FindKeyWord(TokList[2], OutfallOptions, 4);
if I < 0 then I := FREE_OUTFALL;
if (I > NORMAL_OUTFALL) and (Ntoks >= 4) then
begin
case I of
FIXED_OUTFALL: aNode.Data[OUTFALL_FIXED_STAGE_INDEX] := TokList[3];
TIDAL_OUTFALL: aNode.Data[OUTFALL_TIDE_TABLE_INDEX] := TokList[3];
TIMESERIES_OUTFALL: aNode.Data[OUTFALL_TIME_SERIES_INDEX] := TokList[3];
end;
N := 5;
if Ntoks >= 5 then aNode.Data[OUTFALL_TIDE_GATE_INDEX] := TokList[4]; // (5.1.008)
end
else if Ntoks >= 4 then aNode.Data[OUTFALL_TIDE_GATE_INDEX] := TokList[3]; //(5.1.008)
if Ntoks > N then aNode.Data[OUTFALL_ROUTETO_INDEX] := TokList[N]; //(5.1.008)
aNode.Data[OUTFALL_TYPE_INDEX] := OutfallOptions[I];
aNode.Data[COMMENT_INDEX ] := Comment;
Project.Lists[OUTFALL].AddObject(ID, aNode);
Project.HasItems[OUTFALL] := True;
Result := 0;
end;
end;

//// The following function was modified for release 5.1.007. //// //(5.1.007)

function ReadStorageData: Integer;
//-----------------------------------------------------------------------------
// Reads storage unit data from a line of input.
//-----------------------------------------------------------------------------
var
aNode: TNode;
ID : String;
N : Integer;
X : Single;
begin
Result := 0;
N := 6;
if Ntoks < 6
then Result := ErrMsg(ITEMS_ERR, '')
else begin
ID := TokList[0];
aNode := TNode.Create;
NodeList.AddObject(ID, aNode);
aNode.Ntype := STORAGE;
aNode.X := MISSING;
aNode.Y := MISSING;
aNode.Zindex := -1;
Uutils.CopyStringArray(Project.DefProp[STORAGE].Data, aNode.Data);
Project.Lists[STORAGE].AddObject(ID, aNode);
aNode.Data[NODE_INVERT_INDEX] := TokList[1];
aNode.Data[STORAGE_MAX_DEPTH_INDEX] := TokList[2];
aNode.Data[STORAGE_INIT_DEPTH_INDEX] := TokList[3];
aNode.Data[STORAGE_GEOMETRY_INDEX] := TokList[4];
if CompareText(TokList[4], 'TABULAR') = 0 then
begin
aNode.Data[STORAGE_ATABLE_INDEX] := TokList[5];
end
else begin
if Ntoks < 7
then Result := ErrMsg(ITEMS_ERR, '')
else begin
aNode.Data[STORAGE_ACOEFF_INDEX] := TokList[5];
aNode.Data[STORAGE_AEXPON_INDEX] := TokList[6];
if Ntoks >= 8 then aNode.Data[STORAGE_ACONST_INDEX] := TokList[7];
N := 8;
end;
end;

// Optional items
if (Result = 0) and (Ntoks > N) then
begin
// Ponded area
aNode.Data[STORAGE_PONDED_AREA_INDEX] := TokList[N];
// Evaporation factor
if Ntoks > N+1 then aNode.Data[STORAGE_EVAP_FACTOR_INDEX] := TokList[N+1];
// Constant seepage rate
if Ntoks = N+3 then
begin
aNode.InfilData[STORAGE_KSAT_INDEX] := TokList[N+2];
end
// Green-Ampt seepage parameters
else if Ntoks = N+5 then
begin
aNode.InfilData[STORAGE_SUCTION_INDEX] := TokList[N+2];
aNode.InfilData[STORAGE_KSAT_INDEX] := TokList[N+3];
aNode.InfilData[STORAGE_IMDMAX_INDEX] := TokList[N+4];
end;
end;
Uutils.GetSingle(aNode.InfilData[STORAGE_KSAT_INDEX ], X);
if (X > 0) then aNode.Data[STORAGE_SEEPAGE_INDEX] := 'YES'
else aNode.Data[STORAGE_SEEPAGE_INDEX] := 'NO';
aNode.Data[COMMENT_INDEX ] := Comment;
Project.HasItems[STORAGE] := True;
end;
end;

function ReadDividerData: Integer;
//-----------------------------------------------------------------------------
// Reads flow divider data from a line of input.
// (Corrected on 6/14/05)
//-----------------------------------------------------------------------------
var
N, J : Integer;
aNode: TNode;
ID : String;
begin
if Ntoks < 4
then Result := ErrMsg(ITEMS_ERR, '')
else begin
Result := 0;
ID := TokList[0];
aNode := TNode.Create;
NodeList.AddObject(ID, aNode);
aNode.Ntype := DIVIDER;
aNode.X := MISSING;
aNode.Y := MISSING;
aNode.Zindex := -1;
Uutils.CopyStringArray(Project.DefProp[DIVIDER].Data, aNode.Data);
Project.Lists[DIVIDER].AddObject(ID, aNode);
Project.HasItems[DIVIDER] := True;
aNode.Data[COMMENT_INDEX ] := Comment;
aNode.Data[NODE_INVERT_INDEX] := TokList[1];
aNode.Data[DIVIDER_LINK_INDEX] := TokList[2];
aNode.Data[DIVIDER_TYPE_INDEX] := TokList[3];
N := 5;
if SameText(TokList[3], 'OVERFLOW') then
begin
N := 4;
end
else if SameText(TokList[3], 'CUTOFF') then
begin
aNode.Data[DIVIDER_CUTOFF_INDEX] := TokList[4];
end
else if SameText(TokList[3], 'TABULAR') then
begin
aNode.Data[DIVIDER_TABLE_INDEX] := TokList[4];
end
else if SameText(TokList[3], 'WEIR') and (Ntoks >= 7) then
begin
aNode.Data[DIVIDER_QMIN_INDEX] := TokList[4];
aNode.Data[DIVIDER_DMAX_INDEX] := TokList[5];
aNode.Data[DIVIDER_QCOEFF_INDEX] := TokList[6];
N := 7;
end
else Result := ErrMsg(KEYWORD_ERR, TokList[3]);
if (Result = 0) and (Ntoks > N) then
begin
for J := N to Ntoks-1 do
aNode.Data[DIVIDER_MAX_DEPTH_INDEX + J - N] := TokList[J];
end;
end;
end;

function ReadConduitData: Integer;
//-----------------------------------------------------------------------------
// Reads conduit data from a line of input.
//-----------------------------------------------------------------------------
var
aLink : TLink;
aNode1: TNode;
aNode2: TNode;
ID : String;
begin
if Ntoks < 7 then Result := ErrMsg(ITEMS_ERR, '')
else begin
ID := TokList[0];
aNode1 := FindNode(TokList[1]);
aNode2 := FindNode(TokList[2]);
if (aNode1 = nil) then Result := ErrMsg(NODE_ERR, TokList[1])
else if (aNode2 = nil) then Result := ErrMsg(NODE_ERR, TokList[2])
else begin
aLink := TLink.Create;
LinkList.AddObject(ID, aLink);
aLink.Ltype := CONDUIT;
aLink.Node1 := aNode1;
aLink.Node2 := aNode2;
aLink.Zindex := -1;
Uutils.CopyStringArray(Project.DefProp[CONDUIT].Data, aLink.Data);
Project.Lists[CONDUIT].AddObject(ID, aLink);
Project.HasItems[CONDUIT] := True;
aLink.Data[CONDUIT_LENGTH_INDEX] := TokList[3];
aLink.Data[CONDUIT_ROUGHNESS_INDEX] := TokList[4];
aLink.Data[CONDUIT_INLET_HT_INDEX] := TokList[5];
aLink.Data[CONDUIT_OUTLET_HT_INDEX] := TokList[6];
if Ntoks > 7 then aLink.Data[CONDUIT_INIT_FLOW_INDEX] := TokList[7];
if Ntoks > 8 then aLink.Data[CONDUIT_MAX_FLOW_INDEX] := TokList[8];
aLink.Data[COMMENT_INDEX ] := Comment;
Result := 0;
end;
end;
end;

function ReadPumpData: Integer;
//-----------------------------------------------------------------------------
// Reads pump data from a line of input.
//-----------------------------------------------------------------------------
var
aLink : TLink;
aNode1: TNode;
aNode2: TNode;
ID : String;
N : Integer;
begin
if nToks < 4
then Result := ErrMsg(ITEMS_ERR, '')
else begin
ID := TokList[0];
aNode1 := FindNode(TokList[1]);
aNode2 := FindNode(TokList[2]);
if (aNode1 = nil) then Result := ErrMsg(NODE_ERR, TokList[1])
else if (aNode2 = nil) then Result := ErrMsg(NODE_ERR, TokList[2])
else begin
aLink := TLink.Create;
LinkList.AddObject(ID, aLink);
aLink.Ltype := PUMP;
aLink.Node1 := aNode1;
aLink.Node2 := aNode2;
aLink.Zindex := -1;
Uutils.CopyStringArray(Project.DefProp[PUMP].Data, aLink.Data);
Project.Lists[PUMP].AddObject(ID, aLink);
Project.HasItems[PUMP] := True;

// Skip over PumpType if line has old format
if Uutils.FindKeyWord(TokList[3], PumpTypes, 5) >= 0 then N := 4
else N := 3;
if Ntoks <= N then Result := ErrMsg(ITEMS_ERR, '')
else
begin
aLink.Data[PUMP_CURVE_INDEX] := TokList[N];
if nToks > N+1 then aLink.Data[PUMP_STATUS_INDEX] := TokList[N+1];
if nToks > N+2 then aLink.Data[PUMP_STARTUP_INDEX] := TokList[N+2];
if nToks > N+3 then aLink.Data[PUMP_SHUTOFF_INDEX] := TokList[N+3];
aLink.Data[COMMENT_INDEX ] := Comment;
Result := 0;
end;
end;
end;
end;

function ReadOrificeData: Integer;
//-----------------------------------------------------------------------------
// Reads orifice data from a line of input.
//-----------------------------------------------------------------------------
var
aLink : TLink;
aNode1: TNode;
aNode2: TNode;
ID : String;
begin
if nToks < 6
then Result := ErrMsg(ITEMS_ERR, '')
else begin
ID := TokList[0];
aNode1 := FindNode(TokList[1]);
aNode2 := FindNode(TokList[2]);
if (aNode1 = nil) then Result := ErrMsg(NODE_ERR, TokList[1])
else if (aNode2 = nil) then Result := ErrMsg(NODE_ERR, TokList[2])
else begin
aLink := TLink.Create;
LinkList.AddObject(ID, aLink);
aLink.Ltype := ORIFICE;
aLink.Node1 := aNode1;
aLink.Node2 := aNode2;
aLink.Zindex := -1;
Uutils.CopyStringArray(Project.DefProp[ORIFICE].Data, aLink.Data);
Project.Lists[ORIFICE].AddObject(ID, aLink);
Project.HasItems[ORIFICE] := True;
aLink.Data[ORIFICE_TYPE_INDEX] := TokList[3];
aLink.Data[ORIFICE_BOTTOM_HT_INDEX] := TokList[4];
aLink.Data[ORIFICE_COEFF_INDEX] := TokList[5];
if nToks >= 7
then aLink.Data[ORIFICE_FLAPGATE_INDEX] := TokList[6];
if nToks >= 8
then aLink.Data[ORIFICE_ORATE_INDEX] := TokList[7];
aLink.Data[COMMENT_INDEX ] := Comment;
Result := 0;
end;
end;
end;

function ReadWeirData: Integer;
//-----------------------------------------------------------------------------
// Reads weir data from a line of input.
//-----------------------------------------------------------------------------
var
aLink : TLink;
aNode1: TNode;
aNode2: TNode;
ID : String;
begin
if nToks < 6
then Result := ErrMsg(ITEMS_ERR, '')
else begin
ID := TokList[0];
aNode1 := FindNode(TokList[1]);
aNode2 := FindNode(TokList[2]);
if (aNode1 = nil) then Result := ErrMsg(NODE_ERR, TokList[1])
else if (aNode2 = nil) then Result := ErrMsg(NODE_ERR, TokList[2])
else begin
aLink := TLink.Create;
LinkList.AddObject(ID, aLink);
aLink.Ltype := WEIR;
aLink.Node1 := aNode1;
aLink.Node2 := aNode2;
aLink.Zindex := -1;
Uutils.CopyStringArray(Project.DefProp[WEIR].Data, aLink.Data);
Project.Lists[WEIR].AddObject(ID, aLink);
Project.HasItems[WEIR] := True;
aLink.Data[WEIR_TYPE_INDEX] := TokList[3];
aLink.Data[WEIR_CREST_INDEX] := TokList[4];
aLink.Data[WEIR_COEFF_INDEX] := TokList[5];

//// Following section modified for release 5.1.007. //// //(5.1.007)
if (nToks >= 7) and not SameText(TokList[6], '*') then
aLink.Data[WEIR_FLAPGATE_INDEX] := TokList[6];
if (nToks >= 8) and not SameText(TokList[7], '*') then
aLink.Data[WEIR_CONTRACT_INDEX] := TokList[7];
if (nToks >= 9) and not SameText(TokList[8], '*') then
aLink.Data[WEIR_END_COEFF_INDEX] := TokList[8];
if (nToks >= 10) and not SameText(TokList[9], '*') then
aLink.Data[WEIR_SURCHARGE_INDEX] := TokList[9];

//// Following section added for release 5.1.010. //(5.1.010)
if (nToks >= 11) and not SameText(TokList[10], '*') then
aLink.Data[WEIR_ROAD_WIDTH_INDEX] := TokList[10];
if (nToks >= 12) and not SameText(TokList[11], '*') then
aLink.Data[WEIR_ROAD_SURF_INDEX] := TokList[11];
////

aLink.Data[COMMENT_INDEX] := Comment;
Result := 0;
end;
end;
end;

function ReadOutletData: Integer;
//-----------------------------------------------------------------------------
// Reads outlet data from a line of input.
//-----------------------------------------------------------------------------
var
aLink : TLink;
aNode1: TNode;
aNode2: TNode;
ID : String;
N : Integer;
begin
if nToks < 6
then Result := ErrMsg(ITEMS_ERR, '')
else begin
ID := TokList[0];
aNode1 := FindNode(TokList[1]);
aNode2 := FindNode(TokList[2]);
if (aNode1 = nil) then Result := ErrMsg(NODE_ERR, TokList[1])
else if (aNode2 = nil) then Result := ErrMsg(NODE_ERR, TokList[2])
else begin
aLink := TLink.Create;
LinkList.AddObject(ID, aLink);
aLink.Ltype := OUTLET;
aLink.Node1 := aNode1;
aLink.Node2 := aNode2;
aLink.Zindex := -1;
Uutils.CopyStringArray(Project.DefProp[OUTLET].Data, aLink.Data);
Project.Lists[OUTLET].AddObject(ID, aLink);
Project.HasItems[OUTLET] := True;
aLink.Data[OUTLET_CREST_INDEX] := TokList[3];

//... added for backwards compatibility
if SameText(TokList[4], 'TABULAR') then TokList[4] := 'TABULAR/DEPTH';
if SameText(TokList[4], 'FUNCTIONAL') then TokList[4] := 'FUNCTIONAL/DEPTH';
aLink.Data[OUTLET_TYPE_INDEX] := TokList[4];

if AnsiContainsText(TokList[4], 'TABULAR') then
begin
aLink.Data[OUTLET_QTABLE_INDEX] := TokList[5];
N := 6;
end
else begin
if Ntoks < 7 then
begin
Result := ErrMsg(ITEMS_ERR, '');
Exit;
end
else
begin
aLink.Data[OUTLET_QCOEFF_INDEX] := TokList[5];
aLink.Data[OUTLET_QEXPON_INDEX] := TokList[6];
N := 7;
end;
end;
if Ntoks > N then aLink.Data[OUTLET_FLAPGATE_INDEX] := TokList[N];
aLink.Data[COMMENT_INDEX ] := Comment;
Result := 0;
end;
end;
end;

function GetXsectShape(const S: String): Integer;
//-----------------------------------------------------------------------------
// Finds the code number corresponding to cross section shape S.
//-----------------------------------------------------------------------------
var
I: Integer;
begin
for I := 0 to High(Dxsect.XsectShapes) do
begin
if CompareText(S, Dxsect.XsectShapes[I].Text[1]) = 0 then
begin
Result := I;
Exit;
end;
end;
Result := -1;
end;

//// New procedure added to release 5.1.008. //// //(5.1.008)
procedure CheckForStdSize;
//-----------------------------------------------------------------------------
// Converts from old format for standard size ellipse and arch pipes
// to new format.
//-----------------------------------------------------------------------------
var
J: Integer;
X: Extended;
begin
// Old format had size code as 3rd token and 0 for 4th token
J := StrToIntDef(TokList[2], 0);
Uutils.GetExtended(TokList[3], X);
if (J > 0) and (X = 0) then
begin
// New format has 5th token as size code
TokList[4] := TokList[2];
TokList[2] := '0';
TokList[3] := '0';
end;
end;

function ReadXsectionData: Integer;
//-----------------------------------------------------------------------------
// Reads cross section data froma line of input.
//-----------------------------------------------------------------------------
var
I : Integer;
ID : String;
aLink : TLink;
begin
if nToks < 3
then Result := ErrMsg(ITEMS_ERR, '')
else begin
ID := TokList[0];
aLink := FindLink(ID);
if (aLink = nil)
then Result := ErrMsg(LINK_ERR, TokList[0])
else begin
I := GetXsectShape(TokList[1]);
if I < 0 then Result := ErrMsg(KEYWORD_ERR, TokList[1])
else case aLink.Ltype of

CONDUIT:
begin
aLink.Data[CONDUIT_SHAPE_INDEX] := TokList[1];
if I = Dxsect.IRREG_SHAPE_INDEX then
begin
aLink.Data[CONDUIT_TSECT_INDEX] := TokList[2];
aLink.Data[CONDUIT_GEOM1_INDEX] := ''; //(5.1.008)
Result := 0;
end

else begin
if nToks < 6 then Result := ErrMsg(ITEMS_ERR, '')
else begin
{
//// Added to release 5.1.008. //// //(5.1.008)
if I in [Dxsect.HORIZ_ELLIPSE_SHAPE_INDEX,
Dxsect.VERT_ELLIPSE_SHAPE_INDEX,
Dxsect.ARCH_SHAPE_INDEX]
then CheckForStdSize;
}
aLink.Data[CONDUIT_GEOM1_INDEX] := TokList[2];
aLink.Data[CONDUIT_GEOM2_INDEX] := TokList[3];
aLink.Data[CONDUIT_GEOM3_INDEX] := TokList[4];
aLink.Data[CONDUIT_GEOM4_INDEX] := TokList[5];
if Ntoks > 6 then aLink.Data[CONDUIT_BARRELS_INDEX] := TokList[6];
if Ntoks > 7 then aLink.Data[CONDUIT_CULVERT_INDEX] := TokList[7];
if I = Dxsect.CUSTOM_SHAPE_INDEX then
aLink.Data[CONDUIT_TSECT_INDEX] := TokList[3];
Result := 0;
end;
end;
end;

ORIFICE:
begin
if not I in [0, 1] then Result := ErrMsg(XSECT_ERR, TokList[0])
else begin
aLink.Data[ORIFICE_SHAPE_INDEX] := TokList[1];
aLink.Data[ORIFICE_HEIGHT_INDEX] := TokList[2];
aLink.Data[ORIFICE_WIDTH_INDEX] := TokList[3];
Result := 0;
end;
end;

WEIR:
begin
if not I in [2, 3, 4] then Result := ErrMsg(XSECT_ERR, TokList[0])
else begin
aLink.Data[WEIR_SHAPE_INDEX] := TokList[1];
aLink.Data[WEIR_HEIGHT_INDEX] := TokList[2];
aLink.Data[WEIR_WIDTH_INDEX] := TokList[3];
aLink.Data[WEIR_SLOPE_INDEX] := TokList[4];
Result := 0;
end;
end;

else Result := 0;
end;
end;
end;
end;

function ReadTransectData: Integer;
//-----------------------------------------------------------------------------
// Reads transect data from a line of input.
//-----------------------------------------------------------------------------
var
I : Integer;
K : Integer;
N : Integer;
ID : String;
Tsect : TTransect;
begin
Result := 0;
if SameText(TokList[0], 'NC') then
begin
if nToks < 4 then Result := ErrMsg(ITEMS_ERR, '')
else for I := 1 to 3 do ManningsN[I] := TokList[I];
TsectComment := Comment;
Exit;
end;

if SameText(TokList[0], 'X1') then
begin
if nToks < 2 then Exit;
ID := TokList[1];
Tsect := TTransect.Create;

if Length(Comment) > 0 then TsectComment := Comment;
Tsect.Comment := TsectComment;

Project.Lists[TRANSECT].AddObject(ID, Tsect);
Project.HasItems[TRANSECT] := True;
Tsect.Data[TRANSECT_N_LEFT] := ManningsN[1];
Tsect.Data[TRANSECT_N_RIGHT] := ManningsN[2];
Tsect.Data[TRANSECT_N_CHANNEL] := ManningsN[3];
if nToks < 10 then Result := ErrMsg(ITEMS_ERR, '')
else
begin
Tsect.Data[TRANSECT_X_LEFT] := TokList[3];
Tsect.Data[TRANSECT_X_RIGHT] := TokList[4];
Tsect.Data[TRANSECT_L_FACTOR] := TokList[7];
Tsect.Data[TRANSECT_X_FACTOR] := TokList[8];
Tsect.Data[TRANSECT_Y_FACTOR] := TokList[9];
end;
Exit;
end;

if SameText(TokList[0], 'GR') then
begin
N := Project.Lists[TRANSECT].Count;
if N = 0 then Result := ErrMsg(TRANSECT_ERR, '')
else begin
Tsect := TTransect(Project.Lists[TRANSECT].Objects[N-1]);
K := 1;
while K + 1 < Ntoks do
begin
Tsect.Ydata.Add(TokList[K]);
Tsect.Xdata.Add(TokList[K+1]);
K := K + 2;
end;
end;
Exit;
end;
end;

function ReadLossData: Integer;
//-----------------------------------------------------------------------------
// Reads conduit loss data from a line of input.
//-----------------------------------------------------------------------------
var
ID : String;
aLink : TLink;
begin
if nToks < 4
then Result := ErrMsg(ITEMS_ERR, '')
else begin
ID := TokList[0];
aLink := FindLink(ID);
if (aLink = nil) then Result := ErrMsg(LINK_ERR, ID)
else if (aLink.Ltype <> CONDUIT) then Result := 0
else begin
aLink.Data[CONDUIT_ENTRY_LOSS_INDEX] := TokList[1];
aLink.Data[CONDUIT_EXIT_LOSS_INDEX] := TokList[2];
aLink.Data[CONDUIT_AVG_LOSS_INDEX] := TokList[3];
if nToks >= 5
then aLink.Data[CONDUIT_CHECK_VALVE_INDEX] := TokList[4];
if nToks >= 6
then aLink.Data[CONDUIT_SEEPAGE_INDEX] := TokList[5];
Result := 0;
end;
end;
end;

function ReadPollutantData: Integer;
//-----------------------------------------------------------------------------
// Reads pollutant data from a line of input.
//-----------------------------------------------------------------------------
var
ID : String;
aPollut : TPollutant;
X : Single;
begin
if nToks < 5
then Result := ErrMsg(ITEMS_ERR, '')
else begin

// Add new pollutant to project
ID := TokList[0];
aPollut := TPollutant.Create;
Uutils.CopyStringArray(Project.DefProp[POLLUTANT].Data, aPollut.Data);
Project.Lists[POLLUTANT].AddObject(ID, aPollut);
Project.HasItems[POLLUTANT] := True;

// Parse units & concens.
aPollut.Data[POLLUT_UNITS_INDEX] := TokList[1];
aPollut.Data[POLLUT_RAIN_INDEX] := TokList[2];
aPollut.Data[POLLUT_GW_INDEX] := TokList[3];

// This is for old format
if (Ntoks = 5)
or ( (Ntoks = 7) and Uutils.GetSingle(TokList[6], X) ) then
begin
aPollut.Data[POLLUT_DECAY_INDEX] := TokList[4];
if nToks >= 7 then
begin
aPollut.Data[POLLUT_COPOLLUT_INDEX] := TokList[5];
aPollut.Data[POLLUT_FRACTION_INDEX] := TokList[6];
end;
end

// This is for new format
else
begin
aPollut.Data[POLLUT_II_INDEX] := TokList[4];
if Ntoks >= 6 then aPollut.Data[POLLUT_DECAY_INDEX] := TokList[5];
if nToks >= 7 then aPollut.Data[POLLUT_SNOW_INDEX] := TokList[6];
if Ntoks >= 9 then
begin
aPollut.Data[POLLUT_COPOLLUT_INDEX] := TokList[7];
aPollut.Data[POLLUT_FRACTION_INDEX] := TokList[8];
end;
if Ntoks >= 10 then aPollut.Data[POLLUT_DWF_INDEX] := TokList[9];
if Ntoks >= 11 then aPollut.Data[POLLUT_INIT_INDEX] := TokList[10];
end;
Result := 0;
end;
end;

function ReadLanduseData: Integer;
//-----------------------------------------------------------------------------
// Reads land use data from a line of input.
//-----------------------------------------------------------------------------
var
ID : String;
aLanduse : TLanduse;
aNonPtSource : TNonpointSource;
J : Integer;
begin
ID := TokList[0];
aLanduse := TLanduse.Create;
for J := 0 to Project.Lists[POLLUTANT].Count - 1 do
begin
aNonPtSource := TNonpointSource.Create;
aLanduse.NonpointSources.AddObject(Project.Lists[POLLUTANT].Strings[J],
aNonPtSource);
end;
Project.Lists[LANDUSE].AddObject(ID, aLanduse);
Project.HasItems[LANDUSE] := True;
if Ntoks > 1 then aLanduse.Data[LANDUSE_CLEANING_INDEX] := TokList[1];
if Ntoks > 2 then aLanduse.Data[LANDUSE_AVAILABLE_INDEX] := TokList[2];
if Ntoks > 3 then aLanduse.Data[LANDUSE_LASTCLEAN_INDEX] := TokList[3];
aLanduse.Data[COMMENT_INDEX ] := Comment;
Result := 0;
end;

function ReadBuildupData: Integer;
//-----------------------------------------------------------------------------
// Reads pollutant buildup function data from a line of input.
//-----------------------------------------------------------------------------
var
LanduseIndex : Integer;
PollutIndex : Integer;
aLanduse : TLanduse;
aNonpointSource: TNonpointSource;
J : Integer;
begin
if nToks < 7
then Result := ErrMsg(ITEMS_ERR, '')
else begin
LanduseIndex := Project.Lists[LANDUSE].IndexOf(TokList[0]);
PollutIndex := Project.Lists[POLLUTANT].IndexOf(TokList[1]);
if (LanduseIndex < 0) then Result := ErrMsg(LANDUSE_ERR, TokList[0])
else if (PollutIndex < 0) then Result := ErrMsg(POLLUT_ERR, TokList[1])
else begin
aLanduse := TLanduse(Project.Lists[LANDUSE].Objects[LanduseIndex]);
aNonpointSource :=
TNonpointSource(aLanduse.NonpointSources.Objects[PollutIndex]);
for J := 2 to 6 do
aNonpointSource.BuildupData[J-2] := TokList[J];
Result := 0;
end;
end;
end;

function ReadWashoffData: Integer;
//-----------------------------------------------------------------------------
// Reads pollutant washoff function data from a line of input.
//-----------------------------------------------------------------------------
var
LanduseIndex : Integer;
PollutIndex : Integer;
aLanduse : TLanduse;
aNonpointSource: TNonpointSource;
J : Integer;
begin
if nToks < 7
then Result := ErrMsg(ITEMS_ERR, '')
else begin
LanduseIndex := Project.Lists[LANDUSE].IndexOf(TokList[0]);
PollutIndex := Project.Lists[POLLUTANT].IndexOf(TokList[1]);
if (LanduseIndex < 0) then Result := ErrMsg(LANDUSE_ERR, TokList[0])
else if (PollutIndex < 0) then Result := ErrMsg(POLLUT_ERR, TokList[1])
else begin
aLanduse := TLanduse(Project.Lists[LANDUSE].Objects[LanduseIndex]);
aNonpointSource :=
TNonpointSource(aLanduse.NonpointSources.Objects[PollutIndex]);
for J := 2 to 6 do
aNonpointSource.WashoffData[J-2] := TokList[J];
Result := 0;
end;
end;
end;

function ReadCoverageData: Integer;
//-----------------------------------------------------------------------------
// Reads land use coverage data from a line of input.
//-----------------------------------------------------------------------------
var
MaxToks: Integer;
X : Single;
S : TSubcatch;
S1 : String;
I : Integer;
begin
Result := 0;
S := FindSubcatch(TokList[0]);
if S = nil
then Result := ErrMsg(SUBCATCH_ERR, TokList[0])
else begin
MaxToks := 3;
while (MaxToks <= nToks) do
begin
if not Uutils.GetSingle(TokList[MaxToks-1], X) then
begin
Result := ErrMsg(NUMBER_ERR, TokList[MaxToks-1]);
break;
end;
S1 := TokList[MaxToks-2];
I := S.LandUses.IndexOfName(S1);
S1 := TokList[MaxToks-2] + '=' + TokList[MaxToks-1];
if I < 0
then S.LandUses.Add(S1)
else S.Landuses[I] := S1;
MaxToks := MaxToks + 2;
end;
S.Data[SUBCATCH_LANDUSE_INDEX] := IntToStr(S.LandUses.Count);
end;
end;

function ReadTreatmentData(Line: String): Integer;
//-----------------------------------------------------------------------------
// Reads pollutant treatment function from a line of input.
//-----------------------------------------------------------------------------
var
S : String;
aNode : TNode;
I : Integer;
begin
if Ntoks < 3
then Result := ErrMsg(ITEMS_ERR, '')
else begin
aNode := FindNode(TokList[0]);
if (aNode = nil) then Result := ErrMsg(NODE_ERR, TokList[0])
else if Project.Lists[POLLUTANT].IndexOf(TokList[1]) < 0 then
Result := ErrMsg(POLLUT_ERR, TokList[1])
else begin
I := aNode.Treatment.IndexOfName(TokList[1]);
S := Copy(Line, Pos(TokList[1], Line)+Length(TokList[1]), Length(Line));
S := TokList[1] + '=' + Trim(S);
if I < 0 then
aNode.Treatment.Add(S)
else
aNode.Treatment[I] := S;
aNode.Data[NODE_TREAT_INDEX] := 'YES';
Result := 0;
end;
end;
end;

function ReadExInflowData: Integer;
//-----------------------------------------------------------------------------
// Reads external inflow data from a line of input.
//-----------------------------------------------------------------------------
var
S : array[1..7] of String;
Inflow: String;
I : Integer;
aNode : TNode;
begin

if Ntoks < 3
then Result := ErrMsg(ITEMS_ERR, '')
else begin
aNode := FindNode(TokList[0]);
if (aNode = nil) then Result := ErrMsg(NODE_ERR, TokList[0])
else begin
S[1] := TokList[1]; // Constituent name
S[2] := TokList[2]; // Time Series name
S[3] := 'FLOW';
S[4] := '1.0';
if not SameText(S[1], 'FLOW') then
begin
if nToks >= 4 then S[3] := TokList[3] else S[3] := 'CONCEN';
if nToks >= 5 then S[4] := TokList[4] else S[4] := '1.0';
end;
if nToks >= 6 then S[5] := TokList[5] else S[5] := '1.0';
if nToks >= 7 then S[6] := TokList[6] else S[6] := '';
if nToks >= 8 then S[7] := TokList[7] else S[7] := '';
Inflow := S[1] + '=' + S[2] + #13 + S[3] + #13 + S[4] + #13 +
S[5] + #13 + S[6] + #13 + S[7];
I := aNode.DXInflow.IndexOfName(S[1]);
if I < 0 then aNode.DXInflow.Add(Inflow)
else aNode.DXInflow[I] := Inflow;
aNode.Data[NODE_INFLOWS_INDEX] := 'YES';
Result := 0;
end;
end;
end;

function ReadDWInflowData: Integer;
//-----------------------------------------------------------------------------
// Reads dry weather inflow data from a line of input.
//-----------------------------------------------------------------------------
var
M : Integer;
S : String;
S1 : String;
I : Integer;
aNode: TNode;
begin
if Ntoks < 3
then Result := ErrMsg(ITEMS_ERR, '')
else begin
aNode := FindNode(TokList[0]);
if (aNode = nil) then Result := ErrMsg(NODE_ERR, TokList[0])
else begin
S1 := TokList[1];
S := S1 + '=' + TokList[2];
for M := 3 to Ntoks-1 do S := S + #13 + TokList[M];
I := aNode.DWInflow.IndexOfName(S1);
if I < 0
then aNode.DWInflow.Add(S)
else aNode.DWInflow[I] := S;
aNode.Data[NODE_INFLOWS_INDEX] := 'YES';
Result := 0;
end;
end;
end;

function ReadPatternData: Integer;
//-----------------------------------------------------------------------------
// Reads time pattern data from a line of input.
//-----------------------------------------------------------------------------
var
ID: String;
Index: Integer;
aPattern: TPattern;
PatType: Integer;
J: Integer;
begin
if nToks < 2
then Result := ErrMsg(ITEMS_ERR, '')
else begin
J := 1;
ID := TokList[0];
Index := Project.Lists[PATTERN].IndexOf(ID);
if Index < 0 then
begin
aPattern := TPattern.Create;
aPattern.Comment := Comment;
Project.Lists[PATTERN].AddObject(ID, aPattern);
Project.HasItems[PATTERN] := True;
PatType := Uutils.FindKeyWord(TokList[1], PatternTypes, 7);
if PatType < 0 then
begin
Result := ErrMsg(KEYWORD_ERR, TokList[1]);
exit;
end;
aPattern.PatternType := PatType;
J := 2;
end
else aPattern := TPattern(Project.Lists[PATTERN].Objects[Index]);
while (J < nToks) and (aPattern.Count <= High(aPattern.Data)) do
begin
aPattern.Data[aPattern.Count] := TokList[J];
Inc(J);
Inc(aPattern.Count);
end;
Result := 0;
end;
end;

function ReadIIInflowData: Integer;
//-----------------------------------------------------------------------------
// Reads RDII inflow data from a line of input.
//-----------------------------------------------------------------------------
var
aNode: TNode;

begin
if Ntoks < 3
then Result := ErrMsg(ITEMS_ERR, '')
else begin
aNode := FindNode(TokList[0]);
if (aNode = nil) then Result := ErrMsg(NODE_ERR, TokList[0])
else begin
aNode.IIInflow.Clear;
aNode.IIInflow.Add(TokList[1]);
aNode.IIInflow.Add(TokList[2]);
aNode.Data[NODE_INFLOWS_INDEX] := 'YES';
Result := 0;
end;
end;
end;

function ReadLoadData: Integer;
//-----------------------------------------------------------------------------
// Reads initial pollutant loading data from a line of input.
//-----------------------------------------------------------------------------
var
X : Single;
S : TSubcatch;
S1 : String;
I : Integer;

begin
S := FindSubcatch(TokList[0]);
if S = nil
then Result := ErrMsg(SUBCATCH_ERR, TokList[0])
else if Project.Lists[POLLUTANT].IndexOf(TokList[1]) < 0
then Result := ErrMsg(POLLUT_ERR, TokList[1])
else if not Uutils.GetSingle(TokList[2], X)
then Result := ErrMsg(NUMBER_ERR, TokList[2])
else
begin
S1 := TokList[1] + '=' + TokList[2];
I := S.Loadings.IndexOfName(TokList[1]);
if I < 0
then S.Loadings.Add(S1)
else S.Loadings[I] := S1;
S.Data[SUBCATCH_LOADING_INDEX] := 'YES';
Result := 0;
end;
end;

function ReadCurveData: Integer;
//-----------------------------------------------------------------------------
// Reads curve data from a line of input.
//-----------------------------------------------------------------------------
var
Index : Integer;
K : Integer;
L : Integer;
M : Integer;
ObjType : Integer;
ID : String;
aCurve : TCurve;
begin
// Check for too few tokens
if Ntoks < 3
then Result := ErrMsg(ITEMS_ERR, '')
else begin

// Check if curve ID is same as for previous line
ID := TokList[0];
if (ID = PrevID) then
begin
Index := PrevIndex;
ObjType := CurveType;
end
else Project.FindCurve(ID, ObjType, Index);

// Create new curve if ID not in data base
K := 2;
if Index < 0 then
begin

// Check for valid curve type keyword
M := -1;
for L := 0 to High(CurveTypeOptions) do
begin
if SameText(TokList[1], CurveTypeOptions[L]) then
begin
M := L;
break;
end;
end;
if M < 0 then
begin
Result := ErrMsg(KEYWORD_ERR, TokList[1]);
Exit;
end;

// Convert curve type keyword index to a curve object category
case M of
0: ObjType := CONTROLCURVE;
1: ObjType := DIVERSIONCURVE;
2..5:
ObjType := PUMPCURVE;
6: ObjType := RATINGCURVE;
7: ObjType := SHAPECURVE;
8: ObjType := STORAGECURVE;
9: ObjType := TIDALCURVE;
end;

// Create a new curve object
aCurve := TCurve.Create;
aCurve.Comment := Comment;
aCurve.CurveType := TokList[1];
if ObjType = PUMPCURVE
then aCurve.CurveCode := M - 1
else aCurve.CurveCode := 0;
Project.Lists[ObjType].AddObject(ID, aCurve);
Project.HasItems[ObjType] := True;
Index := Project.Lists[ObjType].Count - 1;
PrevID := ID;
PrevIndex := Index;
CurveType := ObjType;
K := 3;
end;

// Add x,y values to the list maintained by the curve
aCurve := TCurve(Project.Lists[ObjType].Objects[Index]);
while K <= nToks-1 do
begin
aCurve.Xdata.Add(TokList[K-1]);
aCurve.Ydata.Add(TokList[K]);
K := K + 2;
end;
Result := 0;
end;
end;

function ReadTimeseriesData: Integer;
//-----------------------------------------------------------------------------
// Reads time series data from a line of input.
//-----------------------------------------------------------------------------
const
NEEDS_DATE = 1;
NEEDS_TIME = 2;
NEEDS_VALUE = 3;
var
Index : Integer;
State : Integer;
K : Integer;
ID : String;
StrDate : String;
aTseries : TTimeseries;
begin
// Check for too few tokens
Result := -1;
if Ntoks < 3 then Result := ErrMsg(ITEMS_ERR, '');

// Check if series ID is same as for previous line
ID := TokList[0];
if (ID = PrevID) then Index := PrevIndex
else Index := Project.Lists[TIMESERIES].IndexOf(ID);

// If starting input for a new series then create it
if Index < 0 then
begin
aTseries := TTimeseries.Create;
aTseries.Comment := Comment;
Project.Lists[TIMESERIES].AddObject(ID,aTseries);
Project.HasItems[TIMESERIES] := True;
Index := Project.Lists[TIMESERIES].Count - 1;
PrevID := ID;
PrevIndex := Index;
end;
aTseries := TTimeseries(Project.Lists[TIMESERIES].Objects[Index]);

// Check if external file name used
if SameText(TokList[1], 'FILE') then
begin
aTseries.Filename := TokList[2];
Result := 0;
Exit;
end;

// Add values to the list maintained by the timeseries
State := NEEDS_DATE;
K := 1;
while K < nToks do
begin
case State of

NEEDS_DATE:
begin
try
StrDate := Uutils.ConvertDate(TokList[K]);
StrToDate(StrDate, MyFormatSettings);
aTseries.Dates.Add(StrDate);
Inc(K);
if K >= nToks then break;
except
On EconvertError do aTseries.Dates.Add('');
end;
State := NEEDS_TIME;
end;

NEEDS_TIME:
begin
aTseries.Times.Add(TokList[K]);
Inc(K);
if K >= nToks then break;
State := NEEDS_VALUE;
end;

NEEDS_VALUE:
begin
aTseries.Values.Add(TokList[K]);
Result := 0;
State := NEEDS_DATE;
Inc(K);
end;
end;
end;
if Result = -1 then Result := ErrMsg(ITEMS_ERR, '');
end;

function ReadControlData(Line: String): Integer;
//-----------------------------------------------------------------------------
// Reads a control rule statement from line of input.
//-----------------------------------------------------------------------------
begin
Project.ControlRules.Add(Line);
Result := 0;
end;

function ReadLidUsageData: Integer;
//-----------------------------------------------------------------------------
// Reads LID usage data from line of input.
//-----------------------------------------------------------------------------
var
aSubcatch: TSubcatch;
begin
aSubcatch := FindSubcatch(TokList[0]);
if aSubcatch = nil then Result := ErrMsg(SUBCATCH_ERR, TokList[0])
else Result := Ulid.ReadLIDUsageData(aSubcatch, TokList, Ntoks);
end;

procedure ReadReportOption(Index: Integer);
begin
if (Ntoks >= 2) and SameText(TokList[1], 'YES') then
Project.Options.Data[Index] := 'YES'
else
Project.Options.Data[Index] := 'NO';
end;

function ReadReportData: Integer;
//-----------------------------------------------------------------------------
// Reads reporting options from a line of input.
//-----------------------------------------------------------------------------
begin
if SameText(TokList[0], 'CONTROLS')
then ReadReportOption(REPORT_CONTROLS_INDEX)
else if SameText(TokList[0], 'INPUT')
then ReadReportOption(REPORT_INPUT_INDEX)
else ReportingForm.Import(TokList, Ntoks);
Result := 0;
end;

function ReadFileData: Integer;
//-----------------------------------------------------------------------------
// Reads interface file usage from a line of input.
//-----------------------------------------------------------------------------
var
Fname: String;
begin
if Ntoks < 3
then Result := ErrMsg(ITEMS_ERR, '')
else begin
Fname := TokList[2];
if ExtractFilePath(Fname) = ''
then Fname := ExtractFilePath(Uglobals.InputFileName) + Fname;
Project.IfaceFiles.Add(TokList[0] + ' ' + TokList[1] + ' ' +
'"' + Fname + '"');
Result := 0;
end;
end;

//// This function was added to release 5.1.007. //// //(5.1.007)
function ReadAdjustmentData: Integer;
//-----------------------------------------------------------------------------
// Reads climate adjustments from a line of input.
//-----------------------------------------------------------------------------
var
I: Integer;
begin
Result := 0;
if Ntoks < 2 then exit;
if SameText(TokList[0], 'Temperature') then
begin
if Ntoks < 13 then Result := ErrMsg(ITEMS_ERR, '')
else with Project.Climatology do
begin
for I := 0 to 11 do
if StrToFloatDef(TokList[I+1], 0.0) = 0.0
then TempAdjust[I] := ''
else TempAdjust[I] := TokList[I+1];
end;
end
else if SameText(TokList[0], 'Evaporation') then
begin
if Ntoks < 13 then Result := ErrMsg(ITEMS_ERR, '')
else with Project.Climatology do
begin
for I := 0 to 11 do
if StrToFloatDef(TokList[I+1], 0.0) = 0.0
then EvapAdjust[I] := ''
else EvapAdjust[I] := TokList[I+1];
end;
end
else if SameText(TokList[0], 'Rainfall') then
begin
if Ntoks < 13 then Result := ErrMsg(ITEMS_ERR, '')
else with Project.Climatology do
begin
for I := 0 to 11 do
if StrToFloatDef(TokList[I+1], 1.0) = 1.0
then RainAdjust[I] := ''
else RainAdjust[I] := TokList[I+1];
end;
end

//// Added to release 5.1.008. //// //(5.1.008)
else if SameText(TokList[0], 'Conductivity') then
begin
if Ntoks < 13 then Result := ErrMsg(ITEMS_ERR, '')
else with Project.Climatology do
begin
for I := 0 to 11 do
if StrToFloatDef(TokList[I+1], 1.0) = 1.0
then CondAdjust[I] := ''
else CondAdjust[I] := TokList[I+1];
end;
end;
////////////////////////////////////////////////////////
end;

//// This function was added to release 5.1.011. //// //(5.1.011)
function ReadEventData(Line: String): Integer;
//-----------------------------------------------------------------------------
// Reads hydraulic event data from a line of input.
//-----------------------------------------------------------------------------
begin
Result := 0;
if Length(Line) = 0 then exit;
if LeftStr(Line,2) = ';;' then exit;
Project.Events.Add(Line);
end;

function ReadOptionData: Integer;
//-----------------------------------------------------------------------------
// Reads an analysis option from a line of input.
//-----------------------------------------------------------------------------
var
Index : Integer;
Keyword : String;
S : String;
S2: String;
I : Integer;
X : Single;
T : Extended;
begin
// Check which keyword applies
Result := 0;
if Ntoks < 2 then exit;
Keyword := TokList[0];
if SameText(Keyword, 'TEMPDIR') then exit;
Index := Uutils.FindKeyWord(Keyword, OptionLabels, 17);
case Index of

-1: Result := ErrMsg(KEYWORD_ERR, Keyword);

ROUTING_MODEL_INDEX:
begin
if SameText(TokList[1], 'NONE') then
begin
Project.Options.Data[IGNORE_ROUTING_INDEX] := 'YES';
Exit;
end;

I := Uutils.FindKeyWord(TokList[1], OldRoutingOptions, 3);
if I >= 0 then TokList[1] := RoutingOptions[I];
end;

START_DATE_INDEX, REPORT_START_DATE_INDEX, END_DATE_INDEX:
begin
S := Uutils.ConvertDate(TokList[1]);
try
StrToDate(S, MyFormatSettings);
TokList[1] := S;
except
on EConvertError do Result := ErrMsg(DATE_ERR, '');
end;
end;

START_TIME_INDEX, REPORT_START_TIME_INDEX, END_TIME_INDEX:
begin
S := TokList[1];
try
StrToTime(S, MyFormatSettings);
TokList[1] := S;
except
on EConvertError do Result := ErrMsg(DATE_ERR, '');
end;
end;

SWEEP_START_INDEX, SWEEP_END_INDEX:
begin
S := Uutils.ConvertDate(TokList[1]);
S2 := S + '/1947';
try
StrToDate(S2, MyFormatSettings);
TokList[1] := S;
except
on EConvertError do Result := ErrMsg(DATE_ERR, '');
end;
end;

WET_STEP_INDEX, DRY_STEP_INDEX, REPORT_STEP_INDEX:
begin
S := TokList[1];
if Uutils.StrHoursToTime(S) = -1 then Result := ErrMsg(TIMESTEP_ERR, '');
end;

ROUTING_STEP_INDEX:
begin
S := TokList[1];
T := 0.0;
if not Uutils.GetExtended(S, T) then
begin
T := Uutils.StrHoursToTime(S)*86400.;
if T <= 0.0 then Result := ErrMsg(TIMESTEP_ERR, '')
else TokList[1] := Format('%.0f',[T]);
end;
end;

VARIABLE_STEP_INDEX:
begin
if Uutils.GetSingle(TokList[1], X) then
TokList[1] := IntToStr(Round(100.0*X))
else
TokList[1] := '0';
end;

INERTIAL_DAMPING_INDEX:
begin
if Uutils.GetSingle(TokList[1], X) then
begin
if X = 0 then TokList[1] := 'NONE'
else TokList[1] := 'PARTIAL';
end;
end;

// This option is now fixed to SWMM 4.
COMPATIBILITY_INDEX:
begin
TokList[1] := '4';
end;

MIN_ROUTE_STEP_INDEX, //(5.1.008)
LENGTHEN_STEP_INDEX,
MIN_SURFAREA_INDEX,
MIN_SLOPE_INDEX,
MAX_TRIALS_INDEX,
HEAD_TOL_INDEX,
SYS_FLOW_TOL_INDEX,
LAT_FLOW_TOL_INDEX:
begin
Uutils.GetSingle(TokList[1], X);
if X <= 0 then TokList[1] := '0';
end;

NORMAL_FLOW_LTD_INDEX:
begin
if SameText(TokList[1], 'NO') or SameText(TokList[1], 'SLOPE')
then TokList[1] := 'SLOPE'
else if SameText(TokList[1], 'YES') or SameText(TokList[1], 'FROUDE')
then TokList[1] := 'FROUDE'
else if SameText(TokList[1], 'BOTH') then TokList[1] := 'BOTH'
else Result := ErrMsg(KEYWORD_ERR, TokList[1]);
end;

FORCE_MAIN_EQN_INDEX:
begin
I := Uutils.FindKeyWord(TokList[1], ForceMainEqnOptions, 3);
if I < 0 then Result := ErrMsg(KEYWORD_ERR, TokList[1])
else TokList[1] := ForceMainEqnOptions[I];
end;

LINK_OFFSETS_INDEX:
begin
I := Uutils.FindKeyWord(TokList[1], LinkOffsetsOptions, 10);
if I < 0 then Result := ErrMsg(KEYWORD_ERR, TokList[1])
else TokList[1] := LinkOffsetsOptions[I];
end;

IGNORE_RAINFALL_INDEX,
IGNORE_SNOWMELT_INDEX,
IGNORE_GRNDWTR_INDEX,
IGNORE_ROUTING_INDEX,
IGNORE_QUALITY_INDEX:
begin
if not SameText(TokList[1], 'YES') and not SameText(TokList[1], 'NO')
then Result := ErrMsg(KEYWORD_ERR, TokList[1]);
end;

//// Following section added to release 5.1.010. //// //(5.1.010)
NUM_THREADS_INDEX:
begin
I := StrToIntDef(TokList[1], 1);
if I < 0 then I := 1;
if (I = 0) or (I > Uutils.GetCPUs) then I := Uutils.GetCPUs;
TokList[1] := IntToStr(I);
end;
////

end;
if Result = 0 then Project.Options.Data[Index] := TokList[1];
end;

function ReadTagData: Integer;
//-----------------------------------------------------------------------------
// Reads in tag data from a line of input.
//-----------------------------------------------------------------------------
const
TagTypes: array[0..3] of PChar = ('Gage', 'Subcatch', 'Node', 'Link');
var
I, J : Integer;
aNode: TNode;
aLink: TLink;
begin
Result := 0;
if Ntoks < 3
then Result := ErrMsg(ITEMS_ERR, '')
else begin
I := Uutils.FindKeyWord(TokList[0], TagTypes, 4);
case I of

-1: Result := ErrMsg(KEYWORD_ERR, TokList[0]);

0: begin
J := Project.Lists[RAINGAGE].IndexOf(TokList[1]);
if J >= 0 then with Project.GetGage(J) do Data[TAG_INDEX] := TokList[2];
end;

1: begin
J := Project.Lists[SUBCATCH].IndexOf(TokList[1]);
if J >= 0 then with Project.GetSubcatch(SUBCATCH, J) do
Data[TAG_INDEX] := TokList[2];
end;

2: begin
aNode := FindNode(TokList[1]);
if (aNode <> nil) then aNode.Data[TAG_INDEX] := TokList[2];
end;

3: begin
aLink := FindLink(TokList[1]);
if (aLink <> nil) then aLink.Data[TAG_INDEX] := TokList[2];
end;
end;
end;
end;

function ReadSymbolData: Integer;
//-----------------------------------------------------------------------------
// Reads rain gage coordinate data from a line of input.
//-----------------------------------------------------------------------------
var
J : Integer;
X, Y : Extended;
aGage : TRaingage;
begin
Result := 0;
if (Ntoks < 3)
then Result := ErrMsg(ITEMS_ERR, '')
else begin

// Locate the gage ID in the database
J := Project.Lists[RAINGAGE].IndexOf(TokList[0]);

// If gage exists then assign it X & Y coordinates
if (J >= 0) then
begin
aGage := Project.GetGage(J);
if not Uutils.GetExtended(TokList[1], X) then
Result := ErrMsg(NUMBER_ERR, TokList[1])
else if not Uutils.GetExtended(TokList[2], Y) then
Result := ErrMsg(NUMBER_ERR, TokList[2])
else
begin
aGage.X := X;
aGage.Y := Y;
end;
end;
end;
end;

function ReadMapData: Integer;
//-----------------------------------------------------------------------------
// Reads map dimensions data from a line of input.
//-----------------------------------------------------------------------------
var
I : Integer;
Index : Integer;
Keyword : String;
X : array[1..4] of Extended;
begin
// Check which keyword applies
Result := 0;
Keyword := TokList[0];
Index := Uutils.FindKeyWord(Keyword, MapWords, 4);
case Index of

0: // Map dimensions
begin
if Ntoks < 5 then Result := ErrMsg(ITEMS_ERR, '')
else begin
for I := 1 to 4 do
if not Uutils.GetExtended(TokList[I], X[I]) then
Result := ErrMsg(NUMBER_ERR, TokList[I]);
if Result = 0 then with MapForm.Map.Dimensions do
begin
LowerLeft.X := X[1];
LowerLeft.Y := X[2];
UpperRight.X := X[3];
UpperRight.Y := X[4];
MapExtentSet := True;
end;
end;
end;

1: //Map units
if Ntoks > 1 then
begin
I := Uutils.FindKeyWord(Copy(TokList[1], 1, 1), MapUnits, 1);
if I < 0 then Result := ErrMsg(KEYWORD_ERR, TokList[1])
else MapForm.Map.Dimensions.Units := TMapUnits(I);
with MapForm.Map.Dimensions do
begin
if Units = muDegrees then Digits := MAXDEGDIGITS
else Digits := Umap.DefMapDimensions.Digits;
end;
end;

else Result := ErrMsg(KEYWORD_ERR, Keyword);
end;
end;

function ReadCoordData: Integer;
//-----------------------------------------------------------------------------
// Reads node coordinate data from a line of input.
//-----------------------------------------------------------------------------
var
X, Y : Extended;
aNode : TNode;
begin
Result := 0;
if (Ntoks < 3)
then Result := ErrMsg(ITEMS_ERR, '')
else begin

// Locate the node ID in the database
aNode := FindNode(TokList[0]);

// If node exists then assign it X & Y coordinates
if (aNode <> nil) then
begin
if not Uutils.GetExtended(TokList[1], X) then
Result := ErrMsg(NUMBER_ERR, TokList[1])
else if not Uutils.GetExtended(TokList[2], Y) then
Result := ErrMsg(NUMBER_ERR, TokList[2])
else
begin
aNode.X := X;
aNode.Y := Y;
end;
end;
end;
end;

function ReadVertexData: Integer;
//-----------------------------------------------------------------------------
// Reads link vertex coordinate data from a line of input.
//-----------------------------------------------------------------------------
var
X, Y : Extended;
aLink : TLink;

begin
Result := 0;
if (Ntoks < 3)
then Result := ErrMsg(ITEMS_ERR, '')
else begin

// Locate the link ID in the database
aLink := FindLink(TokList[0]);;

// If link exists then assign it X & Y coordinates
if (aLink <> nil) then
begin
if not Uutils.GetExtended(TokList[1], X) then
Result := ErrMsg(NUMBER_ERR, TokList[1])
else if not Uutils.GetExtended(TokList[2], Y) then
Result := ErrMsg(NUMBER_ERR, TokList[2])
else aLink.Vlist.Add(X, Y);
end;
end;
end;

function ReadPolygonData: Integer;
//-----------------------------------------------------------------------------
// Reads polygon coordinates associated with subcatchment outlines.
//-----------------------------------------------------------------------------
var
Index : Integer;
X, Y : Extended;
S : TSubcatch;
begin
Result := 0;
if (Ntoks < 3)
then Result := ErrMsg(ITEMS_ERR, '')
else begin

// Locate the subcatchment ID in the database
S := nil;
Index := Project.Lists[SUBCATCH].IndexOf(TokList[0]);
if Index >= 0 then S := Project.GetSubcatch(SUBCATCH, Index);

// If subcatchment exists then add a new vertex to it
if (S <> nil) then
begin
if not Uutils.GetExtended(TokList[1], X) then
Result := ErrMsg(NUMBER_ERR, TokList[1])
else if not Uutils.GetExtended(TokList[2], Y) then
Result := ErrMsg(NUMBER_ERR, TokList[2])
else S.Vlist.Add(X, Y);
end;
end;
end;

function ReadLabelData: Integer;
//-----------------------------------------------------------------------------
// Reads map label data from a line of input.
//-----------------------------------------------------------------------------
var
Ntype : Integer;
Index : Integer;
X, Y : Extended;
S : String;
aMapLabel: TMapLabel;
begin
if (Ntoks < 3)
then Result := ErrMsg(ITEMS_ERR, '')
else begin
if not Uutils.GetExtended(TokList[0], X) then
Result := ErrMsg(NUMBER_ERR, TokList[0])
else if not Uutils.GetExtended(TokList[1], Y) then
Result := ErrMsg(NUMBER_ERR, TokList[1])
else begin
S := TokList[2];
aMapLabel := TMapLabel.Create;
aMapLabel.X := X;
aMapLabel.Y := Y;
Project.Lists[MAPLABEL].AddObject(S, aMapLabel);
Index := Project.Lists[MAPLABEL].Count - 1;
aMapLabel.Text := PChar(Project.Lists[MAPLABEL].Strings[Index]);
Project.HasItems[MAPLABEL] := True;
if Ntoks >= 4 then
begin
if (Length(TokList[3]) > 0) and
Project.FindNode(TokList[3], Ntype, Index) then
aMapLabel.Anchor := Project.GetNode(Ntype, Index);
end;
if Ntoks >= 5 then aMapLabel.FontName := TokList[4];
if Ntoks >= 6 then aMapLabel.FontSize := StrToInt(TokList[5]);
if Ntoks >= 7 then
if StrToInt(TokList[6]) = 1 then aMapLabel.FontBold := True;
if Ntoks >= 8 then
if StrToInt(TokList[7]) = 1 then aMapLabel.FontItalic := True;
Result := 0;
end;
end;
end;

function ReadBackdropData: Integer;
//-----------------------------------------------------------------------------
// Reads map backdrop image information from a line of input.
//-----------------------------------------------------------------------------
var
Index : Integer;
Keyword : String;
I : Integer;
X : array[1..4] of Extended;
begin
// Check which keyword applies
Result := 0;
Keyword := TokList[0];
Index := Uutils.FindKeyWord(Keyword, BackdropWords, 4);
case Index of

0: //Backdrop file
if Ntoks > 1 then MapForm.Map.Backdrop.Filename := TokList[1];

1: // Backdrop dimensions
begin
if Ntoks < 5 then Result := ErrMsg(ITEMS_ERR, '')
else begin
for i := 1 to 4 do
if not Uutils.GetExtended(TokList[I], X[I]) then
Result := ErrMsg(NUMBER_ERR, TokList[I]);
if Result = 0 then with MapForm.Map.Backdrop do
begin
LowerLeft.X := X[1];
LowerLeft.Y := X[2];
UpperRight.X := X[3];
UpperRight.Y := X[4];
end;
end;
end;

2: //Map units - deprecated
if Ntoks > 1 then
begin
i := Uutils.FindKeyWord(Copy(TokList[1], 1, 1), MapUnits, 1);
if I < 0 then Result := ErrMsg(KEYWORD_ERR, TokList[1])
else MapForm.Map.Dimensions.Units := TMapUnits(I);
end;

3, 4: //Backdrop offset or scaling -- deprecated
begin
if Ntoks < 3 then Result := ErrMsg(ITEMS_ERR, '')
else if not Uutils.GetExtended(TokList[1], X[1]) then
Result := ErrMsg(NUMBER_ERR, TokList[1])
else if not Uutils.GetExtended(TokList[2], X[2]) then
Result := ErrMsg(NUMBER_ERR, TokList[2])
else
begin
if Index = 3 then
begin
BackdropX := X[1];
BackdropY := X[2];
end
else
begin
BackdropW := X[1];
BackdropH := X[2];
end;
end;
end;

else Result := ErrMsg(KEYWORD_ERR, Keyword);
end;
end;

function ReadProfileData: Integer;
//-----------------------------------------------------------------------------
// Reads profile plot data from a line of input.
//-----------------------------------------------------------------------------
var
I, J: Integer;
S : String;
begin
Result := 0;
if (Ntoks < 2) then Exit;

// Locate the profile name in the database
I := Project.ProfileNames.IndexOf(TokList[0]);

// If profile does not exist then create it
if (I < 0) then
begin
Project.ProfileNames.Add(TokList[0]);
I := Project.ProfileNames.Count-1;
S := '';
Project.ProfileLinks.Add(S);
end
else S := Project.ProfileLinks[I] + #13;

// Add each remaining token to the list of links in the profile
S := S + TokList[1];
for J := 2 to Ntoks-1 do
S := S + #13 + TokList[J];
Project.ProfileLinks[I] := S;
end;

procedure SetMapDimensions;
//-----------------------------------------------------------------------------
// Determines map dimensions based on range of object coordinates.
//-----------------------------------------------------------------------------
begin
with MapForm.Map do
begin
// Dimensions not provided in [MAP] section
if not MapExtentSet then
begin

// Dimensions were provided in [BACKDROP] section
if (Backdrop.LowerLeft.X <> Backdrop.UpperRight.X) then
begin

// Interpret these as map dimensions
Dimensions.LowerLeft := Backdrop.LowerLeft;
Dimensions.UpperRight := Backdrop.UpperRight;

// Compute backdrop dimensions from Offset and Scale values
Backdrop.LowerLeft.X := BackdropX;
Backdrop.LowerLeft.Y := BackdropY - BackdropH;
Backdrop.UpperRight.X := BackdropX + BackdropW;
Backdrop.UpperRight.Y := BackdropY;
end

// No dimensions of any kind provided
else with Dimensions do
Ucoords.GetCoordExtents(LowerLeft.X, LowerLeft.Y,
UpperRight.X, UpperRight.Y);
end;
end;
end;

function ParseInpLine(S: String): Integer;
//-----------------------------------------------------------------------------
// Parses current input line depending on current section of input file.
//-----------------------------------------------------------------------------
begin
case Section of
1: Result := ReadOptionData;
2: Result := ReadRaingageData;
3: Result := ReadHydrographData;
4: Result := ReadEvaporationData;
5: Result := ReadSubcatchmentData;
6: Result := ReadSubareaData;
7: Result := ReadInfiltrationData;
8: Result := ReadAquiferData;
9: Result := ReadGroundwaterData;
10: Result := ReadJunctionData;
11: Result := ReadOutfallData;
12: Result := ReadStorageData;
13: Result := ReadDividerData;
14: Result := ReadConduitData;
15: Result := ReadPumpData;
16: Result := ReadOrificeData;
17: Result := ReadWeirData;
18: Result := ReadOutletData;
19: Result := ReadXsectionData;
20: Result := ReadTransectData;
21: Result := ReadLossData;
//22: ReadControlData called directly from ReadFile
23: Result := ReadPollutantData;
24: Result := ReadLanduseData;
25: Result := ReadBuildupData;
26: Result := ReadWashoffData;
27: Result := ReadCoverageData;
28: Result := ReadExInflowData;
29: Result := ReadDWInflowData;
30: Result := ReadPatternData;
31: Result := ReadIIInflowData;
32: Result := ReadLoadData;
33: Result := ReadCurveData;
34: Result := ReadTimeseriesData;
35: Result := ReadReportData;
36: Result := ReadFileData;
37: Result := ReadMapData;
38: Result := ReadCoordData;
39: Result := ReadVertexdata;
40: Result := ReadPolygonData;
41: Result := ReadSymbolData;
42: Result := ReadLabelData;
43: Result := ReadBackdropData;
44: Result := ReadProfileData;
45: Result := ReadCurveData;
46: Result := ReadTemperatureData;
47: Result := ReadSnowpackData;
48: Result := ReadTreatmentData(S);
49: Result := ReadTagData;
50: Result := Ulid.ReadLidData(TokList, Ntoks);
51: Result := ReadLidUsageData;
52: Result := ReadGroundwaterFlowEqn(S);
53: Result := ReadAdjustmentData; //(5.1.007)
else Result := 0;
end;
end;

function ParseImportLine(Line: String): Integer;
//-----------------------------------------------------------------------------
// Processes line of input from imported scenario or map file.
// (Not currently used.)
//-----------------------------------------------------------------------------
begin
Result := 0;
end;

procedure StripComment(const Line: String; var S: String);
//-----------------------------------------------------------------------------
// Strips comment (text following a ';') from a line of input.
// Ignores comment if it begins with ';;'.
//-----------------------------------------------------------------------------
var
P: Integer;
N: Integer;
C: String;
begin
C := '';
S := Trim(Line);
P := Pos(';', S);
if P > 0 then
begin
N := Length(S);
C := Copy(S, P+1, N);
if (Length(C) >= 1) and (C[1] <> ';') then
begin
if Length(Comment) > 0 then Comment := Comment + #13;
Comment := Comment + C;
end;
Delete(S, P, N);
end;
end;

function FindNewSection(const S: String): Integer;
//-----------------------------------------------------------------------------
// Checks if S matches any of the section heading key words.
//-----------------------------------------------------------------------------
var
K: Integer;
begin
for K := 0 to High(SectionWords) do
begin
if Pos(SectionWords[K], S) = 1 then
begin
Result := K;
Exit;
end;
end;
Result := -1;
end;

function StartNewSection(S: String): Integer;
//-----------------------------------------------------------------------------
// Begins reading a new section of the input file.
//-----------------------------------------------------------------------------
var
K : Integer;

begin
// Determine which new section to begin
K := FindNewSection(UpperCase(S));
if (K >= 0) then
begin

//Update section code
Section := K;
PrevID := '';
Result := 0;
end
else Result := ErrMsg(KEYWORD_ERR, S);
Comment := '';
end;

function ReadFile(var F: Textfile; const Fsize: Int64):Boolean;
//-----------------------------------------------------------------------------
// Reads each line of a SWMM input file.
//-----------------------------------------------------------------------------
var
Err : Integer;
ByteCount : Integer;
StepCount : Integer;
StepSize : Integer;
S : String;
begin
Result := True;
ErrCount := 0;
LineCount := 0;
Comment := '';

// Initialize progress meter settings
StepCount := MainForm.ProgressBar.Max div MainForm.ProgressBar.Step;
StepSize := Fsize div StepCount;
if StepSize < 1000 then StepSize := 0;
ByteCount := 0;

// Read each line of input file
Reset(F);
while not Eof(F) do
begin
Err := 0;
Readln(F, Line);
Inc(LineCount);
if StepSize > 0 then
begin
Inc(ByteCount, Length(Line));
MainForm.UpdateProgressBar(ByteCount, StepSize);
end;

// Strip out trailing spaces, control characters & comment
Line := TrimRight(Line);
StripComment(Line, S);

// Check if line begins a new input section
if (Pos('[', S) = 1) then Err := StartNewSection(S)
else
begin

//// Following code section modified for release 5.1.011. //// //(5.1.011)
// Check if line contains project title/notes
if (Section = 0) and (Length(Line) > 0) then
begin
if LeftStr(Line,2) <> ';;' then Err := ReadTitleData(Line);
end

// Check if line contains a control rule clause
else if (Section = 22) then Err := ReadControlData(Line)

// Check if line contains an event start/end dates
else if (Section = 54) then Err := ReadEventData(Trim(Line))

// If in some section, then process the input line
else
begin
// Break line into string tokens and parse their contents
Uutils.Tokenize(S, TokList, Ntoks);
if (Ntoks > 0) and (Section >= 0) then
begin
Err := ParseInpLine(S);
Comment := '';
end

// No current section -- file was probably not an EPA-SWMM file
else if (Ntoks > 0) then
begin
Result := False;
Exit;
end;
end;
end;
////

// Increment error count
if Err > 0 then Inc(ErrCount);
end; //End of file.

if ErrCount > MAX_ERRORS then ErrList.Add(
IntToStr(ErrCount-MAX_ERRORS) + TXT_MORE_ERRORS);
end;

procedure DisplayInpErrForm(const Fname: String);
//-----------------------------------------------------------------------------
// Displays Status Report form that lists any error messages.
//-----------------------------------------------------------------------------
begin
SysUtils.DeleteFile((TempReportFile));
TempReportFile := Uutils.GetTempFile(TempDir,'swmm');
ErrList.Insert(0, TXT_ERROR_REPORT + Fname + #13);
ErrList.SaveToFile(TempReportFile);
MainForm.MnuReportStatusClick(MainForm);
end;

procedure ReverseVertexLists;
//-----------------------------------------------------------------------------
// Reverses list of vertex points for each link in the project.
//-----------------------------------------------------------------------------
var
I, J: Integer;
begin
for I := 0 to MAXCLASS do
begin
if not Project.IsLink(I) then continue;
for J := 0 to Project.Lists[I].Count-1 do
if Project.GetLink(I, J).Vlist <> nil then
Project.GetLink(I, J).Vlist.Reverse;
end;
end;

procedure SetSubcatchCentroids;
//-----------------------------------------------------------------------------
// Determines the centroid of each subcatchment polygon.
//-----------------------------------------------------------------------------
var
I : Integer;
begin
for I := 0 to Project.Lists[SUBCATCH].Count - 1 do
begin
Project.GetSubcatch(SUBCATCH, I).SetCentroid;
end;
end;

procedure SetIDPtrs;
//-----------------------------------------------------------------------------
// Makes pointers to ID strings the ID property of objects.
//-----------------------------------------------------------------------------
var
I, J : Integer;
C : TSubcatch;
S : String;

begin
for I := 0 to MAXCLASS do
begin
if I = RAINGAGE then with Project.Lists[RAINGAGE] do
begin
for J := 0 to Count-1 do TRaingage(Objects[J]).ID := PChar(Strings[J]);
end
else if Project.IsSubcatch(I) then with Project.Lists[SUBCATCH] do
begin
for J := 0 to Count-1 do
begin
C := TSubcatch(Objects[J]);
C.ID := PChar(Strings[J]);
S := Trim(C.Data[SUBCATCH_OUTLET_INDEX]);
C.OutSubcatch := FindSubcatch(S);
if C.OutSubcatch = nil then C.OutNode := FindNode(S);
end;
end
else if Project.IsNode(I) then with Project.Lists[I] do
begin
for J := 0 to Count-1 do TNode(Objects[J]).ID := PChar(Strings[J]);
end
else if Project.IsLink(I) then with Project.Lists[I] do
begin
for J := 0 to Count-1 do TLink(Objects[J]).ID := PChar(Strings[J]);
end
else if I = TRANSECT then with Project.Lists[I] do
begin
for J := 0 to Count-1 do
begin
TTransect(Objects[J]).CheckData;
TTransect(Objects[J]).SetMaxDepth;
Project.SetTransectConduitDepth(Strings[J],
TTransect(Objects[J]).Data[TRANSECT_MAX_DEPTH]);
end;
end
else continue;
end;
end;

function ReadInpFile(const Fname: String):Boolean;
//-----------------------------------------------------------------------------
// Reads SWMM input data from a text file.
//-----------------------------------------------------------------------------
var
F : Textfile;
begin
// Try to open the file
Result := False;
AssignFile(F,Fname);
{$I-}
Reset(F);
{$I+}
if (IOResult = 0) then
begin

// Create stringlists
Screen.Cursor := crHourGlass;
MapExtentSet := False;
ErrList := TStringList.Create;
TokList := TStringList.Create;
SubcatchList := TStringList.Create;
NodeList := TStringList.Create;
LinkList := TStringList.Create;
FileType := ftInput;
InpFile := Fname;
try

// Read the file
MainForm.ShowProgressBar(MSG_READING_PROJECT_DATA);
SubcatchList.Sorted := True;
NodeList.Sorted := True;
LinkList.Sorted := True;
Section := -1;
Result := ReadFile(F, Uutils.GetFileSize(Fname));
if (Result = True) then
begin
// Establish pointers to ID names
SetIDPtrs;
end;

finally
// Free the stringlists
SubcatchList.Free;
NodeList.Free;
LinkList.Free;
TokList.Free;
MainForm.PageSetupDialog.Header.Text := Project.Title;
MainForm.HideProgressBar;
Screen.Cursor := crDefault;

// Display errors if found & set map dimensions
if Result = True then
begin
if ErrList.Count > 0 then DisplayInpErrForm(Fname);
SetSubcatchCentroids;
SetMapDimensions;
end;
ErrList.Free;
end;
end;

// Close the input file
CloseFile(F);
end;

procedure ClearDefaultDates;
//-----------------------------------------------------------------------------
// Clears project's date/time settings.
//-----------------------------------------------------------------------------
begin
with Project.Options do
begin
Data[START_DATE_INDEX] := '';
Data[START_TIME_INDEX] := '';
Data[REPORT_START_DATE_INDEX] := '';
Data[REPORT_START_TIME_INDEX] := '';
Data[END_DATE_INDEX] := '';
Data[END_TIME_INDEX] := '';
end;
end;

procedure SetDefaultDates;
//-----------------------------------------------------------------------------
// Sets default values for project's date/time settings.
//-----------------------------------------------------------------------------
var
StartTime: TDateTime;
StartDate: TDateTime;
T: TDateTime;
D: TDateTime;
begin
with Project.Options do
begin

// Process starting date/time
try
StartDate := StrToDate(Data[START_DATE_INDEX], MyFormatSettings);
except
On EConvertError do StartDate := Date;
end;
StartTime := Uutils.StrHoursToTime(Data[START_TIME_INDEX]);
if StartTime < 0 then StartTime := 0;
D := StartDate + StartTime;
Data[START_DATE_INDEX] := DateToStr(D, MyFormatSettings);
Data[START_TIME_INDEX] := TimeToStr(D, MyFormatSettings);

// Process reporting start date/time
try
D := StrToDate(Data[REPORT_START_DATE_INDEX], MyFormatSettings);
except
On EConvertError do D := StartDate;
end;
T := Uutils.StrHoursToTime(Data[REPORT_START_TIME_INDEX]);
if T < 0 then T := StartTime;
D := D + T;
Data[REPORT_START_DATE_INDEX] := DateToStr(D, MyFormatSettings);
Data[REPORT_START_TIME_INDEX] := TimeToStr(D, MyFormatSettings);

// Process ending date/time
try
D := StrToDate(Data[END_DATE_INDEX], MyFormatSettings);
except
On EConvertError do D := StartDate;
end;
T := Uutils.StrHoursToTime(Data[END_TIME_INDEX]);
if T < 0 then T := StartTime;
D := D + T;
Data[END_DATE_INDEX] := DateToStr(D, MyFormatSettings);
Data[END_TIME_INDEX] := TimeToStr(D, MyFormatSettings);
end;
end;

function OpenProject(const Fname: String): TInputFileType;
//-----------------------------------------------------------------------------
// Reads in project data from a file.
//-----------------------------------------------------------------------------
begin
// Show progress meter
ClearDefaultDates;
Screen.Cursor := crHourGlass;
MainForm.ShowProgressBar(MSG_READING_PROJECT_DATA);

// Use default map dimensions and backdrop settings
MapForm.Map.Dimensions := DefMapDimensions;
MapForm.Map.Backdrop := DefMapBackdrop;

// Do the following for non-temporary input files
if not SameText(Fname, Uglobals.TempInputFile) then
begin

// Create a backup file
if AutoBackup
then CopyFile(PChar(Fname), PChar(ChangeFileExt(Fname, '.bak')), FALSE);

// Retrieve project defaults from .INI file
if CompareText(ExtractFileExt(Fname), '.ini') <> 0
then Uinifile.ReadProjIniFile(ChangeFileExt(Fname, '.ini'));
end;

// Read and parse each line of input file
Result := iftNone;
if ReadInpFile(Fname) then Result := iftINP;

// Finish processing the input data
if Result <> iftNone then
begin
SetDefaultDates; // set any missing analysis dates
Uglobals.RegisterCalibData; // register calibration data files
Uupdate.UpdateUnits; // update choice of unit system
Uupdate.UpdateDefOptions; // update default analysis options
Uupdate.UpdateLinkHints; // update hints used for offsets
Project.GetControlRuleNames; // store control rule names in a list
end;

// Hide progress meter.
MainForm.HideProgressBar;
Screen.Cursor := crDefault;
end;

end.le names in a list
end;

// Hide progress meter.
MainForm.HideProgressBar;
Screen.Cursor := crDefault;
end;

end.
if Result <> iftNone then
begin
SetDefaultDates; // set any missing analysis dates
Uglobals.RegisterCalibData; // register calibration data files
Uupdate.UpdateUnits; // update choice of unit system
Uupdate.UpdateDefOptions; // update default analysis options
Uupdate.UpdateLinkHints; // update hints used for offsets
Project.GetControlRuleNames; // store control rule names in a list
end;

// Hide progress meter.
MainForm.HideProgressBar;
Screen.Cursor := crDefault;
end;

end.

No comments:

SWMM456.COM

SWMM456.COM (previously known as SWMM5.NET) is a mini-blog that provides short and concise articles about various topics related to Stormwater Management Model (SWMM). Each post on the blog is no more than 150-200 words (about 1300 characters) in length and aims to deliver instant information, opinion, or introduction on a specific topic related to SWMM. The blog covers a wide range of topics, including tips and tricks for using SWMM, case studies, software updates, and news related to the field of stormwater management. The goal of the blog is to provide useful and relevant information to SWMM users and professionals in the stormwater management industry in a quick and easy-to-digest format.

Information

You can see recent Posts in the Recent Post Section, Top Labels, Older Alphabetical Labels and Dated Archives. You can also search for Tags in the Google Search Box or the Custom Search Box. The above Tabs in the Menu are those sites and blogs that I think can help you. Pleasse send any further questions to robert.dickinson@gmail.com or robert.dickinson@innovyze.com if you have further questions or ideas. If you are a student and you want a general introduction to SWMM 5 please visit Wikipedia or the EPA Tab. Thanks for visiting!

Best New Blog: http://blog.innovyze.com/2014/11/30/advanced-calibration-graphs-and-advanced-reference-graphical-comparisons-in-infoswmm-13/ The Current InfoSWMM Version is InfoSWMM v14 which is based on EPA SWMM 5.1.010 You can read about SWMM5 on Wikipedia and InfoSWMM vs SWMM 5 on this blog post. An advantage of updating to the newer version of Info/Map/SWMM/Sewer is a newly designed help file with many more FAQ’s and the User Guide as part of the help file. You can use the Google translate tool at the top of the right hand side to translate any and all blog posts.

Sunday, July 23, 2017

#SWMM5 - Delphi Pascal unit that imports a SWMM project's data from a formatted text file

No comments:

Today is day 356 or 97.5 percent of the year 2024