/// 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); }
// Adds the force exerted on each body to each body's net force void NBodySimulator::AddForcesBetween(ModelObject &b1, ModelObject &b2) { Gravity::PointMass m1 = { b1.mass(), b1.position() }; Gravity::PointMass m2 = { b2.mass(), b2.position() }; Vector3 force = Gravity::force(m1, m2, gravity_); b1.set_force(b1.force() + force); b2.set_force(b2.force() + force * -1); }
double ImfitSolver::EnergyFunction( double *trial, bool &bAtSolution ) { double fitStatistic; fitStatistic = theModel->GetFitStatistic(trial); return(fitStatistic); }
TEST_F(ModelFixture, DefaultConstructionSet_CloneBadName) { Model model; DefaultSurfaceConstructions defaultSurfaceConstructions(model); defaultSurfaceConstructions.setName("Easy name"); ModelObject clone = defaultSurfaceConstructions.clone(model); EXPECT_EQ("Easy name 1", clone.name().get()); clone = defaultSurfaceConstructions.clone(model); EXPECT_EQ("Easy name 2", clone.name().get()); defaultSurfaceConstructions = DefaultSurfaceConstructions(model); defaultSurfaceConstructions.setName("Harder 1-8_(name)"); clone = defaultSurfaceConstructions.clone(model); EXPECT_EQ("Harder 1-8_(name) 1", clone.name().get()); clone = defaultSurfaceConstructions.clone(model); EXPECT_EQ("Harder 1-8_(name) 2", clone.name().get()); defaultSurfaceConstructions = DefaultSurfaceConstructions(model); defaultSurfaceConstructions.setName("*H.a.r.d.e.s.t*^\\1|-|8/_#($name$)?#"); clone = defaultSurfaceConstructions.clone(model); EXPECT_EQ("*H.a.r.d.e.s.t*^\\1|-|8/_#($name$)?# 1", clone.name().get()); clone = defaultSurfaceConstructions.clone(model); EXPECT_EQ("*H.a.r.d.e.s.t*^\\1|-|8/_#($name$)?# 2", clone.name().get()); }
bool STL::read(std::string input_file, Model* model) { TriangleMesh mesh; if (!STL::read(input_file, &mesh)) return false; if (mesh.facets_count() == 0) throw std::runtime_error("This STL file couldn't be read because it's empty."); ModelObject* object = model->add_object(); object->name = boost::filesystem::path(input_file).filename().string(); object->input_file = input_file; ModelVolume* volume = object->add_volume(mesh); volume->name = object->name; return true; }
bool ModelObjectList_Impl::addModelObject(const ModelObject& modelObject ) { WorkspaceExtensibleGroup eg = getObject<ModelObject>().pushExtensibleGroup().cast<WorkspaceExtensibleGroup>(); bool ok = eg.setPointer(OS_ModelObjectListExtensibleFields::ModelObject,modelObject.handle()); if( !ok ) { getObject<ModelObject>().eraseExtensibleGroup(eg.groupIndex()); } return ok; }
bool ComponentData_Impl::registerObject(const ModelObject& object) { IdfExtensibleGroup eg = pushExtensibleGroup(StringVector()); bool result = !eg.empty(); if (result) { ModelExtensibleGroup meg = eg.cast<ModelExtensibleGroup>(); result = result && meg.setPointer(OS_ComponentDataExtensibleFields::NameofObject, object.handle()); } return result; }
ScheduleRule::ScheduleRule(ScheduleRuleset& scheduleRuleset, const ScheduleDay& daySchedule) : ParentObject(ScheduleRule::iddObjectType(), scheduleRuleset.model()) { OS_ASSERT(getImpl<detail::ScheduleRule_Impl>()); bool result = setPointer(OS_Schedule_RuleFields::ScheduleRulesetName, scheduleRuleset.handle()); OS_ASSERT(result); ModelObject clone = daySchedule.clone(scheduleRuleset.model()); result = setPointer(OS_Schedule_RuleFields::DayScheduleName, clone.handle()); OS_ASSERT(result); if (OptionalScheduleTypeLimits limits = scheduleRuleset.scheduleTypeLimits()) { clone.cast<ScheduleDay>().setScheduleTypeLimits(*limits); } this->setRuleIndex(std::numeric_limits<int>::max()); result = scheduleRuleset.setScheduleRuleIndex(*this, 0); OS_ASSERT(result); }
void Model::duplicate_objects_grid(size_t x, size_t y, coordf_t dist) { if (this->objects.size() > 1) throw std::runtime_error("Grid duplication is not supported with multiple objects"); if (this->objects.empty()) throw std::runtime_error("No objects!"); ModelObject* object = this->objects.front(); object->clear_instances(); Sizef3 size = object->bounding_box().size(); for (size_t x_copy = 1; x_copy <= x; ++x_copy) { for (size_t y_copy = 1; y_copy <= y; ++y_copy) { ModelInstance* instance = object->add_instance(); instance->offset.x = (size.x + dist) * (x_copy-1); instance->offset.y = (size.y + dist) * (y_copy-1); } } }
void Model::convert_multipart_object() { if (this->objects.empty()) return; ModelObject* object = this->add_object(); object->input_file = this->objects.front()->input_file; for (const ModelObject* o : this->objects) { for (const ModelVolume* v : o->volumes) { ModelVolume* v2 = object->add_volume(*v); v2->name = o->name; } } for (const ModelInstance* i : this->objects.front()->instances) object->add_instance(*i); while (this->objects.size() > 1) this->delete_object(0); }
void Torre::calcular_viga_cruzada(ModelObject& mo, const glm::vec3& p0, const glm::vec3& p1) { mo.set_model_matrix( ModelObject::adjust_z( ModelObject::line( glm::vec3(p0[0], p0[1], p0[2]*z_factor), glm::vec3(p1[0], p1[1], p1[2]*z_factor), 0.1, 0.1, 1.0/z_factor), z_factor) ); }
bool STL::read(std::string input_file, Model* model) { // TODO: encode file name // TODO: check that file exists TriangleMesh mesh; if (!STL::read(input_file, &mesh)) return false; if (mesh.facets_count() == 0) throw std::runtime_error("This STL file couldn't be read because it's empty."); ModelObject* object = model->add_object(); object->name = input_file; // TODO: use basename() object->input_file = input_file; ModelVolume* volume = object->add_volume(mesh); volume->name = input_file; // TODO: use basename() return true; }
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++; } }
ModelObject ZoneHVACTerminalUnitVariableRefrigerantFlow_Impl::clone(Model model) const { ModelObject terminalClone = ZoneHVACComponent_Impl::clone(model); HVACComponent fanClone = supplyAirFan().clone(model).cast<HVACComponent>(); CoilCoolingDXVariableRefrigerantFlow coolingCoilClone = coolingCoil().clone(model).cast<CoilCoolingDXVariableRefrigerantFlow>(); CoilHeatingDXVariableRefrigerantFlow heatingCoilClone = heatingCoil().clone(model).cast<CoilHeatingDXVariableRefrigerantFlow>(); terminalClone.getImpl<detail::ZoneHVACTerminalUnitVariableRefrigerantFlow_Impl>()->setSupplyAirFan(fanClone); terminalClone.getImpl<detail::ZoneHVACTerminalUnitVariableRefrigerantFlow_Impl>()->setCoolingCoil(coolingCoilClone); terminalClone.getImpl<detail::ZoneHVACTerminalUnitVariableRefrigerantFlow_Impl>()->setHeatingCoil(heatingCoilClone); // TODO Move this into base clase terminalClone.setString(OS_ZoneHVAC_TerminalUnit_VariableRefrigerantFlowFields::TerminalUnitAirInletNode,""); terminalClone.setString(OS_ZoneHVAC_TerminalUnit_VariableRefrigerantFlowFields::TerminalUnitAirOutletNode,""); return terminalClone; }
void ModelObject::cut(Axis axis, coordf_t z, Model* model) const { // clone this one to duplicate instances, materials etc. ModelObject* upper = model->add_object(*this); ModelObject* lower = model->add_object(*this); upper->clear_volumes(); lower->clear_volumes(); upper->input_file = ""; lower->input_file = ""; for (ModelVolumePtrs::const_iterator v = this->volumes.begin(); v != this->volumes.end(); ++v) { ModelVolume* volume = *v; if (volume->modifier) { // don't cut modifiers upper->add_volume(*volume); lower->add_volume(*volume); } else { TriangleMesh upper_mesh, lower_mesh; if (axis == X) { TriangleMeshSlicer<X>(&volume->mesh).cut(z, &upper_mesh, &lower_mesh); } else if (axis == Y) { TriangleMeshSlicer<Y>(&volume->mesh).cut(z, &upper_mesh, &lower_mesh); } else if (axis == Z) { TriangleMeshSlicer<Z>(&volume->mesh).cut(z, &upper_mesh, &lower_mesh); } upper_mesh.repair(); lower_mesh.repair(); upper_mesh.reset_repair_stats(); lower_mesh.reset_repair_stats(); if (upper_mesh.facets_count() > 0) { ModelVolume* vol = upper->add_volume(upper_mesh); vol->name = volume->name; vol->config = volume->config; vol->set_material(volume->material_id(), *volume->material()); } if (lower_mesh.facets_count() > 0) { ModelVolume* vol = lower->add_volume(lower_mesh); vol->name = volume->name; vol->config = volume->config; vol->set_material(volume->material_id(), *volume->material()); } } } }
void RendererBase::loadScene() { m_camera->setPosDir(glm::vec3(0.0f, 5.0f, 0.0f), glm::vec2(TO_RADIANS(175.0f), 0.0f)); ModelObject *ground = new ModelObject(&m_modelCube); ground->scale(glm::vec3(200.0f, 1.0f, 200.0f)); ground->pos(glm::vec3(0.0f, 0.0f, 0.0f)); m_modelObjects.push_back(ground); int index = 0; for (int x = 0; x < 8; x++) { for (int y = 0; y < 8; y++) { LightPoint *lp = new LightPoint; lp->position = glm::vec3(-10.0f + (x* 12 ), 5.0f, -20.0f + (y* 12 )); ModelObject *teapot = new ModelObject(&m_modelTeapot); teapot->scale(glm::vec3(20.0f, 20.0f, 20.0f)); teapot->pos(glm::vec3(lp->position.x-1.0f, 0.5f, lp->position.z)); m_pointLights.push_back(lp); m_modelObjects.push_back(teapot); } } // Textures m_textureGround.load("Ground_SmoothRocks_1k_d.tga", 16); m_textureGround.setTextTile(50.0f); m_textureGround.setKd(glm::vec3(1.0f)); m_textureGround.setShininess(100.0f); m_textureGround.setSpec(0.1f); m_textureTeapot.load("Metal_WallPanel_1k_d.tga", 16); m_textureTeapot.setTextTile(4.0f); m_textureTeapot.setKd(glm::vec3(1.0f)); m_textureTeapot.setShininess(100.0f); m_textureTeapot.setSpec(2.7f); m_textureColorTerrain.setKd(glm::vec3(0.0f, 0.0f, 1.0f)); m_textureColorTerrain.setShininess(100.0f); m_textureColorTerrain.setSpec(2.7f); std::vector<glm::vec3> verticesList; std::vector<glm::vec3> normalsList; std::vector<glm::vec2> tcList; std::vector<GLushort> indices; CreateCube(1, verticesList, normalsList, tcList, indices); m_terrainCube.fillVertecies(verticesList, normalsList, tcList, indices); m_terrainCube.pos(glm::vec3(0.0f, 1.0f, 0.0f)); m_terrainCube.scale(glm::vec3(4.0f)); }