This component is an expandable connector that is used to implement a bus that contains the weather data.
This component reads TMY3 weather data (Wilcox and Marion, 2008) or user specified weather data.
The weather data format is the Typical Meteorological Year (TMY3)
as obtained from the EnergyPlus web site at
http://apps1.eere.energy.gov/buildings/energyplus/cfm/weather_data.cfm. These
data, which are in the EnergyPlus format, need to be converted as described
in the next paragraph.
By default, the data bus contains the wet bulb temperature.
This introduces a nonlinear equation.
However, we have not observed an increase in computing time because
of this equation.
To disable the computation of the wet bulb temperature, set
computeWetBulbTemperature=false.
This model has the option of using a constant value, using the data from the weather file,
or using data from an input connector for the following variables:
By default, all data are obtained from the weather data file,
except for the atmospheric pressure, which is set to the
parameter pAtm=101325 Pascals.
Because global, diffuse and direct radiation are related to each other, the parameter
HSou is treated differently.
It is set to a value of the enumeration
Buildings.BoundaryConditions.Types.RadiationDataSource,
and allows the following configurations:
The TMY3 weather data, as well as the EnergyPlus weather data, start at 1:00 AM
on January 1, and provide hourly data until midnight on December 31.
Thus, the first entry for temperatures, humidity, wind speed etc. are values
at 1:00 AM and not at midnight. Furthermore, the TMY3 weather data files can have
values at midnight of December 31 that may be significantly different from the values
at 1:00 AM on January 1.
Since annual simulations require weather data that start at 0:00 on January 1,
data need to be provided for this hour. Due to the possibly large change in
weatherdata between 1:00 AM on January 1 and midnight at December 31,
the weather data files in the Buildings library do not use the data entry from
midnight at December 31 as the value for t=0. Rather, the
value from 1:00 AM on January 1 is duplicated and used for 0:00 on January 1.
To maintain a data record with 8760 hours, the weather data record from
midnight at December 31 is deleted.
These changes in the weather data file are done in the Java program that converts
EnergyPlus weather data file to Modelica weather data files, and which is described
below.
To read weather data from the TMY3 weather data file, there are
two data readers in this model. One data reader obtains all data
except solar radiation, and the other data reader reads only the
solar radiation data, shifted by 30 minutes.
The reason for this time shift is as follows:
The TMY3 weather data file contains for solar radiation the
"...radiation received
on a horizontal surface during
the 60-minute period ending at
the timestamp."
Thus, as the figure below shows, a more accurate interpolation is obtained if
time is shifted by 30 minutes prior to reading the weather data.
block ReaderTMY3 
"Reader for TMY3 weather data"
  parameter Boolean computeWetBulbTemperature = true 
    "If true, then this model computes the wet bulb temperature";
  
//--------------------------------------------------------------
  // Atmospheric pressure
  parameter Buildings.BoundaryConditions.Types.DataSource pAtmSou=Buildings.BoundaryConditions.Types.DataSource.Parameter 
    "Atmospheric pressure";
  
parameter Modelica.SIunits.Pressure pAtm=101325 
    "Atmospheric pressure (used if pAtmSou=Parameter)";
  
Modelica.Blocks.Interfaces.RealInput pAtm_in(
    
final quantity="Pressure",
    
final unit="Pa",
    displayUnit="Pa") 
if (pAtmSou == Buildings.BoundaryConditions.Types.DataSource.Input) 
    "Input pressure";
  
//--------------------------------------------------------------
  // Ceiling height
  parameter Buildings.BoundaryConditions.Types.DataSource ceiHeiSou=Buildings.BoundaryConditions.Types.DataSource.File 
    "Ceiling height";
  
parameter Real ceiHei(
    
final quantity="Height",
    
final unit="m",
    displayUnit="m") = 20000 
"Ceiling height (used if ceiHei=Parameter)";
  
Modelica.Blocks.Interfaces.RealInput ceiHei_in(
    
final quantity="Height",
    
final unit="m",
    displayUnit="m") 
if (ceiHeiSou == Buildings.BoundaryConditions.Types.DataSource.Input) 
    "Input ceiling height";
  
//--------------------------------------------------------------
  // Total sky cover
  parameter Buildings.BoundaryConditions.Types.DataSource totSkyCovSou=Buildings.BoundaryConditions.Types.DataSource.File 
    "Total sky cover";
  
parameter Real totSkyCov(
    min=0,
    max=1,
    unit="1") = 0.5 
    "Total sky cover (used if totSkyCov=Parameter). Use 0 <= totSkyCov <= 1";
  
Modelica.Blocks.Interfaces.RealInput totSkyCov_in(
    min=0,
    max=1,
    unit="1") 
if (totSkyCovSou == Buildings.BoundaryConditions.Types.DataSource.Input) 
    "Input total sky cover";
  
// Opaque sky cover
  parameter Buildings.BoundaryConditions.Types.DataSource opaSkyCovSou=Buildings.BoundaryConditions.Types.DataSource.File 
    "Opaque sky cover";
  
parameter Real opaSkyCov(
    min=0,
    max=1,
    unit="1") = 0.5 
    "Opaque sky cover (used if opaSkyCov=Parameter). Use 0 <= opaSkyCov <= 1";
  
Modelica.Blocks.Interfaces.RealInput opaSkyCov_in(
    min=0,
    max=1,
    unit="1") 
if (opaSkyCovSou == Buildings.BoundaryConditions.Types.DataSource.Input) 
    "Input opaque sky cover";
  
//--------------------------------------------------------------
  // Dry bulb temperature
  parameter Buildings.BoundaryConditions.Types.DataSource TDryBulSou=Buildings.BoundaryConditions.Types.DataSource.File 
    "Dry bulb temperature";
  
parameter Modelica.SIunits.Temperature TDryBul(displayUnit="degC") = 293.15 
    "Dry bulb temperature (used if TDryBul=Parameter)";
  
Modelica.Blocks.Interfaces.RealInput TDryBul_in(
    
final quantity="ThermodynamicTemperature",
    
final unit="K",
    displayUnit="degC") 
if (TDryBulSou == Buildings.BoundaryConditions.Types.DataSource.Input) 
    "Input dry bulb temperature";
  
//--------------------------------------------------------------
  // Dew point temperature
  parameter Buildings.BoundaryConditions.Types.DataSource TDewPoiSou=Buildings.BoundaryConditions.Types.DataSource.File 
    "Dew point temperature";
  
parameter Modelica.SIunits.Temperature TDewPoi(displayUnit="degC") = 283.15 
    "Dew point temperature (used if TDewPoi=Parameter)";
  
Modelica.Blocks.Interfaces.RealInput TDewPoi_in(
    
final quantity="ThermodynamicTemperature",
    
final unit="K",
    displayUnit="degC") 
if (TDewPoiSou == Buildings.BoundaryConditions.Types.DataSource.Input) 
    "Input dew point temperature";
  
//--------------------------------------------------------------
  // Black body sky temperature
  parameter Buildings.BoundaryConditions.Types.DataSource TBlaSkySou=Buildings.BoundaryConditions.Types.DataSource.File 
    "Black-body sky temperature";
  
parameter Modelica.SIunits.Temperature TBlaSky=273.15 
    "Black-body sky temperature (used if TBlaSkySou=Parameter)";
  
Modelica.Blocks.Interfaces.RealInput TBlaSky_in(
    
final quantity="ThermodynamicTemperature",
    displayUnit="degC",
    
final unit="K") 
if 
    (TBlaSkySou == Buildings.BoundaryConditions.Types.DataSource.Input) 
    "Black-body sky temperature";
  
//--------------------------------------------------------------
  // Relative humidity
  parameter Buildings.BoundaryConditions.Types.DataSource relHumSou=Buildings.BoundaryConditions.Types.DataSource.File 
    "Relative humidity";
  
parameter Real relHum(
    min=0,
    max=1,
    unit="1") = 0.5 
"Relative humidity (used if relHum=Parameter)";
  
Modelica.Blocks.Interfaces.RealInput relHum_in(
    min=0,
    max=1,
    unit="1") 
if (relHumSou == Buildings.BoundaryConditions.Types.DataSource.Input) 
    "Input relative humidity";
  
//--------------------------------------------------------------
  // Wind speed
  parameter Buildings.BoundaryConditions.Types.DataSource winSpeSou=Buildings.BoundaryConditions.Types.DataSource.File 
    "Wind speed";
  
parameter Modelica.SIunits.Velocity winSpe(min=0) = 1 
    "Wind speed (used if winSpe=Parameter)";
  
Modelica.Blocks.Interfaces.RealInput winSpe_in(
    
final quantity="Velocity",
    
final unit="m/s",
    min=0) 
if (winSpeSou == Buildings.BoundaryConditions.Types.DataSource.Input) 
    "Input wind speed";
  
//--------------------------------------------------------------
  // Wind direction
  parameter Buildings.BoundaryConditions.Types.DataSource winDirSou=Buildings.BoundaryConditions.Types.DataSource.File 
    "Wind direction";
  
parameter Modelica.SIunits.Angle winDir=1.0 
    "Wind direction (used if winDir=Parameter)";
  
Modelica.Blocks.Interfaces.RealInput winDir_in(
    
final quantity="Angle",
    
final unit="rad",
    displayUnit="deg") 
if (winDirSou == Buildings.BoundaryConditions.Types.DataSource.Input) 
    "Input wind direction";
  
//--------------------------------------------------------------
  // Infrared horizontal radiation
  parameter Buildings.BoundaryConditions.Types.DataSource HInfHorSou=Buildings.BoundaryConditions.Types.DataSource.File 
    "Infrared horizontal radiation";
  
parameter Modelica.SIunits.HeatFlux HInfHor=0.0 
    "Infrared horizontal radiation (used if HInfHorSou=Parameter)";
  
Modelica.Blocks.Interfaces.RealInput HInfHor_in(
    
final quantity="RadiantEnergyFluenceRate",
    
final unit="W/m2") 
if (HInfHorSou == Buildings.BoundaryConditions.Types.DataSource.Input) 
    "Input infrared horizontal radiation";
   
parameter Buildings.BoundaryConditions.Types.RadiationDataSource HSou=Buildings.BoundaryConditions.Types.RadiationDataSource.File 
    "Global, diffuse, and direct normal radiation";
  
//--------------------------------------------------------------
  // Global horizontal radiation
  Modelica.Blocks.Interfaces.RealInput HGloHor_in(
    
final quantity="RadiantEnergyFluenceRate",
    
final unit="W/m2") 
if (HSou == Buildings.BoundaryConditions.Types.RadiationDataSource.Input_HGloHor_HDifHor
 or HSou == Buildings.BoundaryConditions.Types.RadiationDataSource.Input_HDirNor_HGloHor) 
    "Input global horizontal radiation";
  
//--------------------------------------------------------------
  // Diffuse horizontal radiation
  Modelica.Blocks.Interfaces.RealInput HDifHor_in(
    
final quantity="RadiantEnergyFluenceRate",
    
final unit="W/m2") 
if (HSou == Buildings.BoundaryConditions.Types.RadiationDataSource.Input_HGloHor_HDifHor
 or HSou == Buildings.BoundaryConditions.Types.RadiationDataSource.Input_HDirNor_HDifHor) 
    "Input diffuse horizontal radiation";
  
//--------------------------------------------------------------
  // Direct normal radiation
  Modelica.Blocks.Interfaces.RealInput HDirNor_in(
final quantity="RadiantEnergyFluenceRate",
      
final unit="W/m2") 
if 
                          (HSou == Buildings.BoundaryConditions.Types.RadiationDataSource.Input_HDirNor_HDifHor
 or HSou == Buildings.BoundaryConditions.Types.RadiationDataSource.Input_HDirNor_HGloHor) 
    "Input direct normal radiation";
  
//--------------------------------------------------------------
  parameter String filNam="" 
"Name of weather data file";
  
final parameter Modelica.SIunits.Angle lon(displayUnit="deg")=
    
Buildings.BoundaryConditions.WeatherData.BaseClasses.getLongitudeTMY3(
    filNam) 
"Longitude";
  
final parameter Modelica.SIunits.Angle lat(displayUnit="deg")=
    
Buildings.BoundaryConditions.WeatherData.BaseClasses.getLatitudeTMY3(
    filNam) 
"Latitude";
  
final parameter Modelica.SIunits.Time timZon(displayUnit="h")=
    
Buildings.BoundaryConditions.WeatherData.BaseClasses.getTimeZoneTMY3(filNam) 
    "Time zone";
  
Bus weaBus 
"Weather data bus";
  
parameter Buildings.BoundaryConditions.Types.SkyTemperatureCalculation
    calTSky=Buildings.BoundaryConditions.Types.SkyTemperatureCalculation.TemperaturesAndSkyCover 
    "Computation of black-body sky temperature";
  
constant Real epsCos = 1e-6 
"Small value to avoid division by 0";
protected 
  Modelica.Blocks.Tables.CombiTable1Ds datRea(
    
final tableOnFile=true,
    
final tableName="tab1",
    
final fileName=
Buildings.BoundaryConditions.WeatherData.BaseClasses.getAbsolutePath(filNam),
    
final smoothness=Modelica.Blocks.Types.Smoothness.ContinuousDerivative,
    
final columns={2,3,4,5,6,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,
        28,29,30}) 
"Data reader";
  
Buildings.BoundaryConditions.WeatherData.BaseClasses.CheckTemperature
    cheTemDryBul 
"Check dry bulb temperature ";
  
Buildings.BoundaryConditions.WeatherData.BaseClasses.CheckTemperature
    cheTemDewPoi 
"Check dew point temperature";
  
Buildings.BoundaryConditions.WeatherData.BaseClasses.ConvertRelativeHumidity
    conRelHum 
"Convert the relative humidity from percentage to [0, 1] ";
  
BaseClasses.CheckPressure chePre 
"Check the air pressure";
  
BaseClasses.CheckSkyCover cheTotSkyCov 
"Check the total sky cover";
  
BaseClasses.CheckSkyCover cheOpaSkyCov 
"Check the opaque sky cover";
  
BaseClasses.CheckRadiation cheGloHorRad 
    "Check the global horizontal radiation";
  
BaseClasses.CheckRadiation cheDifHorRad 
    "Check the diffuse horizontal radiation";
  
BaseClasses.CheckRadiation cheDirNorRad 
"Check the direct normal radiation";
  
BaseClasses.CheckCeilingHeight cheCeiHei 
"Check the ceiling height";
  
BaseClasses.CheckWindSpeed cheWinSpe 
"Check the wind speed";
  
BaseClasses.CheckRadiation cheHorRad 
"Check the horizontal radiation";
  
BaseClasses.CheckWindDirection cheWinDir 
"Check the wind direction";
  
SkyTemperature.BlackBody TBlaSkyCom(
final calTSky=calTSky) 
if 
       not (TBlaSkySou == Buildings.BoundaryConditions.Types.DataSource.Parameter
 or 
            TBlaSkySou == Buildings.BoundaryConditions.Types.DataSource.Input) 
    "Computation of the sky black-body temperature";
  
Utilities.Time.ModelTime modTim 
"Model time";
  
Modelica.Blocks.Math.Add add 
    "Add 30 minutes to time to shift weather data reader";
  
Modelica.Blocks.Sources.Constant con30mins(
final k=1800) 
    "Constant used to shift weather data reader";
  
Buildings.BoundaryConditions.WeatherData.BaseClasses.LocalCivilTime locTim(
      
final lon=lon, 
final timZon=timZon) 
"Local civil time";
  
Modelica.Blocks.Tables.CombiTable1Ds datRea1(
    
final tableOnFile=true,
    
final tableName="tab1",
    
final fileName=
Buildings.BoundaryConditions.WeatherData.BaseClasses.getAbsolutePath(filNam),
    
final smoothness=Modelica.Blocks.Types.Smoothness.ContinuousDerivative,
    
final columns=8:11) 
"Data reader";
  
Buildings.BoundaryConditions.WeatherData.BaseClasses.ConvertTime conTim1 
    "Convert simulation time to calendar time";
  
BaseClasses.ConvertTime conTim 
"Convert simulation time to calendar time";
  
BaseClasses.EquationOfTime eqnTim 
"Equation of time";
  
BaseClasses.SolarTime solTim 
"Solar time";
  
// Conditional connectors
  Modelica.Blocks.Interfaces.RealInput pAtm_in_internal(
    
final quantity="Pressure",
    
final unit="Pa",
    displayUnit="bar") 
"Needed to connect to conditional connector";
  
Modelica.Blocks.Interfaces.RealInput ceiHei_in_internal(
    
final quantity="Height",
    
final unit="m",
    displayUnit="m") 
"Needed to connect to conditional connector";
  
Modelica.Blocks.Interfaces.RealInput totSkyCov_in_internal(
    
final quantity="1",
    min=0,
    max=1) 
"Needed to connect to conditional connector";
  
Modelica.Blocks.Interfaces.RealInput opaSkyCov_in_internal(
    
final quantity="1",
    min=0,
    max=1) 
"Needed to connect to conditional connector";
  
Modelica.Blocks.Interfaces.RealInput TDryBul_in_internal(
    
final quantity="ThermodynamicTemperature",
    
final unit="K",
    displayUnit="degC") 
"Needed to connect to conditional connector";
  
Modelica.Blocks.Interfaces.RealInput TDewPoi_in_internal(
    
final quantity="ThermodynamicTemperature",
    
final unit="K",
    displayUnit="degC") 
"Needed to connect to conditional connector";
  
Modelica.Blocks.Interfaces.RealInput TBlaSky_in_internal(
    
final quantity="ThermodynamicTemperature",
    
final unit="K",
    displayUnit="degC") 
"Needed to connect to conditional connector";
  
Modelica.Blocks.Interfaces.RealInput relHum_in_internal(
    
final quantity="1",
    min=0,
    max=1) 
"Needed to connect to conditional connector";
  
Modelica.Blocks.Interfaces.RealInput winSpe_in_internal(
    
final quantity="Velocity",
    
final unit="m/s") 
"Needed to connect to conditional connector";
  
Modelica.Blocks.Interfaces.RealInput winDir_in_internal(
    
final quantity="Angle",
    
final unit="rad",
    displayUnit="deg") 
"Needed to connect to conditional connector";
  
Modelica.Blocks.Interfaces.RealInput HGloHor_in_internal(
    
final quantity="RadiantEnergyFluenceRate",
    
final unit="W/m2") 
"Needed to connect to conditional connector";
  
Modelica.Blocks.Interfaces.RealInput HDifHor_in_internal(
    
final quantity="RadiantEnergyFluenceRate",
    
final unit="W/m2") 
"Needed to connect to conditional connector";
  
Modelica.Blocks.Interfaces.RealInput HDirNor_in_internal(
    
final quantity="RadiantEnergyFluenceRate",
    
final unit="W/m2") 
"Needed to connect to conditional connector";
  
Modelica.Blocks.Interfaces.RealInput HInfHor_in_internal(
    
final quantity="RadiantEnergyFluenceRate",
    
final unit="W/m2") 
"Needed to connect to conditional connector";
  
Modelica.Blocks.Math.UnitConversions.From_deg conWinDir 
    "Convert the wind direction unit from [deg] to [rad]";
  
Modelica.Blocks.Math.UnitConversions.From_degC conTDryBul;
  
BaseClasses.ConvertRadiation conHorRad;
  
Modelica.Blocks.Math.UnitConversions.From_degC conTDewPoi 
    "Convert the dew point temperature form [degC] to [K]";
  
BaseClasses.ConvertRadiation conDirNorRad;
  
BaseClasses.ConvertRadiation conGloHorRad;
  
BaseClasses.ConvertRadiation conDifHorRad;
  
BaseClasses.CheckRelativeHumidity cheRelHum;
  
SolarGeometry.BaseClasses.AltitudeAngle altAng 
"Solar altitude angle";
   
SolarGeometry.BaseClasses.ZenithAngle zenAng(
     
final lat = lat) 
"Zenith angle";
   
SolarGeometry.BaseClasses.Declination decAng 
"Declination angle";
   
SolarGeometry.BaseClasses.SolarHourAngle
    solHouAng;
  
Modelica.Blocks.Sources.Constant latitude(
final k=lat) 
"Latitude";
  
Modelica.Blocks.Sources.Constant longitude(
final k=lon) 
"Longitude";
  
//---------------------------------------------------------------------------
  // Optional instanciation of a block that computes the wet bulb temperature.
  // This block may be needed for evaporative cooling towers.
  // By default, it is enabled. This introduces a nonlinear equation, but
  // we have not observed an increase in computing time because of this equation.
  Buildings.Utilities.Psychrometrics.TWetBul_TDryBulPhi tWetBul_TDryBulXi(
      
redeclare package Medium = 
Buildings.Media.Air,
      TDryBul(displayUnit="degC")) 
if computeWetBulbTemperature;
  
//---------------------------------------------------------------------------
  // Conversion blocks for sky cover
  Modelica.Blocks.Math.Gain conTotSkyCov(
final k=0.1) 
if 
       totSkyCovSou == Buildings.BoundaryConditions.Types.DataSource.File 
    "Convert sky cover from [0...10] to [0...1]";
  
Modelica.Blocks.Math.Gain conOpaSkyCov(
final k=0.1) 
if 
       opaSkyCovSou == Buildings.BoundaryConditions.Types.DataSource.File 
    "Convert sky cover from [0...10] to [0...1]";
equation 
  //---------------------------------------------------------------------------
  // Select atmospheric pressure connector
  if pAtmSou == Buildings.BoundaryConditions.Types.DataSource.Parameter
 then
    pAtm_in_internal = pAtm;
  
elseif pAtmSou == Buildings.BoundaryConditions.Types.DataSource.File
 then
    connect(datRea.y[4], pAtm_in_internal);
  
else
    connect(pAtm_in, pAtm_in_internal);
  
end if;
  
connect(pAtm_in_internal, chePre.PIn);
  
//---------------------------------------------------------------------------
  // Select ceiling height connector
  if ceiHeiSou == Buildings.BoundaryConditions.Types.DataSource.Parameter
 then
    ceiHei_in_internal = ceiHei;
  
elseif ceiHeiSou == Buildings.BoundaryConditions.Types.DataSource.Input
 then
    connect(ceiHei_in, ceiHei_in_internal);
  
else
    connect(datRea.y[16], ceiHei_in_internal);
  
end if;
  
 connect(ceiHei_in_internal, cheCeiHei.ceiHeiIn);
  
//---------------------------------------------------------------------------
  // Select total sky cover connector
  if totSkyCovSou == Buildings.BoundaryConditions.Types.DataSource.Parameter
 then
    totSkyCov_in_internal = totSkyCov;
  
elseif totSkyCovSou == Buildings.BoundaryConditions.Types.DataSource.Input
 then
    connect(totSkyCov_in, totSkyCov_in_internal);
  
else
    connect(conTotSkyCov.u, datRea.y[13]);
    
connect(conTotSkyCov.y, totSkyCov_in_internal);
  
end if;
  
connect(totSkyCov_in_internal, cheTotSkyCov.nIn);
  
//---------------------------------------------------------------------------
  // Select opaque sky cover connector
  if opaSkyCovSou == Buildings.BoundaryConditions.Types.DataSource.Parameter
 then
    opaSkyCov_in_internal = opaSkyCov;
  
elseif opaSkyCovSou == Buildings.BoundaryConditions.Types.DataSource.Input
 then
    connect(opaSkyCov_in, opaSkyCov_in_internal);
  
else
    connect(conOpaSkyCov.u, datRea.y[14]);
    
connect(conOpaSkyCov.y, opaSkyCov_in_internal);
  
end if;
  
connect(opaSkyCov_in_internal, cheOpaSkyCov.nIn);
  
//---------------------------------------------------------------------------
  // Select dew point temperature connector
  if TDewPoiSou == Buildings.BoundaryConditions.Types.DataSource.Parameter
 then
    TDewPoi_in_internal = TDewPoi;
  
elseif TDewPoiSou == Buildings.BoundaryConditions.Types.DataSource.Input
 then
    connect(TDewPoi_in, TDewPoi_in_internal);
  
else
    connect(conTDewPoi.y, TDewPoi_in_internal);
  
end if;
  
connect(TDewPoi_in_internal, cheTemDewPoi.TIn);
  
//---------------------------------------------------------------------------
  // Select dry bulb temperature connector
  if TDryBulSou == Buildings.BoundaryConditions.Types.DataSource.Parameter
 then
    TDryBul_in_internal = TDryBul;
  
elseif TDryBulSou == Buildings.BoundaryConditions.Types.DataSource.Input
 then
    connect(TDryBul_in, TDryBul_in_internal);
  
else
    connect(conTDryBul.y, TDryBul_in_internal);
  
end if;
  
connect(TDryBul_in_internal, cheTemDryBul.TIn);
  
//---------------------------------------------------------------------------
  // Select sky black body temperature connector
  if TBlaSkySou == Buildings.BoundaryConditions.Types.DataSource.Parameter
 then
    TBlaSky_in_internal = TBlaSky;
  
elseif TBlaSkySou == Buildings.BoundaryConditions.Types.DataSource.Input
 then
    connect(TBlaSky_in, TBlaSky_in_internal);
  
else
    connect(TBlaSkyCom.TBlaSky, TBlaSky_in_internal);
  
end if;
  
connect(TBlaSky_in_internal, weaBus.TBlaSky);
  
//---------------------------------------------------------------------------
  // Select relative humidity connector
  if relHumSou == Buildings.BoundaryConditions.Types.DataSource.Parameter
 then
    relHum_in_internal = relHum;
  
elseif relHumSou == Buildings.BoundaryConditions.Types.DataSource.Input
 then
    connect(relHum_in, relHum_in_internal);
  
else
    connect(conRelHum.relHumOut, relHum_in_internal);
  
end if;
  
connect(relHum_in_internal, cheRelHum.relHumIn);
  
//---------------------------------------------------------------------------
  // Select wind speed connector
  if winSpeSou == Buildings.BoundaryConditions.Types.DataSource.Parameter
 then
    winSpe_in_internal = winSpe;
  
elseif winSpeSou == Buildings.BoundaryConditions.Types.DataSource.Input
 then
    connect(winSpe_in, winSpe_in_internal);
  
else
    connect(datRea.y[12], winSpe_in_internal);
  
end if;
  
connect(winSpe_in_internal, cheWinSpe.winSpeIn);
  
//---------------------------------------------------------------------------
  // Select wind direction connector
  if winDirSou == Buildings.BoundaryConditions.Types.DataSource.Parameter
 then
    winDir_in_internal = winDir;
  
elseif winDirSou == Buildings.BoundaryConditions.Types.DataSource.Input
 then
    connect(winDir_in, winDir_in_internal);
  
else
    connect(conWinDir.y, winDir_in_internal);
  
end if;
  
connect(winDir_in_internal, cheWinDir.nIn);
  
//---------------------------------------------------------------------------
  // Select global horizontal radiation connector
  if HSou ==  Buildings.BoundaryConditions.Types.RadiationDataSource.Input_HGloHor_HDifHor
 or HSou == Buildings.BoundaryConditions.Types.RadiationDataSource.Input_HDirNor_HGloHor
 then
    connect(HGloHor_in, HGloHor_in_internal) 
      "Get HGloHor using user input file";
  
elseif HSou == Buildings.BoundaryConditions.Types.RadiationDataSource.Input_HDirNor_HDifHor
 then
     HDirNor_in_internal*
cos(zenAng.zen)+HDifHor_in_internal = HGloHor_in_internal 
      "Calculate the HGloHor using HDirNor and HDifHor according to (A.4.14) and (A.4.15)";
  
else
    connect(conGloHorRad.HOut, HGloHor_in_internal) 
      "Get HGloHor using weather data file";
  
end if;
  
connect(HGloHor_in_internal, cheGloHorRad.HIn);
  
//---------------------------------------------------------------------------
  // Select diffuse horizontal radiation connector
  if HSou == Buildings.BoundaryConditions.Types.RadiationDataSource.Input_HGloHor_HDifHor
 or HSou == Buildings.BoundaryConditions.Types.RadiationDataSource.Input_HDirNor_HDifHor
 then
     connect(HDifHor_in, HDifHor_in_internal) 
      "Get HDifHor using user input file";
  
elseif  HSou == Buildings.BoundaryConditions.Types.RadiationDataSource.Input_HDirNor_HGloHor
 then
      HGloHor_in_internal - HDirNor_in_internal*
cos(zenAng.zen) = HDifHor_in_internal 
      "Calculate the HGloHor using HDirNor and HDifHor according to (A.4.14) and (A.4.15)";
  
else
    connect(conDifHorRad.HOut, HDifHor_in_internal) 
      "Get HDifHor using weather data file";
  
end if;
  
connect(HDifHor_in_internal, cheDifHorRad.HIn);
  
//---------------------------------------------------------------------------
  // Select direct normal radiation connector
  if HSou == Buildings.BoundaryConditions.Types.RadiationDataSource.Input_HDirNor_HGloHor
 or HSou == Buildings.BoundaryConditions.Types.RadiationDataSource.Input_HDirNor_HDifHor
 then
     connect(HDirNor_in, HDirNor_in_internal) 
      "Get HDirNor using user input file";
  
elseif  HSou == Buildings.BoundaryConditions.Types.RadiationDataSource.Input_HGloHor_HDifHor
 then
      (HGloHor_in_internal -HDifHor_in_internal)/
Buildings.Utilities.Math.Functions.smoothMax(x1=
cos(zenAng.zen), x2=epsCos, deltaX=0.1*epsCos)
       = HDirNor_in_internal 
      "Calculate the HDirNor using HGloHor and HDifHor according to (A.4.14) and (A.4.15)";
  
else
    connect(conDirNorRad.HOut, HDirNor_in_internal) 
      "Get HDirNor using weather data file";
  
end if;
  
connect(HDirNor_in_internal, cheDirNorRad.HIn);
  
//---------------------------------------------------------------------------
  // Select infrared radiation connector
  if HInfHorSou == Buildings.BoundaryConditions.Types.DataSource.Parameter
 then
    HInfHor_in_internal = HInfHor;
  
elseif HInfHorSou == Buildings.BoundaryConditions.Types.DataSource.Input
 then
    connect(HInfHor_in, HInfHor_in_internal);
  
else
    connect(conHorRad.HOut, HInfHor_in_internal);
  
end if;
  
connect(HInfHor_in_internal, cheHorRad.HIn);
  
connect(chePre.POut, weaBus.pAtm);
  
connect(cheTotSkyCov.nOut, weaBus.nTot);
  
connect(cheOpaSkyCov.nOut, weaBus.nOpa);
  
connect(cheGloHorRad.HOut, weaBus.HGloHor);
  
connect(cheDifHorRad.HOut, weaBus.HDifHor);
  
connect(cheDirNorRad.HOut, weaBus.HDirNor);
  
connect(cheCeiHei.ceiHeiOut, weaBus.celHei);
  
connect(cheWinSpe.winSpeOut, weaBus.winSpe);
  
connect(cheHorRad.HOut, weaBus.radHorIR);
  
connect(cheWinDir.nOut, weaBus.winDir);
  
connect(cheOpaSkyCov.nOut,TBlaSkyCom. nOpa);
  
connect(cheHorRad.HOut,TBlaSkyCom. radHorIR);
  
connect(TBlaSkyCom.TBlaSky, weaBus.TBlaSky);
  
connect(modTim.y, weaBus.cloTim);
  
connect(modTim.y, add.u2);
  
connect(con30mins.y, add.u1);
  
connect(add.y, conTim1.modTim);
  
connect(conTim1.calTim, datRea1.u);
  
connect(modTim.y, locTim.cloTim);
  
connect(modTim.y, conTim.modTim);
  
connect(conTim.calTim, datRea.u);
  
connect(modTim.y, eqnTim.nDay);
  
connect(eqnTim.eqnTim, solTim.equTim);
  
connect(locTim.locTim, solTim.locTim);
  
connect(solTim.solTim, weaBus.solTim);
  
connect(datRea.y[11], conWinDir.u);
  
connect(datRea1.y[1], conHorRad.HIn);
  
connect(cheTemDryBul.TOut,TBlaSkyCom. TDryBul);
  
connect(datRea.y[1], conTDryBul.u);
  
connect(datRea.y[2], conTDewPoi.u);
  
connect(cheTemDewPoi.TOut, weaBus.TDewPoi);
  
connect(TBlaSkyCom.TDewPoi, cheTemDewPoi.TOut);
  
connect(datRea1.y[3], conDirNorRad.HIn);
  
connect(datRea1.y[2], conGloHorRad.HIn);
  
connect(datRea1.y[4], conDifHorRad.HIn);
  
connect(conRelHum.relHumIn, datRea.y[3]);
  
connect(cheRelHum.relHumOut, weaBus.relHum);
  
connect(cheTemDryBul.TOut, weaBus.TDryBul);
  
connect(decAng.decAng, zenAng.decAng);
  
connect(solHouAng.solHouAng, zenAng.solHouAng);
  
connect(solHouAng.solTim, solTim.solTim);
  
connect(decAng.nDay, modTim.y);
  
connect(zenAng.zen, altAng.zen);
  
// Connectors for wet bulb temperature.
  // These are removed if computeWetBulbTemperature = false
  connect(chePre.POut, tWetBul_TDryBulXi.p);
  
connect(tWetBul_TDryBulXi.TWetBul, weaBus.TWetBul);
  
connect(cheTemDryBul.TOut, tWetBul_TDryBulXi.TDryBul);
  
connect(cheRelHum.relHumOut, tWetBul_TDryBulXi.phi);
  
connect(altAng.alt, weaBus.solAlt);
  
connect(zenAng.zen, weaBus.solZen);
  
connect(decAng.decAng, weaBus.solDec);
  
connect(solHouAng.solHouAng, weaBus.solHouAng);
  
connect(longitude.y, weaBus.lon);
  
connect(latitude.y, weaBus.lat);
end ReaderTMY3;