C++ (Cpp) ScheduleTypeLimits::upperLimitValue Examples

Example #1

File: ScheduleTypeLimits.cpp Project: Anto-F/OpenStudio

bool isCompatible(const ScheduleTypeLimits &parentLimits,
                  const ScheduleTypeLimits &candidate)
{
  if (candidate == parentLimits) {
    return true;
  }

  // check continuous/discrete
  if (OptionalString numericType = parentLimits.numericType()) {
    if (!candidate.numericType() || !istringEqual(candidate.numericType().get(),*numericType)) {
      return false;
    }
  }

  // check unit type
  std::string unitType = parentLimits.unitType();
  if (parentLimits.isUnitTypeDefaulted() || istringEqual("Dimensionless",unitType)) {
    if (!(candidate.isUnitTypeDefaulted() || (istringEqual("Dimensionless",candidate.unitType())))) {
      return false;
    }
  }
  else {
    if (!istringEqual(candidate.unitType(),unitType)) {
      return false;
    }
  }

  // check lower limit
  if (parentLimits.lowerLimitValue()) {
    if (!candidate.lowerLimitValue() ||
        (candidate.lowerLimitValue().get() < parentLimits.lowerLimitValue().get()))
    {
      return false;
    }
  }

  // check upper limit
  if (parentLimits.upperLimitValue()) {
    if (!candidate.upperLimitValue() ||
        (candidate.upperLimitValue().get() > parentLimits.upperLimitValue().get()))
    {
      return false;
    }
  }

  // passed all checks
  return true;
}

Example #2

File: ScheduleTypeRegistry_GTest.cpp Project: MatthewSteen/OpenStudio

TEST_F(ModelFixture, ScheduleTypeRegistry_UseInSetSchedule) {
  Model model;

  // create a schedule
  ScheduleConstant schedule(model);

  // set a minimal schedule type limits
  ScheduleTypeLimits anyNumber(model);
  anyNumber.setName("Any Number");
  bool ok = schedule.setScheduleTypeLimits(anyNumber);
  EXPECT_TRUE(ok);

  // try to set Lights schedule--should fail b/c needs between 0 and 1
  LightsDefinition definition(model);
  definition.setLightingLevel(100.0);
  Lights light(definition);
  ok = light.setSchedule(schedule);
  EXPECT_FALSE(ok);

  // set Availablity schedule type limits
  ScheduleType scheduleType = ScheduleTypeRegistry::instance().getScheduleType("CoilCoolingDXSingleSpeed","Availability");
  ScheduleTypeLimits availabilityLimits = ScheduleTypeRegistry::instance().getOrCreateScheduleTypeLimits(scheduleType,model);
  ok = schedule.setScheduleTypeLimits(availabilityLimits);
  EXPECT_TRUE(ok);

  // try to set Lights schedule--used to fail b/c lights schedule is Dimensionless, not Availability, now passes
  ok = light.setSchedule(schedule);
  EXPECT_TRUE(ok);

  // clear conflicting information
  availabilityLimits.resetNumericType();
  availabilityLimits.resetUnitType();

  // set Lights schedule--should succeed b/c not in conflict
  ok = light.setSchedule(schedule);
  EXPECT_TRUE(ok);

  // try to clear schedule type limits--should fail b/c in use
  ok = schedule.resetScheduleTypeLimits();
  EXPECT_FALSE(ok);

  // reset Lights schedule
  light.resetSchedule();

  // try to clear schedule type limits--should succeed
  ok = schedule.resetScheduleTypeLimits();
  EXPECT_TRUE(ok);
  EXPECT_FALSE(schedule.scheduleTypeLimits());

  // set Lights schedule--should succeed and assign an appropriate ScheduleTypeLimits
  ok = light.setSchedule(schedule);
  EXPECT_TRUE(ok);
  ASSERT_TRUE(schedule.scheduleTypeLimits());
  ScheduleTypeLimits lightsLimits = schedule.scheduleTypeLimits().get();
  EXPECT_EQ("Fractional",lightsLimits.name().get());
  ASSERT_TRUE(lightsLimits.numericType());
  EXPECT_EQ("Continuous",lightsLimits.numericType().get());
  EXPECT_EQ("Dimensionless",lightsLimits.unitType());
  EXPECT_TRUE(lightsLimits.isUnitTypeDefaulted());
  ASSERT_TRUE(lightsLimits.lowerLimitValue());
  EXPECT_DOUBLE_EQ(0.0,lightsLimits.lowerLimitValue().get());
  ASSERT_TRUE(lightsLimits.upperLimitValue());
  EXPECT_DOUBLE_EQ(1.0,lightsLimits.upperLimitValue().get());
}