public static List <Guid> AddDesignDays(this TBD.Building building, IEnumerable <DesignDay> coolingDesignDays, IEnumerable <DesignDay> heatingDesignDays, int repetitions = 30)
{
if (building == null)
{
return(null);
}
building.ClearDesignDays();
List <TBD.dayType> dayTypes = building.DayTypes();
List <Guid> result = new List <Guid>();
if (coolingDesignDays != null && coolingDesignDays.Count() != 0)
{
TBD.dayType dayType = dayTypes?.Find(x => x.name == "CDD");
List <TBD.CoolingDesignDay> coolingDesignDays_TBD = building.CoolingDesignDays();
foreach (DesignDay designDay in coolingDesignDays)
{
if (designDay == null)
{
continue;
}
TBD.CoolingDesignDay coolingDesignDay_TBD = coolingDesignDays_TBD?.Find(x => x.name == designDay.Name);
if (coolingDesignDay_TBD == null)
{
coolingDesignDay_TBD = building.AddCoolingDesignDay();
}
coolingDesignDay_TBD.Update(designDay, dayType, repetitions);
result.Add(Guid.Parse(coolingDesignDay_TBD.GUID));
}
}
if (heatingDesignDays != null && heatingDesignDays.Count() != 0)
{
TBD.dayType dayType = dayTypes?.Find(x => x.name == "HDD");
List <TBD.HeatingDesignDay> heatingDesignDays_TBD = building.HeatingDesignDays();
foreach (DesignDay designDay in heatingDesignDays)
{
if (designDay == null)
{
continue;
}
TBD.HeatingDesignDay heatingDesignDay_TBD = heatingDesignDays_TBD?.Find(x => x.name == designDay.Name);
if (heatingDesignDay_TBD == null)
{
heatingDesignDay_TBD = building.AddHeatingDesignDay();
}
heatingDesignDay_TBD.Update(designDay, dayType, repetitions);
result.Add(Guid.Parse(heatingDesignDay_TBD.GUID));
}
}
return(result);
}
public static TBD.dayType DayType(this TBD.TBDDocument tBDDocument, string name)
{
if (string.IsNullOrEmpty(name))
{
return(null);
}
TBD.Calendar calendar = tBDDocument?.Building?.GetCalendar();
if (calendar == null)
{
return(null);
}
int index = 1;
TBD.dayType dayType = calendar.dayTypes(index);
while (dayType != null)
{
if (dayType.name.Equals(name))
{
return(dayType);
}
index++;
dayType = calendar.dayTypes(index);
}
return(null);
}
private static TBD.dayType[] GetDayTypeArray(TBD.TBDDocument tbdDocument)
{
TBD.dayType[] aDayTypeArray = new TBD.dayType[365];
TBD.Calendar aCalendar = tbdDocument.Building.GetCalendar();
for (int i = 0; i < 365; i++)
{
aDayTypeArray[i] = aCalendar.days(i + 1).dayType;
}
return(aDayTypeArray);
}
public static BHE.SimulationDayType FromTAS(this TBD.dayType tbdDayType)
{
if (tbdDayType.name.Equals("Weekday"))
{
return(BHE.SimulationDayType.Weekday);
}
if (tbdDayType.name.Equals("Monday"))
{
return(BHE.SimulationDayType.Monday);
}
if (tbdDayType.name.Equals("Tuesday"))
{
return(BHE.SimulationDayType.Tuesday);
}
if (tbdDayType.name.Equals("Wednesday"))
{
return(BHE.SimulationDayType.Wednesday);
}
if (tbdDayType.name.Equals("Thursday"))
{
return(BHE.SimulationDayType.Thursday);
}
if (tbdDayType.name.Equals("Friday"))
{
return(BHE.SimulationDayType.Friday);
}
if (tbdDayType.name.Equals("Saturday"))
{
return(BHE.SimulationDayType.Saturday);
}
if (tbdDayType.name.Equals("Sunday"))
{
return(BHE.SimulationDayType.Sunday);
}
if (tbdDayType.name.Equals("Public Holiday"))
{
return(BHE.SimulationDayType.PublicHoliday);
}
if (tbdDayType.name.Equals("CDD"))
{
return(BHE.SimulationDayType.CoolingDesignDay);
}
if (tbdDayType.name.Equals("HDD"))
{
return(BHE.SimulationDayType.HeatingDesignDay);
}
if (tbdDayType.name.Equals("Weekend"))
{
return(BHE.SimulationDayType.Weekend);
}
return(BHE.SimulationDayType.Undefined);
}
/// <summary>
/// Gets TAS Internal Condition Day Types
/// </summary>
/// <param name="InternalCondition">TAS Internal Condition</param>
/// <returns name="DayTypes">Day Type List</returns>
/// <search>
/// TAS, InternalCondition, DayTypes, Day Types
/// </search>
public static List <DayType> DayTypes(InternalCondition InternalCondition)
{
List <DayType> aDayTypeList = new List <DayType>();
int aIndex = 1;
TBD.dayType aDayType = InternalCondition.pInternalCondition.GetDayType(aIndex);
while (aDayType != null)
{
aDayTypeList.Add(new DayType(aDayType));
aIndex++;
aDayType = InternalCondition.pInternalCondition.GetDayType(aIndex);
}
return(aDayTypeList);
}
/// <summary>
/// Gets all TAS TBD Substitute Element Day Types
/// </summary>
/// <param name="SubstituteElement">Substitute Element</param>
/// <returns name="DayTypes">Day Type List</returns>
/// <search>
/// TAS, TBD, SubstituteElement, Substitute Element, DayTypes, GetDayTypes, Day Types
/// </search>
public static List <DayType> DayTypes(SubstituteElement SubstituteElement)
{
List <DayType> aDayTypeList = new List <DayType>();
int aIndex = 0;
TBD.dayType aDayType = SubstituteElement.pSubstituteElement.GetDayType(aIndex);
while (aDayType != null)
{
aDayTypeList.Add(new DayType(aDayType));
aIndex++;
aDayType = SubstituteElement.pSubstituteElement.GetDayType(aIndex);
}
return(aDayTypeList);
}
private static bool HasDayType(TBD.InternalCondition internalCondition, TBD.dayType dayType)
{
int aIndex = 0;
TBD.dayType aDayType = internalCondition.GetDayType(aIndex);
while (aDayType != null)
{
if (aDayType.name == dayType.name)
{
return(true);
}
aIndex++;
aDayType = internalCondition.GetDayType(aIndex);
}
return(false);
}
public static List <TBD.dayType> DayTypes(this TBD.InternalCondition internalCondition)
{
if (internalCondition == null)
{
return(null);
}
List <TBD.dayType> result = new List <TBD.dayType>();
TBD.dayType dayType = internalCondition.GetDayType(result.Count);
while (dayType != null)
{
result.Add(dayType);
dayType = internalCondition.GetDayType(result.Count);
}
return(result);
}
public static List <TBD.dayType> DayTypes(this TBD.Calendar calendar)
{
if (calendar == null)
{
return(null);
}
List <TBD.dayType> result = new List <TBD.dayType>();
for (int i = 1; i <= calendar.GetDayTypeCount(); i++)
{
TBD.dayType dayType = calendar.dayTypes(i);
if (dayType != null)
{
result.Add(dayType);
}
}
return(result);
}
private static TBD.InternalCondition GetInternalCondition(TBD.zone zone, TBD.dayType dayType)
{
if (zone == null)
{
return(null);
}
int aIndex = 0;
TBD.InternalCondition aInternalCondition = zone.GetIC(aIndex);
while (aInternalCondition != null)
{
if (HasDayType(aInternalCondition, dayType))
{
return(aInternalCondition);
}
aIndex++;
aInternalCondition = zone.GetIC(aIndex);
}
return(null);;
}
public static TBD.InternalCondition InternalCondition(this TBD.zone zone, TBD.dayType dayType)
{
if (zone == null)
{
return(null);
}
int index = 0;
TBD.InternalCondition internalCondition = zone.GetIC(index);
while (internalCondition != null)
{
if (HasDayType(internalCondition, dayType))
{
return(internalCondition);
}
index++;
internalCondition = zone.GetIC(index);
}
return(null);
}
public static AnalyticalModel RunWorkflow(this AnalyticalModel analyticalModel, string path_TBD, string path_gbXML = null, Weather.WeatherData weatherData = null, List <DesignDay> heatingDesignDays = null, List <DesignDay> coolingDesignDays = null, List <SurfaceOutputSpec> surfaceOutputSpecs = null, bool unmetHours = true)
{
if (analyticalModel == null || string.IsNullOrWhiteSpace(path_TBD))
{
return(null);
}
string directory = System.IO.Path.GetDirectoryName(path_TBD);
string fileName = System.IO.Path.GetFileNameWithoutExtension(path_TBD);
string path_TSD = System.IO.Path.Combine(directory, string.Format("{0}.{1}", fileName, "tsd"));
if (!string.IsNullOrWhiteSpace(path_gbXML))
{
string path_T3D = System.IO.Path.Combine(directory, string.Format("{0}.{1}", fileName, "t3d"));
string guid = null;
using (SAMT3DDocument sAMT3DDocument = new SAMT3DDocument(path_T3D))
{
TAS3D.T3DDocument t3DDocument = sAMT3DDocument.T3DDocument;
guid = t3DDocument.Building.GUID;
sAMT3DDocument.Save();
}
float latitude = float.NaN;
float longitude = float.NaN;
float timeZone = float.NaN;
using (SAMTBDDocument sAMTBDDocument = new SAMTBDDocument(path_TBD))
{
TBD.TBDDocument tBDDocument = sAMTBDDocument.TBDDocument;
if (weatherData != null)
{
Weather.Tas.Modify.UpdateWeatherData(tBDDocument, weatherData);
}
if (!string.IsNullOrWhiteSpace(guid))
{
tBDDocument.Building.GUID = guid;
}
TBD.Calendar calendar = tBDDocument.Building.GetCalendar();
List <TBD.dayType> dayTypes = Query.DayTypes(calendar);
if (dayTypes.Find(x => x.name == "HDD") == null)
{
TBD.dayType dayType = calendar.AddDayType();
dayType.name = "HDD";
}
if (dayTypes.Find(x => x.name == "CDD") == null)
{
TBD.dayType dayType = calendar.AddDayType();
dayType.name = "CDD";
}
latitude = tBDDocument.Building.latitude;
longitude = tBDDocument.Building.longitude;
timeZone = tBDDocument.Building.timeZone;
sAMTBDDocument.Save();
}
using (SAMT3DDocument sAMT3DDocument = new SAMT3DDocument(path_T3D))
{
TAS3D.T3DDocument t3DDocument = sAMT3DDocument.T3DDocument;
t3DDocument.TogbXML(path_gbXML, true, true, true);
t3DDocument.SetUseBEWidths(false);
analyticalModel = Query.UpdateT3D(analyticalModel, t3DDocument);
t3DDocument.Building.latitude = float.IsNaN(latitude) ? t3DDocument.Building.latitude : latitude;
t3DDocument.Building.longitude = float.IsNaN(longitude) ? t3DDocument.Building.longitude : longitude;
t3DDocument.Building.timeZone = float.IsNaN(timeZone) ? t3DDocument.Building.timeZone : timeZone;
sAMT3DDocument.Save();
Convert.ToTBD(t3DDocument, path_TBD, 1, 365, 15, true);
}
}
AdjacencyCluster adjacencyCluster = null;
bool hasWeatherData = false;
using (SAMTBDDocument sAMTBDDocument = new SAMTBDDocument(path_TBD))
{
TBD.TBDDocument tBDDocument = sAMTBDDocument.TBDDocument;
hasWeatherData = tBDDocument?.Building.GetWeatherYear() != null;
analyticalModel = Query.UpdateFacingExternal(analyticalModel, tBDDocument);
AssignAdiabaticConstruction(tBDDocument, "Adiabatic", new string[] { "-unzoned", "-internal", "-exposed" }, false, true);
UpdateBuildingElements(tBDDocument, analyticalModel);
adjacencyCluster = analyticalModel.AdjacencyCluster;
UpdateThermalParameters(adjacencyCluster, tBDDocument.Building);
analyticalModel = new AnalyticalModel(analyticalModel, adjacencyCluster);
UpdateZones(tBDDocument.Building, analyticalModel, true);
if (coolingDesignDays != null || heatingDesignDays != null)
{
AddDesignDays(tBDDocument, coolingDesignDays, heatingDesignDays, 30);
}
sAMTBDDocument.Save();
}
if (!hasWeatherData)
{
return(new AnalyticalModel(analyticalModel, adjacencyCluster));
}
Query.Sizing(path_TBD, analyticalModel, false, true);
using (SAMTBDDocument sAMTBDDocument = new SAMTBDDocument(path_TBD))
{
TBD.TBDDocument tBDDocument = sAMTBDDocument.TBDDocument;
if (surfaceOutputSpecs != null && surfaceOutputSpecs.Count > 0)
{
Core.Tas.Modify.UpdateSurfaceOutputSpecs(tBDDocument, surfaceOutputSpecs);
Core.Tas.Modify.AssignSurfaceOutputSpecs(tBDDocument, surfaceOutputSpecs[0].Name);
sAMTBDDocument.Save();
}
Simulate(tBDDocument, path_TSD, 1, 1);
}
adjacencyCluster = analyticalModel.AdjacencyCluster;
List <Core.Result> results = AddResults(path_TSD, adjacencyCluster);
if (unmetHours)
{
List <Core.Result> results_UnmetHours = Query.UnmetHours(path_TSD, path_TBD, 0.5);
if (results_UnmetHours != null && results_UnmetHours.Count > 0)
{
foreach (Core.Result result in results_UnmetHours)
{
if (result is AdjacencyClusterSimulationResult)
{
adjacencyCluster.AddObject(result);
}
else if (result is SpaceSimulationResult)
{
SpaceSimulationResult spaceSimulationResult = (SpaceSimulationResult)result;
List <SpaceSimulationResult> spaceSimulationResults = Query.Results(results, spaceSimulationResult);
if (spaceSimulationResults == null)
{
results.Add(spaceSimulationResult);
}
else
{
spaceSimulationResults.ForEach(x => Core.Modify.Copy(spaceSimulationResult, x, Analytical.SpaceSimulationResultParameter.UnmetHourFirstIndex, Analytical.SpaceSimulationResultParameter.UnmetHours, Analytical.SpaceSimulationResultParameter.OccupiedUnmetHours));
}
}
}
}
}
AnalyticalModel analyticalModel_Temp = new AnalyticalModel(analyticalModel, adjacencyCluster);
//if (System.IO.File.Exists(path_TSD))
//{
// string path_TPD = System.IO.Path.Combine(directory, string.Format("{0}.{1}", fileName, "tpd"));
// CreateTPD(path_TPD, path_TSD, analyticalModel_Temp);
//}
adjacencyCluster = UpdateDesignLoads(path_TBD, analyticalModel_Temp.AdjacencyCluster);
return(new AnalyticalModel(analyticalModel, adjacencyCluster));
}
public static TBD.dayType ToTAS(this BHE.SimulationDayType dayType, TBD.dayType tbdDayType)
{
tbdDayType.name = dayType.ToTASString();
return(tbdDayType);
}
/// <summary>
/// This is the method that actually does the work.
/// </summary>
/// <param name="dataAccess">The DA object is used to retrieve from inputs and store in outputs.</param>
protected override void SolveInstance(IGH_DataAccess dataAccess)
{
int index_successful = Params.IndexOfOutputParam("successful");
if (index_successful != -1)
{
dataAccess.SetData(index_successful, false);
}
int index;
bool run = false;
index = Params.IndexOfInputParam("_run");
if (index == -1 || !dataAccess.GetData(index, ref run))
{
run = false;
}
if (!run)
{
return;
}
string path_TBD = null;
index = Params.IndexOfInputParam("_path_TBD");
if (index == -1 || !dataAccess.GetData(index, ref path_TBD) || string.IsNullOrWhiteSpace(path_TBD))
{
AddRuntimeMessage(GH_RuntimeMessageLevel.Error, "Invalid data");
return;
}
AnalyticalModel analyticalModel = null;
index = Params.IndexOfInputParam("_analyticalModel");
if (index == -1 || !dataAccess.GetData(index, ref analyticalModel) || string.IsNullOrWhiteSpace(path_TBD))
{
AddRuntimeMessage(GH_RuntimeMessageLevel.Error, "Invalid data");
return;
}
WeatherData weatherData = null;
index = Params.IndexOfInputParam("weatherData_");
if (index != -1)
{
if (!dataAccess.GetData(index, ref weatherData))
{
weatherData = null;
}
}
List <DesignDay> heatingDesignDays = new List <DesignDay>();
index = Params.IndexOfInputParam("heatingDesignDays_");
if (index == -1 || !dataAccess.GetDataList(index, heatingDesignDays) || heatingDesignDays == null || heatingDesignDays.Count == 0)
{
heatingDesignDays = null;
}
List <DesignDay> coolingDesignDays = new List <DesignDay>();
index = Params.IndexOfInputParam("coolingDesignDays_");
if (index == -1 || !dataAccess.GetDataList(index, coolingDesignDays) || coolingDesignDays == null || coolingDesignDays.Count == 0)
{
coolingDesignDays = null;
}
List <SurfaceOutputSpec> surfaceOutputSpecs = null;
List <GH_ObjectWrapper> objectWrappers = new List <GH_ObjectWrapper>();
index = Params.IndexOfInputParam("surfaceOutputSpec_");
if (index != -1 && dataAccess.GetDataList(index, objectWrappers) && objectWrappers != null && objectWrappers.Count != 0)
{
surfaceOutputSpecs = new List <SurfaceOutputSpec>();
foreach (GH_ObjectWrapper objectWrapper in objectWrappers)
{
object value = objectWrapper.Value;
if (value is IGH_Goo)
{
value = (value as dynamic)?.Value;
}
if (value is bool && ((bool)value))
{
SurfaceOutputSpec surfaceOutputSpec = new SurfaceOutputSpec("Tas.Simulate");
surfaceOutputSpec.SolarGain = true;
surfaceOutputSpec.Conduction = true;
surfaceOutputSpec.ApertureData = false;
surfaceOutputSpec.Condensation = false;
surfaceOutputSpec.Convection = false;
surfaceOutputSpec.LongWave = false;
surfaceOutputSpec.Temperature = false;
surfaceOutputSpecs.Add(surfaceOutputSpec);
}
else if (Core.Query.IsNumeric(value) && Core.Query.TryConvert(value, out double @double) && @double == 2.0)
{
surfaceOutputSpecs = new List <SurfaceOutputSpec>()
{
new SurfaceOutputSpec("Tas.Simulate")
};
surfaceOutputSpecs[0].SolarGain = true;
surfaceOutputSpecs[0].Conduction = true;
surfaceOutputSpecs[0].ApertureData = true;
surfaceOutputSpecs[0].Condensation = true;
surfaceOutputSpecs[0].Convection = true;
surfaceOutputSpecs[0].LongWave = true;
surfaceOutputSpecs[0].Temperature = true;
}
else if (value is SurfaceOutputSpec)
{
surfaceOutputSpecs.Add((SurfaceOutputSpec)value);
}
}
}
bool unmetHours = false;
index = Params.IndexOfInputParam("_runUnmetHours_");
if (index != -1)
{
if (!dataAccess.GetData(index, ref unmetHours))
{
unmetHours = true;
}
}
if (System.IO.File.Exists(path_TBD))
{
System.IO.File.Delete(path_TBD);
}
using (SAMTBDDocument sAMTBDDocument = new SAMTBDDocument(path_TBD))
{
TBD.TBDDocument tBDDocument = sAMTBDDocument.TBDDocument;
if (weatherData != null)
{
Weather.Tas.Modify.UpdateWeatherData(tBDDocument, weatherData);
}
TBD.Calendar calendar = tBDDocument.Building.GetCalendar();
List <TBD.dayType> dayTypes = Grashopper.Tas.Query.DayTypes(calendar);
if (dayTypes.Find(x => x.name == "HDD") == null)
{
TBD.dayType dayType = calendar.AddDayType();
dayType.name = "HDD";
}
if (dayTypes.Find(x => x.name == "CDD") == null)
{
TBD.dayType dayType = calendar.AddDayType();
dayType.name = "CDD";
}
Analytical.Tas.Convert.ToTBD(analyticalModel, tBDDocument);
Analytical.Tas.Modify.UpdateZones(tBDDocument.Building, analyticalModel, true);
if (coolingDesignDays != null || heatingDesignDays != null)
{
Analytical.Tas.Modify.AddDesignDays(tBDDocument, coolingDesignDays, heatingDesignDays, 30);
}
sAMTBDDocument.Save();
}
analyticalModel = Analytical.Tas.Modify.RunWorkflow(analyticalModel, path_TBD, null, weatherData, heatingDesignDays, coolingDesignDays, surfaceOutputSpecs, unmetHours);
index = Params.IndexOfOutputParam("_path_TSD");
if (index != -1)
{
string directory = System.IO.Path.GetDirectoryName(path_TBD);
string fileName = System.IO.Path.GetFileNameWithoutExtension(path_TBD);
string path_TSD = System.IO.Path.Combine(directory, string.Format("{0}.{1}", fileName, "tsd"));
dataAccess.SetData(index, path_TSD);
}
index = Params.IndexOfOutputParam("analyticalModel");
if (index != -1)
{
dataAccess.SetData(index, analyticalModel);
}
if (index_successful != -1)
{
dataAccess.SetData(index_successful, true);
}
}
public static bool Update(this TBD.DesignDay designDay_TBD, DesignDay designDay, TBD.dayType dayType = null, int repetitions = 30)
{
if (designDay_TBD == null)
{
return(false);
}
designDay_TBD.yearDay = designDay.GetDateTime().DayOfYear;
designDay_TBD.repetitions = repetitions;
if (dayType != null)
{
designDay_TBD.SetDayType(dayType);
}
return(Weather.Tas.Modify.Update(designDay_TBD?.GetWeatherDay(), designDay));
}
public static bool Update(this TBD.HeatingDesignDay heatingDesignDay_TBD, DesignDay designDay, TBD.dayType dayType = null, int repetitions = 30)
{
if (heatingDesignDay_TBD == null || designDay == null)
{
return(false);
}
heatingDesignDay_TBD.name = designDay.Name;
foreach (TBD.DesignDay designDay_TBD in heatingDesignDay_TBD.DesignDays())
{
designDay_TBD?.Update(designDay, dayType, repetitions);
}
return(true);
}
public static double[] GetNumberOfPeople(TBD.TBDDocument tbdDocument, TBD.zone tbdZone)
{
if (tbdDocument == null)
{
return(null);
}
TBD.dayType[] aDayTypeArray = GetDayTypeArray(tbdDocument);
List <TBD.dayType> aDayTypeList_Unique = GetUnique(aDayTypeArray);
double[] aHourlyValues = null;
double[] aHourlyValuesLatent = null;
double aTotalPersonGain = 0;
Dictionary <string, double[]> aDictionary_DayType = new Dictionary <string, double[]>();
Dictionary <string, double[]> aDictionary_DayTypeLatent = new Dictionary <string, double[]>();
foreach (TBD.dayType aDayType in aDayTypeList_Unique)
{
TBD.InternalCondition aInternalCondition = GetInternalCondition(tbdZone, aDayType);
if (aInternalCondition == null)
{
continue;
}
TBD.IInternalGain aInternalGain = aInternalCondition.GetInternalGain();
aTotalPersonGain = aInternalGain.personGain;
TBD.profile aProfile = aInternalGain.GetProfile((int)TBD.Profiles.ticOSG);
TBD.profile aProfileLatent = aInternalGain.GetProfile((int)TBD.Profiles.ticOLG);
//check if profile hourly or yearly if yearly take it and skip next step
aHourlyValues = GetHourlyValues(aProfile);
aHourlyValuesLatent = GetHourlyValues(aProfileLatent);
//double[] result = x.Select(r => r * factor).ToArray();
aHourlyValues = MultiplyByFactor(aHourlyValues, aProfile.factor);
aHourlyValuesLatent = MultiplyByFactor(aHourlyValuesLatent, aProfile.factor);
aDictionary_DayType.Add(aDayType.name, aHourlyValues);
aDictionary_DayTypeLatent.Add(aDayType.name, aHourlyValuesLatent);
}
double[] aYearlyValues = new double[8760];
int aCount = 0;
for (int i = 0; i < 365; i++)
{
TBD.dayType aDayType = aDayTypeArray[i];
if (!aDictionary_DayType.ContainsKey(aDayType.name))
{
break;
}
aHourlyValues = aDictionary_DayType[aDayType.name];
for (int j = 0; j < 24; j++)
{
aYearlyValues[aCount] = aHourlyValues[j];
aCount++;
}
}
double[] aYearlyValuesLatent = new double[8760];
aCount = 0;
for (int i = 0; i < 365; i++)
{
TBD.dayType aDayType = aDayTypeArray[i];
if (!aDictionary_DayType.ContainsKey(aDayType.name))
{
break;
}
aHourlyValuesLatent = aDictionary_DayTypeLatent[aDayType.name];
for (int j = 0; j < 24; j++)
{
aYearlyValuesLatent[aCount] = aHourlyValuesLatent[j];
aCount++;
}
}
double[] aNumberOfPeople = new double[7];
double aMaxSpecificSensibleGain = aYearlyValues.Max();//Unit W/m2 sensible gain
aNumberOfPeople[0] = aMaxSpecificSensibleGain;
double aMaxSpecificLatentGain = aYearlyValuesLatent.Max();//Unit W/m2 latent gain
aNumberOfPeople[1] = aMaxSpecificLatentGain;
double aPeopleDesity = (aMaxSpecificLatentGain + aMaxSpecificSensibleGain) / aTotalPersonGain; //Unit people/m2
aNumberOfPeople[2] = aPeopleDesity;
double aPeople = tbdZone.floorArea * aPeopleDesity;
aNumberOfPeople[3] = aPeople;
double aPersonSensibleGain = aMaxSpecificSensibleGain / aPeopleDesity; //sensible gain per person
aNumberOfPeople[4] = aPersonSensibleGain;
double aPersonLatenteGain = aMaxSpecificLatentGain / aPeopleDesity; //sensible gain per person
aNumberOfPeople[5] = aPersonLatenteGain;
double aMetabolicRateCheck = aPersonSensibleGain + aPersonLatenteGain;
aNumberOfPeople[6] = aMetabolicRateCheck;
return(aYearlyValues);
}
internal DayType(TBD.dayType DayType)
{
pDayType = DayType;
}
public static Dictionary <TBD.Profiles, Dictionary <string, double[]> > TemperatureSetPointDictionary(this TBD.Building building, params TBD.Profiles[] profiles)
{
List <TBD.zone> zones = building?.Zones();
if (zones == null)
{
return(null);
}
List <TBD.dayType> dayTypes = building.DayTypes();
if (dayTypes == null)
{
return(null);
}
Dictionary <TBD.Profiles, Dictionary <string, Dictionary <string, double[]> > > dictionary_DayType = new Dictionary <TBD.Profiles, Dictionary <string, Dictionary <string, double[]> > >();
foreach (TBD.Profiles profiles_Enum in profiles)
{
dictionary_DayType[profiles_Enum] = new Dictionary <string, Dictionary <string, double[]> >();
foreach (TBD.dayType dayType in dayTypes)
{
Dictionary <string, double[]> dictionary_Zone = new Dictionary <string, double[]>();
dictionary_DayType[profiles_Enum][dayType.name] = dictionary_Zone;
foreach (TBD.zone zone in zones)
{
TBD.InternalCondition internalCondition = InternalCondition(zone, dayType);
if (internalCondition == null)
{
continue;
}
TBD.Thermostat thermostat = internalCondition.GetThermostat();
TBD.profile profile = thermostat.GetProfile((int)profiles_Enum);
double[] dailyValues = DailyValues(profile);
dictionary_Zone.Add(zone.GUID, dailyValues);
}
}
}
dayTypes = building.DayTypes(0, 365);
Dictionary <TBD.Profiles, Dictionary <string, double[]> > result = new Dictionary <TBD.Profiles, Dictionary <string, double[]> >();
foreach (KeyValuePair <TBD.Profiles, Dictionary <string, Dictionary <string, double[]> > > keyValuePair in dictionary_DayType)
{
Dictionary <string, double[]> dictionary_Zone = new Dictionary <string, double[]>();
foreach (TBD.zone zone in zones)
{
bool exists = true;
double[] yearlyValues = new double[8760];
int aCount = 0;
for (int i = 0; i < 365; i++)
{
TBD.dayType dayType = dayTypes[i];
if (!keyValuePair.Value.ContainsKey(dayType.name) || !keyValuePair.Value[dayType.name].ContainsKey(zone.GUID))
{
exists = false;
break;
}
double[] dailyValues = keyValuePair.Value[dayType.name][zone.GUID];
for (int j = 0; j < 24; j++)
{
yearlyValues[aCount] = dailyValues[j];
aCount++;
}
}
if (exists)
{
dictionary_Zone.Add(zone.GUID, yearlyValues);
}
}
result[keyValuePair.Key] = dictionary_Zone;
}
return(result);
}
/// <summary>
/// This is the method that actually does the work.
/// </summary>
/// <param name="dataAccess">The DA object is used to retrieve from inputs and store in outputs.</param>
protected override void SolveInstance(IGH_DataAccess dataAccess)
{
int index_successful = Params.IndexOfOutputParam("successful");
if (index_successful != -1)
{
dataAccess.SetData(index_successful, false);
}
int index;
bool run = false;
index = Params.IndexOfInputParam("_run");
if (index == -1 || !dataAccess.GetData(index, ref run))
{
run = false;
}
if (!run)
{
return;
}
string path = null;
index = Params.IndexOfInputParam("_path_TBD");
if (index == -1 || !dataAccess.GetData(index, ref path) || string.IsNullOrWhiteSpace(path))
{
AddRuntimeMessage(GH_RuntimeMessageLevel.Error, "Invalid data");
return;
}
AnalyticalModel analyticalModel = null;
index = Params.IndexOfInputParam("_analyticalModel");
if (index == -1 || !dataAccess.GetData(index, ref analyticalModel) || string.IsNullOrWhiteSpace(path))
{
AddRuntimeMessage(GH_RuntimeMessageLevel.Error, "Invalid data");
return;
}
WeatherData weatherData = null;
index = Params.IndexOfInputParam("weatherData_");
if (index != -1)
{
if (!dataAccess.GetData(index, ref weatherData))
{
weatherData = null;
}
}
List <DesignDay> heatingDesignDays = new List <DesignDay>();
index = Params.IndexOfInputParam("heatingDesignDays_");
if (index == -1 || !dataAccess.GetDataList(index, heatingDesignDays) || heatingDesignDays == null || heatingDesignDays.Count == 0)
{
heatingDesignDays = null;
}
List <DesignDay> coolingDesignDays = new List <DesignDay>();
index = Params.IndexOfInputParam("coolingDesignDays_");
if (index == -1 || !dataAccess.GetDataList(index, coolingDesignDays) || coolingDesignDays == null || coolingDesignDays.Count == 0)
{
coolingDesignDays = null;
}
if (System.IO.File.Exists(path))
{
System.IO.File.Delete(path);
}
using (SAMTBDDocument sAMTBDDocument = new SAMTBDDocument(path))
{
TBD.TBDDocument tBDDocument = sAMTBDDocument.TBDDocument;
if (weatherData != null)
{
Weather.Tas.Modify.UpdateWeatherData(tBDDocument, weatherData);
}
TBD.Calendar calendar = tBDDocument.Building.GetCalendar();
List <TBD.dayType> dayTypes = Grashopper.Tas.Query.DayTypes(calendar);
if (dayTypes.Find(x => x.name == "HDD") == null)
{
TBD.dayType dayType = calendar.AddDayType();
dayType.name = "HDD";
}
if (dayTypes.Find(x => x.name == "CDD") == null)
{
TBD.dayType dayType = calendar.AddDayType();
dayType.name = "CDD";
}
Analytical.Tas.Convert.ToTBD(analyticalModel, tBDDocument);
Analytical.Tas.Modify.UpdateZones(tBDDocument.Building, analyticalModel, true);
if (coolingDesignDays != null || heatingDesignDays != null)
{
Analytical.Tas.Modify.AddDesignDays(tBDDocument, coolingDesignDays, heatingDesignDays, 30);
}
sAMTBDDocument.Save();
}
index = Params.IndexOfOutputParam("analyticalModel");
if (index != -1)
{
dataAccess.SetData(index, analyticalModel);
}
if (index_successful != -1)
{
dataAccess.SetData(index_successful, true);
}
}
