std::vector<openstudio::Time> ScheduleDay_Impl::times() const {
if (!m_cachedTimes){
std::vector<openstudio::Time> result;
for (const IdfExtensibleGroup& group : extensibleGroups()) {
OptionalInt hour = group.getInt(OS_Schedule_DayExtensibleFields::Hour, true);
OptionalInt minute = group.getInt(OS_Schedule_DayExtensibleFields::Minute, true);
if (hour && minute){
openstudio::Time time(0, *hour, *minute);
if (time.totalMinutes() <= 0.5 || time.totalDays() > 1.0){
LOG(Error, "Time " << time << " in " << briefDescription() << " is out of range." );
}else{
result.push_back(time);
}
}else{
LOG(Error, "Could not read time " << group.groupIndex() << " in " << briefDescription() << "." );
}
}
m_cachedTimes = result;
}
return m_cachedTimes.get();
}
openstudio::TimeSeries ScheduleVariableInterval_Impl::timeSeries() const
{
unsigned numExtensibleGroups = this->numExtensibleGroups();
if (numExtensibleGroups == 0){
return TimeSeries(Date(MonthOfYear::Jan, 1), 0, Vector(), "");
}
DateTimeVector dateTimes;
Vector values(numExtensibleGroups);
unsigned i = 0;
for (const ModelExtensibleGroup& group : castVector<ModelExtensibleGroup>(extensibleGroups()))
{
OptionalInt month = group.getInt(0);
OptionalInt day = group.getInt(1);
OptionalInt hour = group.getInt(2);
OptionalInt minute = group.getInt(3);
OptionalDouble x = group.getDouble(4);
OS_ASSERT(month);
OS_ASSERT(day);
OS_ASSERT(hour);
OS_ASSERT(minute);
OS_ASSERT(x);
dateTimes.push_back(DateTime(Date(MonthOfYear(*month), *day), Time(0, *hour, *minute)));
values[i] = *x;
++i;
}
TimeSeries result(dateTimes, values, "");
result.setOutOfRangeValue(this->outOfRangeValue());
return result;
}
unsigned ZoneHVACEquipmentList_Impl::coolingPriority(const ModelObject & equipment)
{
boost::optional<unsigned> result;
std::vector<IdfExtensibleGroup> groups = extensibleGroups();
for( std::vector<IdfExtensibleGroup>::iterator it = groups.begin();
it != groups.end();
++it )
{
boost::optional<WorkspaceObject> wo = it->cast<WorkspaceExtensibleGroup>().getTarget(OS_ZoneHVAC_EquipmentListExtensibleFields::ZoneEquipment);
OS_ASSERT(wo);
if( wo->handle() == equipment.handle() )
{
result = it->getUnsigned(OS_ZoneHVAC_EquipmentListExtensibleFields::ZoneEquipmentCoolingSequence);
break;
}
}
OS_ASSERT(result);
return result.get();
}
std::vector<ModelObject> ZoneHVACEquipmentList_Impl::equipmentInCoolingOrder()
{
std::map<unsigned,ModelObject> equipmentMap;
std::vector<IdfExtensibleGroup> groups = extensibleGroups();
for( std::vector<IdfExtensibleGroup>::iterator it = groups.begin();
it != groups.end();
++it )
{
unsigned coolingPriority = it->getUnsigned(OS_ZoneHVAC_EquipmentListExtensibleFields::ZoneEquipmentCoolingSequence).get();
boost::optional<WorkspaceObject> wo = it->cast<WorkspaceExtensibleGroup>().getTarget(OS_ZoneHVAC_EquipmentListExtensibleFields::ZoneEquipment);
OS_ASSERT(wo);
ModelObject mo = wo->cast<ModelObject>();
equipmentMap.insert(std::make_pair(coolingPriority,mo));
}
std::vector<ModelObject> equipmentVector;
for( unsigned i = 1; i <= equipmentMap.size(); i++ )
{
ModelObject mo = equipmentMap.find(i)->second;
equipmentVector.push_back(mo);
}
return equipmentVector;
}
unsigned AvailabilityManagerAssignmentList_Impl::availabilityManagerPriority(const AvailabilityManager & avm) const {
// TODO: perhaps I chould explicitly check that the avm is
// 1. in the same model
// 2. in the avm list
// In order to LOG a helpful message to the user.
boost::optional<unsigned> result;
std::vector<IdfExtensibleGroup> groups = extensibleGroups();
int i = 1;
for( const auto & group : groups )
{
boost::optional<WorkspaceObject> wo = group.cast<WorkspaceExtensibleGroup>().getTarget(OS_AvailabilityManagerAssignmentListExtensibleFields::AvailabilityManagerName);
OS_ASSERT(wo);
if( wo->handle() == avm.handle() )
{
result = i;
break;
}
i++;
}
if (!result.is_initialized()) {
LOG(Warn, avm.briefDescription() << " wasn't found in " << this->briefDescription());
// Should we return 0 for eg?
}
OS_ASSERT(result);
return result.get();
}
WorkspaceExtensibleGroup ZoneHVACEquipmentList_Impl::getGroupForModelObject(const ModelObject & modelObject)
{
boost::optional<WorkspaceExtensibleGroup> result;
std::vector<IdfExtensibleGroup> groups = extensibleGroups();
for( std::vector<IdfExtensibleGroup>::iterator it = groups.begin();
it != groups.end();
++it )
{
boost::optional<WorkspaceObject> wo = it->cast<WorkspaceExtensibleGroup>().getTarget(OS_ZoneHVAC_EquipmentListExtensibleFields::ZoneEquipment);
OS_ASSERT(wo);
if( wo->handle() == modelObject.handle() )
{
result = it->cast<WorkspaceExtensibleGroup>();
break;
}
}
OS_ASSERT(result);
return result.get();
}
std::vector<ClimateZone> ClimateZones_Impl::climateZones() const {
IdfExtensibleGroupVector egs = extensibleGroups();
ClimateZoneVector result;
for (const IdfExtensibleGroup& eg : egs) {
result.push_back(eg.cast<ClimateZone>());
}
return result;
}
std::vector<FuelType> TimeDependentValuation_Impl::availableFuelTypes() const {
FuelTypeVector result;
IdfExtensibleGroupVector egs = extensibleGroups();
BOOST_FOREACH(const IdfExtensibleGroup& eg,egs) {
OptionalString os = eg.getString(OS_TimeDependentValuationExtensibleFields::AvailableFuelType,true);
OS_ASSERT(os);
FuelType candidate(*os); // can throw if keys and enum get out of sync.
result.push_back(candidate);
}
bool EnergyManagementSystemProgramCallingManager_Impl::eraseProgram(unsigned index) {
//erase program at index
bool result = false;
auto groups = extensibleGroups();
unsigned sizeOfGroup = numExtensibleGroups();
if (index < sizeOfGroup) {
eraseExtensibleGroup(index);
result = true;
}
return result;
}
void ZoneHVACEquipmentList_Impl::removeEquipment(const ModelObject & equipment)
{
std::vector<ModelObject> coolingVector = equipmentInCoolingOrder();
std::vector<ModelObject> heatingVector = equipmentInHeatingOrder();
std::vector<IdfExtensibleGroup> groups = extensibleGroups();
for( std::vector<IdfExtensibleGroup>::iterator it = groups.begin();
it != groups.end();
++it )
{
boost::optional<WorkspaceObject> wo = it->cast<WorkspaceExtensibleGroup>().getTarget(OS_ZoneHVAC_EquipmentListExtensibleFields::ZoneEquipment);
OS_ASSERT(wo);
if( wo->handle() == equipment.handle() )
{
getObject<ModelObject>().eraseExtensibleGroup(it->groupIndex());
break;
}
}
coolingVector.erase(std::find(coolingVector.begin(),coolingVector.end(),equipment));
heatingVector.erase(std::find(heatingVector.begin(),heatingVector.end(),equipment));
unsigned priority = 1;
for( std::vector<ModelObject>::iterator it = coolingVector.begin();
it != coolingVector.end();
++it )
{
WorkspaceExtensibleGroup eg = getGroupForModelObject(*it);
eg.setUnsigned(OS_ZoneHVAC_EquipmentListExtensibleFields::ZoneEquipmentCoolingSequence,priority);
priority++;
}
priority = 1;
for( std::vector<ModelObject>::iterator it = heatingVector.begin();
it != heatingVector.end();
++it )
{
WorkspaceExtensibleGroup eg = getGroupForModelObject(*it);
eg.setUnsigned(OS_ZoneHVAC_EquipmentListExtensibleFields::ZoneEquipmentHeatingorNoLoadSequence,priority);
priority++;
}
}
bool EnergyManagementSystemProgramCallingManager_Impl::setProgram(const EnergyManagementSystemProgram& program, unsigned index) {
//add program to {index} of vector of programs
bool result = false;
auto groups = extensibleGroups();
unsigned sizeOfGroup = numExtensibleGroups();
if (index <= sizeOfGroup) {
IdfExtensibleGroup idfGroup = insertExtensibleGroup(index, StringVector());
OS_ASSERT(!idfGroup.empty());
ModelExtensibleGroup group = idfGroup.cast<ModelExtensibleGroup>();
result = group.setPointer(0, program.handle());
}
return result;
}
std::vector<Glazing> ThermochromicGlazing_Impl::mf_glazings() const {
GlazingVector result;
for (const IdfExtensibleGroup& idfGroup : extensibleGroups()) {
ModelExtensibleGroup group = idfGroup.cast<ModelExtensibleGroup>();
OptionalWorkspaceObject owo = group.getTarget(OS_WindowMaterial_GlazingGroup_ThermochromicExtensibleFields::WindowMaterialGlazingName);
if (owo) {
OptionalGlazing og = owo->optionalCast<Glazing>();
OS_ASSERT(og);
result.push_back(*og);
}
}
return result;
}
std::vector<CoilHeatingGasMultiStageStageData> CoilHeatingGasMultiStage_Impl::stages() const {
std::vector<CoilHeatingGasMultiStageStageData> result;
auto groups = extensibleGroups();
for( auto group: groups ) {
auto target = group.cast<WorkspaceExtensibleGroup>().getTarget(OS_Coil_Heating_Gas_MultiStageExtensibleFields::Stage);
if( target ) {
if( auto stage = target->optionalCast<CoilHeatingGasMultiStageStageData>() ) {
result.push_back(stage.get());
}
}
}
return result;
}
std::vector<EnergyManagementSystemProgram> EnergyManagementSystemProgramCallingManager_Impl::programs() const {
// loop through extensible groups and return vector of programs
std::vector<EnergyManagementSystemProgram> result;
auto groups = extensibleGroups();
for (const auto & elem : groups) {
WorkspaceExtensibleGroup group = elem.cast<WorkspaceExtensibleGroup>();
boost::optional<WorkspaceObject> wo = group.getTarget(OS_EnergyManagementSystem_ProgramCallingManagerExtensibleFields::ProgramName);
if (wo){
EnergyManagementSystemProgram program = wo->cast<EnergyManagementSystemProgram>();
result.push_back(program);
}
}
return result;
}
boost::optional<EnergyManagementSystemProgram> EnergyManagementSystemProgramCallingManager_Impl::getProgram(unsigned index) const {
//return program at index
boost::optional<EnergyManagementSystemProgram> result;
auto groups = extensibleGroups();
unsigned sizeOfGroup = numExtensibleGroups();
if ((index < sizeOfGroup) && (!groups[index].empty())) {
WorkspaceExtensibleGroup group = groups[index].cast<WorkspaceExtensibleGroup>();
boost::optional<WorkspaceObject> wo = group.getTarget(OS_EnergyManagementSystem_ProgramCallingManagerExtensibleFields::ProgramName);
if (wo) {
EnergyManagementSystemProgram program = wo->cast<EnergyManagementSystemProgram>();
result = program;
}
}
return result;
}
std::vector<ModelObject> ModelObjectList_Impl::modelObjects() const {
std::vector<ModelObject> result;
std::vector<IdfExtensibleGroup> groups = extensibleGroups();
for( const auto & group : groups )
{
boost::optional<WorkspaceObject> wo = group.cast<WorkspaceExtensibleGroup>().getTarget(OS_ModelObjectListExtensibleFields::ModelObject);
if( wo )
{
result.push_back(wo->cast<ModelObject>());
}
}
return result;
}
std::vector<openstudio::Date> ScheduleRule_Impl::specificDates() const
{
YearDescription yd = this->model().getUniqueModelObject<model::YearDescription>();
std::vector<openstudio::Date> result;
for (const ModelExtensibleGroup& group : castVector<ModelExtensibleGroup>(extensibleGroups()))
{
OptionalInt month = group.getInt(0);
OS_ASSERT(month);
OptionalInt day = group.getInt(1);
OS_ASSERT(day);
result.push_back(yd.makeDate(MonthOfYear(*month), *day));
}
return result;
}
std::vector<AvailabilityManager> AvailabilityManagerAssignmentList_Impl::availabilityManagers() const
{
std::vector<AvailabilityManager> result;
std::vector<IdfExtensibleGroup> groups = extensibleGroups();
for( const auto & group : groups )
{
boost::optional<WorkspaceObject> wo = group.cast<WorkspaceExtensibleGroup>().getTarget(OS_AvailabilityManagerAssignmentListExtensibleFields::AvailabilityManagerName);
if( wo )
{
result.push_back(wo->cast<AvailabilityManager>());
}
}
return result;
}
std::vector<double> ScheduleDay_Impl::values() const {
if (!m_cachedValues){
std::vector<double> result;
for (const IdfExtensibleGroup& group : extensibleGroups()) {
OptionalDouble value = group.getDouble(OS_Schedule_DayExtensibleFields::ValueUntilTime, true);
if (value){
result.push_back(*value);
}else{
LOG(Error, "Could not read value " << group.groupIndex() << " in " << briefDescription() << "." );
}
}
m_cachedValues = result;
}
return m_cachedValues.get();
}
std::vector<SpectralDataField> MaterialPropertyGlazingSpectralData_Impl::spectralDataFields() const
{
std::vector<SpectralDataField> result;
for (const ModelExtensibleGroup& group : castVector<ModelExtensibleGroup>(extensibleGroups()))
{
OptionalDouble wavelength = group.getDouble(OS_MaterialProperty_GlazingSpectralDataExtensibleFields::Wavelength);
OptionalDouble transmittance = group.getDouble(OS_MaterialProperty_GlazingSpectralDataExtensibleFields::Transmittance);
OptionalDouble frontReflectance = group.getDouble(OS_MaterialProperty_GlazingSpectralDataExtensibleFields::FrontReflectance);
OptionalDouble backReflectance = group.getDouble(OS_MaterialProperty_GlazingSpectralDataExtensibleFields::BackReflectance);
if (wavelength && transmittance && frontReflectance && backReflectance){
result.push_back(SpectralDataField(*wavelength, *transmittance, *frontReflectance, *backReflectance));
}else{
LOG(Error, "Could not read SpectralDataField " << group.groupIndex() << " in " << briefDescription() << "." );
}
}
return result;
}
openstudio::TimeSeries ScheduleFixedInterval_Impl::timeSeries() const
{
Date startDate(openstudio::MonthOfYear(this->startMonth()), this->startDay());
Time intervalLength(0, 0, this->intervalLength());
Vector values(this->numExtensibleGroups());
unsigned i = 0;
for (const ModelExtensibleGroup& group : castVector<ModelExtensibleGroup>(extensibleGroups()))
{
OptionalDouble x = group.getDouble(0);
OS_ASSERT(x);
values[i] = *x;
++i;
}
TimeSeries result(startDate, intervalLength, values, "");
result.setOutOfRangeValue(this->outOfRangeValue());
return result;
}
std::vector<ModelObject> ZoneHVACEquipmentList_Impl::equipment() const
{
std::vector<ModelObject> result;
std::vector<IdfExtensibleGroup> groups = extensibleGroups();
for( std::vector<IdfExtensibleGroup>::iterator it = groups.begin();
it != groups.end();
++it )
{
boost::optional<WorkspaceObject> wo = it->cast<WorkspaceExtensibleGroup>().getTarget(OS_ZoneHVAC_EquipmentListExtensibleFields::ZoneEquipment);
if( wo )
{
result.push_back(wo->cast<ModelObject>());
}
}
return result;
}
std::vector<WaterUseEquipment> WaterUseConnections_Impl::waterUseEquipment() const
{
std::vector<WaterUseEquipment> result;
std::vector<IdfExtensibleGroup> groups = extensibleGroups();
for( const auto & elem : groups )
{
WorkspaceExtensibleGroup group = elem.cast<WorkspaceExtensibleGroup>();
boost::optional<WorkspaceObject> wo = group.getTarget(OS_WaterUse_ConnectionsExtensibleFields::WaterUseEquipmentName);
if( wo )
{
WaterUseEquipment equipment = wo->cast<WaterUseEquipment>();
result.push_back(equipment);
}
}
return result;
}
WorkspaceExtensibleGroup ModelObjectList_Impl::getGroupForModelObject(const ModelObject& modelObject)
{
boost::optional<WorkspaceExtensibleGroup> result;
std::vector<IdfExtensibleGroup> groups = extensibleGroups();
for( const auto & group : groups )
{
boost::optional<WorkspaceObject> wo = group.cast<WorkspaceExtensibleGroup>().getTarget(OS_ModelObjectListExtensibleFields::ModelObject);
OS_ASSERT(wo);
if( wo->handle() == modelObject.handle() )
{
result = group.cast<WorkspaceExtensibleGroup>();
break;
}
}
OS_ASSERT(result);
return result.get();
}
