bool LayeredConstruction_Impl::insertLayer(unsigned layerIndex, 
                                             const Material& material) 
  {
    OS_ASSERT(material.model() == model());
    layerIndex = mf_clearNullLayers(layerIndex);

    unsigned n = numLayers();
    MaterialVector layers = this->layers();
    MaterialVector::iterator layersBegin = layers.begin();
    MaterialVector::iterator layersEnd = layers.end();
    MaterialVector::iterator insertAtIt = layersBegin;
    while ((static_cast<unsigned>(insertAtIt - layersBegin) < layerIndex) &&
           (insertAtIt != layersEnd)) 
    { ++insertAtIt; }
    layers.insert(insertAtIt, material);
    OS_ASSERT(layers.size() == ++n);
    if ((model().strictnessLevel() < StrictnessLevel::Final) || 
        LayeredConstruction::layersAreValid(layers)) 
    {
      IdfExtensibleGroup idfGroup = insertExtensibleGroup(layerIndex,StringVector());
      OS_ASSERT(!idfGroup.empty());
      ModelExtensibleGroup group = idfGroup.cast<ModelExtensibleGroup>();
      bool ok = group.setPointer(0,material.handle());
      OS_ASSERT(ok);
      return true;
    }

    return false;
  }
TEST_F(ModelFixture, ConstructionWithInternalSource_ReverseConstructionWithInternalSource_2)
{
  Model model;

  // Create some materials
  StandardOpaqueMaterial exterior(model);
  StandardOpaqueMaterial interior(model);

  OpaqueMaterialVector layers;
  layers.push_back(exterior);
  layers.push_back(interior);

  ConstructionWithInternalSource construction(layers);

  EXPECT_EQ(1u, model.getModelObjects<ConstructionWithInternalSource>().size());

  ConstructionWithInternalSource construction2 = construction.reverseConstructionWithInternalSource();

  EXPECT_EQ(2u, model.getModelObjects<ConstructionWithInternalSource>().size());
  EXPECT_NE(construction.handle(), construction2.handle());

  MaterialVector testLayers = construction2.layers();
  ASSERT_EQ(static_cast<unsigned>(2),testLayers.size());
  EXPECT_TRUE(testLayers[0] == interior);
  EXPECT_TRUE(testLayers[1] == exterior);

  ConstructionWithInternalSource construction3 = construction.reverseConstructionWithInternalSource();
  EXPECT_EQ(2u, model.getModelObjects<ConstructionWithInternalSource>().size());
  EXPECT_NE(construction.handle(), construction3.handle());
  EXPECT_EQ(construction2.handle(), construction3.handle());
}
TEST_F(ModelFixture, Construction_InsertLayers)
{
  Model model;

  // Create some materials
  StandardOpaqueMaterial exterior(model);
  AirGap air(model);
  StandardOpaqueMaterial interior(model);

  Construction construction(model);
  try{
    // these functions should not throw, just return false
    EXPECT_TRUE(construction.insertLayer(0, exterior));
    EXPECT_TRUE(construction.insertLayer(1, air));
    EXPECT_TRUE(construction.insertLayer(2, interior));
  }catch(const std::exception&){
    
  }

  // Get layers
  MaterialVector testLayers = construction.layers();
  ASSERT_EQ(static_cast<unsigned>(3),testLayers.size());
  EXPECT_TRUE(testLayers[0] == exterior);
  EXPECT_TRUE(testLayers[1] == air);
  EXPECT_TRUE(testLayers[2] == interior);
}
TEST_F(ModelFixture, Construction_Layers)
{
  Model model;

  // Create some materials
  StandardOpaqueMaterial exterior(model);
  AirGap air(model);
  StandardOpaqueMaterial interior(model);

  OpaqueMaterialVector layers;
  layers.push_back(exterior);
  layers.push_back(air);
  layers.push_back(interior);

  Construction construction(layers);

  // Get layers
  MaterialVector testLayers = construction.layers();
  ASSERT_EQ(static_cast<unsigned>(3),testLayers.size());
  EXPECT_TRUE(testLayers[0] == exterior);
  EXPECT_TRUE(testLayers[1] == air);
  EXPECT_TRUE(testLayers[2] == interior);

  // construct by clone
  Model modelClone = model.clone().cast<Model>();
  EXPECT_EQ(static_cast<unsigned>(4),modelClone.objects().size());
  ConstructionVector constructions = modelClone.getModelObjects<Construction>();
  ASSERT_EQ(static_cast<unsigned>(1),constructions.size());
  construction = constructions[0];
  EXPECT_FALSE(construction.model() == model);
  EXPECT_TRUE(construction.iddObject().type() ==
              IddObjectType::OS_Construction);
}
Exemple #5
0
MaterialVector MaterialManager::load(const std::string &filepath)
{
    if ( !filepath.empty() )
    {
        // We must find a MaterialLoader able to load this file.
        
        for ( auto it = iFactory.getLoaders().begin(); it != iFactory.getLoaders().end(); it++ )
        {
            MaterialLoader* loader = it->second.get();
            
            if ( loader )
            {
                if ( loader->isLoadable(filepath) )
                {
                    // Found a loader. Load the Materials.
                    
                    MaterialHolderList materials = loader->load(filepath);
                    
                    if ( !materials.empty() )
                    {
                        // Registers every Loader to the Manager and to the return Vector.
                        
                        MaterialVector ret;
                        
                        for ( MaterialHolder& holder : materials )
                        {
                            iMaterials.add(holder);
                            ret.push_back(Material(holder));
                        }
                        
                        return ret;
                    }
                    
                    else
                    {
#ifdef GreIsDebugMode
                        GreDebugPretty() << "File '" << filepath << "' doesn't seem to contain any Material." << std::endl;
#endif
                        return MaterialVector();
                    }
                }
            }
        }
        
#ifdef GreIsDebugMode
        GreDebugPretty() << "File '" << filepath << "' is not loadable by any MaterialLoader." << std::endl;
#endif
        return MaterialVector();
    }
    
    else
    {
#ifdef GreIsDebugMode
        GreDebugPretty() << "'filepath' is empty." << std::endl;
#endif
        return MaterialVector();
    }
}
Exemple #6
0
void CSobeyView::ComputerTimeLineLength(MaterialVector& timeLine)
{
    m_timeLineLength = 0;
    if (timeLine.empty())
        return;
    for (MaterialVector::iterator it = timeLine.begin(); it != timeLine.end(); ++it)
    {
        m_timeLineLength += abs(it->endTime - it->beginTime);
    }
}
boost::optional<IdfObject> ForwardTranslator::translateConstruction( Construction & modelObject )
{
  IdfObject construction( openstudio::IddObjectType::Construction );
  m_idfObjects.push_back(construction);

  for (LifeCycleCost lifeCycleCost : modelObject.lifeCycleCosts()){
    translateAndMapModelObject(lifeCycleCost);
  }

  construction.setName(modelObject.name().get());

  MaterialVector layers = modelObject.layers();

  unsigned fieldIndex = 1;
  for(unsigned layerIndex = 0; layerIndex < layers.size(); ++layerIndex ) {
    Material material = layers[layerIndex];
    translateAndMapModelObject(material);
    construction.setString(fieldIndex++, material.name().get());
  }

  return boost::optional<IdfObject>(construction);
}
Exemple #8
0
void CSobeyView::ComputerTimeLineRect(MaterialVector& timeLine)
{
    ComputerTimeLineLength(timeLine);
    m_timeLineRect.clear();
    if (timeLine.empty())
        return;
    int top = 10;
    int left = 10;
    int width = 0;
    int height = 50;

    CRect windowRect;
    GetWindowRect(&windowRect);
    // 计算出窗体的大小作为比率
    int base = windowRect.right - windowRect.left - 20;
    for (MaterialVector::iterator it = timeLine.begin(); it != timeLine.end(); ++it)
    {
        left += width + 1;
        // 素材的宽度等于素材时间长度和时间线总长的比值乘以窗体大小
        width = abs(it->endTime - it->beginTime) * base / m_timeLineLength;
        m_timeLineRect.push_back(CRect(left, top, left + width, top + height));
    }
}
TEST_F(ModelFixture, ConstructionWithInternalSource_Layers)
{
  Model model;

  // Create some materials
  StandardOpaqueMaterial exterior(model);
  AirGap air(model);
  StandardOpaqueMaterial interior(model);

  MaterialVector layers;
  layers.push_back(exterior);
  layers.push_back(air);
  layers.push_back(interior);

  ConstructionWithInternalSource construction(model);
  EXPECT_TRUE(construction.setLayers(layers));

  // Get layers
  MaterialVector testLayers = construction.layers();
  ASSERT_EQ(static_cast<unsigned>(3),testLayers.size());
  EXPECT_TRUE(testLayers[0] == exterior);
  EXPECT_TRUE(testLayers[1] == air);
  EXPECT_TRUE(testLayers[2] == interior);
}
Exemple #10
0
TEST_F(ModelFixture, Material)
{
  Model model;

  StandardOpaqueMaterial exterior(model);

  MaterialVector materials = model.getModelObjects<Material>();
  ASSERT_EQ(static_cast<unsigned>(1), materials.size());

  StandardsInformationMaterialVector materialInformations = model.getModelObjects<StandardsInformationMaterial>();
  ASSERT_EQ(static_cast<unsigned>(0), materialInformations.size());

  {
    Model testModel;

    exterior.clone(testModel);

    materials = model.getModelObjects<Material>();
    ASSERT_EQ(static_cast<unsigned>(1), materials.size());

    materialInformations = model.getModelObjects<StandardsInformationMaterial>();
    ASSERT_EQ(static_cast<unsigned>(0), materialInformations.size());

    materials = testModel.getModelObjects<Material>();
    ASSERT_EQ(static_cast<unsigned>(1), materials.size());

    materialInformations = testModel.getModelObjects<StandardsInformationMaterial>();
    ASSERT_EQ(static_cast<unsigned>(0), materialInformations.size());
  }

  StandardsInformationMaterial info = exterior.standardsInformation();

  {
    Model testModel;

    exterior.clone(testModel);


    materials = model.getModelObjects<Material>();
    ASSERT_EQ(static_cast<unsigned>(1), materials.size());

    materialInformations = model.getModelObjects<StandardsInformationMaterial>();
    ASSERT_EQ(static_cast<unsigned>(1), materialInformations.size());

    materials = testModel.getModelObjects<Material>();
    ASSERT_EQ(static_cast<unsigned>(1), materials.size());

    materialInformations = testModel.getModelObjects<StandardsInformationMaterial>();
    ASSERT_EQ(static_cast<unsigned>(1), materialInformations.size());
  }

  {
    Model testModel;

    info.clone(testModel);

    materials = model.getModelObjects<Material>();
    ASSERT_EQ(static_cast<unsigned>(1), materials.size());

    materialInformations = model.getModelObjects<StandardsInformationMaterial>();
    ASSERT_EQ(static_cast<unsigned>(1), materialInformations.size());

    materials = testModel.getModelObjects<Material>();
    ASSERT_EQ(static_cast<unsigned>(0), materials.size());

    materialInformations = testModel.getModelObjects<StandardsInformationMaterial>();
    ASSERT_EQ(static_cast<unsigned>(1), materialInformations.size());
  }

  StandardOpaqueMaterial exteriorClone = exterior.clone().cast<StandardOpaqueMaterial>();

  materials = model.getModelObjects<Material>();
  ASSERT_EQ(static_cast<unsigned>(2), materials.size());

  materialInformations = model.getModelObjects<StandardsInformationMaterial>();
  ASSERT_EQ(static_cast<unsigned>(2), materialInformations.size());

}
  ConstructionWithInternalSource ConstructionWithInternalSource_Impl::reverseConstructionWithInternalSource() const
  {
    MaterialVector reverseLayers(this->layers());
    std::reverse(reverseLayers.begin(), reverseLayers.end());

    int numLayers = (int)this->numLayers();
    int reverseSourcePresentAfterLayerNumber = numLayers - this->sourcePresentAfterLayerNumber();
    int reverseTemperatureCalculationRequestedAfterLayerNumber = numLayers - this->temperatureCalculationRequestedAfterLayerNumber();
    int dimensionsForTheCTFCalculation = this->dimensionsForTheCTFCalculation();
    double tubeSpacing = this->tubeSpacing();

    Model model = this->model();
    for (const ConstructionWithInternalSource& other : model.getConcreteModelObjects<ConstructionWithInternalSource>()) {
      
      if (other.sourcePresentAfterLayerNumber() != reverseSourcePresentAfterLayerNumber){
        continue;
      }

      if (other.temperatureCalculationRequestedAfterLayerNumber() != reverseTemperatureCalculationRequestedAfterLayerNumber){
        continue;
      }

      if (other.dimensionsForTheCTFCalculation() != dimensionsForTheCTFCalculation){
        continue;
      }

      if (other.tubeSpacing() != tubeSpacing){
        continue;
      }

      MaterialVector layers = other.layers();
      if (layers.size() != reverseLayers.size()){
        continue;
      }

      bool test = true;
      for (unsigned i = 0; i < layers.size(); ++i){
        if (layers[i].handle() != reverseLayers[i].handle()){
          test = false;
          break; // break out of loop over layers
        }
      }

      if (test){
        return other;
      }
    }

    // TODO: this should also copy (and modify) standards information object

    // no match, make one
    ConstructionWithInternalSource result(model);
    result.setName(this->name().get() + " Reversed");
    result.setSourcePresentAfterLayerNumber(reverseSourcePresentAfterLayerNumber);
    result.setTemperatureCalculationRequestedAfterLayerNumber(reverseTemperatureCalculationRequestedAfterLayerNumber);
    result.setDimensionsForTheCTFCalculation(dimensionsForTheCTFCalculation);
    result.setTubeSpacing(tubeSpacing);
    result.setLayers(reverseLayers);

    return result;
  }
TEST_F(ModelFixture, ConstructionWithInternalSource_FromLayers)
{
  Model model;

  // Create some materials
  StandardOpaqueMaterial exterior(model);
  StandardOpaqueMaterial interior(model);

  OpaqueMaterialVector layers;

  EXPECT_EQ(0, model.getModelObjects<ConstructionWithInternalSource>().size());

  EXPECT_EQ(0, layers.size());
  EXPECT_THROW((ConstructionWithInternalSource(layers)), std::exception);

  EXPECT_EQ(0, model.getModelObjects<ConstructionWithInternalSource>().size());

  layers.push_back(exterior);

  EXPECT_EQ(1u, layers.size());
  EXPECT_THROW((ConstructionWithInternalSource(layers)), std::exception);

  EXPECT_EQ(0, model.getModelObjects<ConstructionWithInternalSource>().size());

  layers.push_back(interior);

  EXPECT_EQ(2u, layers.size());
  ConstructionWithInternalSource construction(layers);
  EXPECT_EQ(2u, construction.numLayers());
  EXPECT_EQ(2u, construction.layers().size());
  EXPECT_EQ(1, construction.sourcePresentAfterLayerNumber());
  EXPECT_EQ(1, construction.temperatureCalculationRequestedAfterLayerNumber());
  EXPECT_EQ(1, construction.dimensionsForTheCTFCalculation());
  EXPECT_EQ(0.154, construction.tubeSpacing());

  // check that we can't mess up the construction
  EXPECT_FALSE(construction.setSourcePresentAfterLayerNumber(3));
  EXPECT_EQ(1, construction.sourcePresentAfterLayerNumber());
  EXPECT_FALSE(construction.setTemperatureCalculationRequestedAfterLayerNumber(3));
  EXPECT_EQ(1, construction.temperatureCalculationRequestedAfterLayerNumber());

  EXPECT_TRUE(construction.eraseLayer(1));
  EXPECT_EQ(1u, construction.numLayers());

  EXPECT_FALSE(construction.setLayers(MaterialVector()));
  EXPECT_EQ(1u, construction.numLayers());

  MaterialVector testLayers = construction.layers();
  ASSERT_EQ(static_cast<unsigned>(1),testLayers.size());
  EXPECT_TRUE(testLayers[0] == exterior);

  testLayers.push_back(interior);
  testLayers.push_back(exterior);

  EXPECT_TRUE(construction.setLayers(testLayers));
  EXPECT_EQ(3u, construction.numLayers());

  testLayers = construction.layers();
  ASSERT_EQ(static_cast<unsigned>(3),testLayers.size());
  EXPECT_TRUE(testLayers[0] == exterior);
  EXPECT_TRUE(testLayers[1] == interior);
  EXPECT_TRUE(testLayers[2] == exterior);

  EXPECT_TRUE(construction.setSourcePresentAfterLayerNumber(3));
  EXPECT_EQ(3, construction.sourcePresentAfterLayerNumber());
  EXPECT_TRUE(construction.setTemperatureCalculationRequestedAfterLayerNumber(3));
  EXPECT_EQ(3, construction.temperatureCalculationRequestedAfterLayerNumber());

  testLayers.clear();
  testLayers.push_back(interior);
  testLayers.push_back(exterior);

  EXPECT_TRUE(construction.setLayers(testLayers));
  EXPECT_EQ(2u, construction.numLayers());

  testLayers = construction.layers();
  ASSERT_EQ(static_cast<unsigned>(2),testLayers.size());
  EXPECT_TRUE(testLayers[0] == interior);
  EXPECT_TRUE(testLayers[1] == exterior);

  EXPECT_EQ(1, construction.sourcePresentAfterLayerNumber());
  EXPECT_EQ(1, construction.temperatureCalculationRequestedAfterLayerNumber());

  EXPECT_FALSE(construction.setSourcePresentAfterLayerNumber(3));
  EXPECT_EQ(1, construction.sourcePresentAfterLayerNumber());
  EXPECT_FALSE(construction.setTemperatureCalculationRequestedAfterLayerNumber(3));
  EXPECT_EQ(1, construction.temperatureCalculationRequestedAfterLayerNumber());

  while (layers.size() < 11) {
    layers.push_back(exterior);
  }
  EXPECT_THROW((ConstructionWithInternalSource(layers)), std::exception);
}