C++ ModelObject类代码示例

/// Objective function: calculates the objective value (ignore gradient calculation)
/// Keep track of how many times this function has been called, and report current
/// chi^2 (or other objective-function value) every 20 calls
/// Note that parameters n and grad are unused, but required by the NLopt interface.
double myfunc_nlopt_gen( unsigned n, const double *x, double *grad, void *my_func_data )
{
  ModelObject *theModel = (ModelObject *)my_func_data;
  // following is a necessary kludge bcs theModel->GetFitStatistic() won't accept 
  // const double*
  double  *params = (double *)x;
  double  fitStatistic;
  nlopt_result  junk;
  
  fitStatistic = theModel->GetFitStatistic(params);
  
  // feedback to user
  funcCallCount++;
  if (verboseOutput > 0) {
    if ((funcCallCount % FUNCS_PER_REPORTING_STEP) == 0) {
      printf("\tN-M simplex: function call %d: objective = %f\n", funcCallCount, fitStatistic);
      if ( (verboseOutput > 1) && ((funcCallCount % (REPORT_STEPS_PER_VERBOSE_OUTPUT*FUNCS_PER_REPORTING_STEP)) == 0) ) {
        PrintParametersSimple(theModel, params);
      }
    }
  }
  
  if (isnan(fitStatistic)) {
    fprintf(stderr, "\n*** NaN-valued fit statistic detected (N-M optimization)!\n");
    fprintf(stderr, "*** Terminating the fit...\n");
    junk = nlopt_force_stop(theOptimizer);
  }

  return(fitStatistic);
}

void Level::findObjectsInRadius( TGameObjectVec& out_objects, const rtti::TypeInfo* type, const mkVec3& search_origin, float radius, bool allow_derived /*= true*/ )
{
    MK_ASSERT(out_objects.empty());

    m_objectsMgr.findObjectsOfType(out_objects, type, allow_derived);

    for (size_t i = 0; i < out_objects.size(); ++i)
    {
        bool accept = false;

        GameObject* go = out_objects[i];
        if (go->getTypeInfo()->isDerivedOrExact(&ModelObject::Type))
        {
            ModelObject* mo = static_cast<ModelObject*>(go);
            float dist_sq = (mo->getWorldPosition() - search_origin).length();

            if (dist_sq <= radius)
                accept = true;
        }

        if (!accept)
            out_objects[i] = NULL;
    }

    fast_remove_val_from_vec(out_objects, (GameObject*)NULL);
}

bool Model::IsOverlapping(ModelObject &left, ModelObject &right)
{
  Shape::Sphere circle_left = { left.position(), left.radius() };
  Shape::Sphere circle_right = { right.position(), right.radius() };

  return (Overlap::IsOverlapping(circle_left, circle_right));
}

// Set parent object id (after reading from model emf-file)
void
BoundaryCondition::updateParentId()
{
  // If parent object type is a normal boundary, replace the
  // parent object with the boundary-group object
  //
  if ( parentEmfType != OT_ELEMENT_GROUP ) {

    ModelObject* obj = model->getModelObjectByTag(parentEmfType, parentEmfTag);
    if ( obj != NULL ) {
      BodyElement* be = (BodyElement*)obj;
      parentEmfTag = be->getElementGroupTag();
      parentEmfType = OT_ELEMENT_GROUP;
    } else {
      parentEmfTag = NO_INDEX;
      parentEmfType = OT_NONE;
    }
  }

  ModelObject* obj = model->getModelObjectByTag(parentEmfType, parentEmfTag);

  if ( obj != NULL ) {
    parentId = obj->Id();
  }
}

void RenderQueue::Enqueue(const mat4x4 &world, ModelHandle& model){
	ModelObject* obj = new ModelObject();
	obj->Model = model;
	obj->World = world;
	obj->SetType( RENDER_TYPE::MODEL);
	m_CurrentScene->Objects.push_back(obj);
	m_CurrentScene->Programs.push_back(nullptr); //default program
}

 ModelObject ParentObject_Impl::clone(Model model) const
 {
   ModelObject newParentAsModelObject = ModelObject_Impl::clone(model);
   ParentObject newParent = newParentAsModelObject.cast<ParentObject>();
   for (ModelObject child : children())
   {
     ModelObject newChild = child.clone(model);
     newChild.setParent(newParent);
   }
   return newParentAsModelObject;
 }

TEST_F(ModelFixture, Construction_Clone)
{
  Model library;

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

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

  EXPECT_EQ(static_cast<unsigned>(3), library.getModelObjects<Material>().size());

  Construction construction(layers);
  ASSERT_EQ(static_cast<unsigned>(3), construction.layers().size());

  // Clone into same model
  ModelObject clone = construction.clone(library);

  // Material ResourceObject instances are shared resources so they have not been cloned
  EXPECT_EQ(static_cast<unsigned>(3), library.getModelObjects<Material>().size());

  // New handle for cloned construction
  EXPECT_FALSE(clone.handle() == construction.handle());
  ASSERT_TRUE(clone.optionalCast<Construction>());

  ASSERT_EQ(static_cast<unsigned>(3), clone.cast<Construction>().layers().size());

  // Clone into a differnt model
  Model model;

  auto clone2 = construction.clone(model).cast<Construction>();
  EXPECT_EQ(static_cast<unsigned>(3), model.getModelObjects<Material>().size());

  EXPECT_EQ(static_cast<unsigned>(1), model.getModelObjects<Construction>().size());

  // Make sure materials are still hooked up
  ASSERT_EQ(static_cast<unsigned>(3), clone2.cast<Construction>().layers().size());

  // Clone again
  auto clone3 = construction.clone(model).cast<Construction>();
  EXPECT_EQ(static_cast<unsigned>(3), model.getModelObjects<Material>().size());

  EXPECT_EQ(static_cast<unsigned>(2), model.getModelObjects<Construction>().size());

  // Make sure materials are still hooked up
  ASSERT_EQ(static_cast<unsigned>(3), clone3.cast<Construction>().layers().size());

  EXPECT_FALSE(clone2.handle() == clone3.handle());
}

ContainersTemp get_output_containers(const ModelObjectsTemp &mo) {
  ContainersTemp ret;
  for (unsigned int i = 0; i < mo.size(); ++i) {
    ModelObject *o = mo[i];
    Container *p = dynamic_cast<Container *>(o);
    if (p)
      ret.push_back(p);
    else {
      ret += get_output_containers(o->get_inputs());
    }
  }
  return ret;
}

ParticlesTemp get_output_particles(const ModelObjectsTemp &mo) {
  ParticlesTemp ret;
  for (unsigned int i = 0; i < mo.size(); ++i) {
    ModelObject *o = mo[i];
    Particle *p = dynamic_cast<Particle *>(o);
    if (p)
      ret.push_back(p);
    else {
      ret += get_output_particles(o->get_inputs());
    }
  }
  return ret;
}

void OSIntegerEdit::refreshTextAndLabel() {
  if (m_modelObject) {
    QString textValue;
    ModelObject modelObject = m_modelObject.get();
    std::stringstream ss;

    if (m_isAutosizedProperty) {
      Attribute autosized = modelObject.getAttribute(*m_isAutosizedProperty).get();
      if (autosized.valueAsBoolean()) {
        textValue = QString("autosize");
      }
    }

    if (m_isAutocalculatedProperty) {
      Attribute autocalculated = modelObject.getAttribute(*m_isAutocalculatedProperty).get();
      if (autocalculated.valueAsBoolean()) {
        textValue = QString("autocalculate");
      }
    }

    OptionalAttribute attribute = modelObject.getAttribute(m_property);
    if (attribute) {
      int value = attribute->valueAsInteger();
      if (m_isScientific) {
        ss << std::scientific;
      }
      else {
        ss << std::fixed;
      }
      if (m_precision) {
        ss << std::setprecision(*m_precision);
      }
      ss << value;
      textValue = toQString(ss.str());
      ss.str("");
    }

    this->setText(textValue);

    if (m_isDefaultedProperty) {
      Attribute defaulted = modelObject.getAttribute(*m_isDefaultedProperty).get();
      if (defaulted.valueAsBoolean()) {
        this->setStyleSheet("color:green");
      }
      else {
        this->setStyleSheet("color:black");
      }
    }
  }
}

  bool Node_Impl::isConnected(const ModelObject & modelObject)
  {
    if( auto mo = outletModelObject() ) {
      if( modelObject.handle() == mo->handle() ) {
        return true;
      }
    }
    if( auto mo = inletModelObject() ) {
      if( modelObject.handle() == mo->handle() ) {
        return true;
      }
    }

    return false;
  }

TEST_F(ModelFixture, ModelObject_Attributes)
{
  Model model;

  OptionalWorkspaceObject oObject = model.addObject(IdfObject(IddObjectType::OS_Version));
  ASSERT_TRUE(oObject);
  ModelObject version = oObject->cast<ModelObject>();
  StringVector versionAttributeNames = version.attributeNames();
  ASSERT_EQ(static_cast<unsigned>(3),versionAttributeNames.size());
  EXPECT_EQ("iddObjectType",versionAttributeNames[0]);
  EXPECT_EQ("handle",versionAttributeNames[1]);
  EXPECT_EQ("name",versionAttributeNames[2]);

  EXPECT_FALSE(version.getAttribute("N a m e"));
}

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();
}

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();
}

ExternalInterfaceFunctionalMockupUnitImportToActuator::ExternalInterfaceFunctionalMockupUnitImportToActuator(const ModelObject& modelObject,
                                                                                                             const std::string& actuatedComponentType,
                                                                                                             const std::string& actuatedComponentControlType,
                                                                                                             const ExternalInterfaceFunctionalMockupUnitImport& fMUFile,
                                                                                                             const std::string& fMUInstanceName,
                                                                                                             const std::string& fMUVariableName,
                                                                                                             double initialValue)
  : ModelObject(ExternalInterfaceFunctionalMockupUnitImportToActuator::iddObjectType(), modelObject.model())
{
  OS_ASSERT(getImpl<detail::ExternalInterfaceFunctionalMockupUnitImportToActuator_Impl>());

  bool ok = setActuatedComponentUnique(modelObject);
  if (!ok) {
    remove();
    LOG_AND_THROW("Unable to set " << briefDescription() << "'s ActuatedComponentUnique to "
      << modelObject.nameString() << ".");
  }
  setActuatedComponentType(actuatedComponentType);
  setActuatedComponentControlType(actuatedComponentControlType);
  ok = setFMUFile(fMUFile);
  if (!ok) {
    remove();
    LOG_AND_THROW("Unable to set " << briefDescription() << "'s FMUFileName to "
      << fMUFile.fMUFileName() << ".");
  }
  setFMUInstanceName(fMUInstanceName);
  setFMUVariableName(fMUVariableName);
  setInitialValue(initialValue);
}