void BooksDBUtil::addTag(shared_ptr<Book> book, shared_ptr<Tag> tag) { if (book->addTag(tag)) { BooksDB::Instance().saveTags(book); } }
bool PersistentRuleCriteria::ReadObject(shared_ptr<RuleCriteria> pRuleCriteria, shared_ptr<DALRecordset> pRS) { if (pRS->IsEOF()) return false; pRuleCriteria->SetID(pRS->GetLongValue("criteriaid")); pRuleCriteria->SetRuleID(pRS->GetLongValue("criteriaruleid")); pRuleCriteria->SetMatchValue(pRS->GetStringValue("criteriamatchvalue")); pRuleCriteria->SetPredefinedField((RuleCriteria::PredefinedField) pRS->GetLongValue("criteriapredefinedfield")); pRuleCriteria->SetMatchType((RuleCriteria::MatchType) pRS->GetLongValue("criteriamatchtype")); pRuleCriteria->SetHeaderField(pRS->GetStringValue("criteriaheadername")); pRuleCriteria->SetUsePredefined(pRS->GetLongValue("criteriausepredefined") ? true : false); return true; }
int feature_extraction_pipeline(int argc, char** argv) { ::google::InitGoogleLogging(argv[0]); const int num_required_args = 7; if (argc < num_required_args) { LOG(ERROR)<< "This program takes in a trained network and an input data layer, and then" " extract features of the input data produced by the net.\n" "Usage: extract_features pretrained_net_param" " feature_extraction_proto_file extract_feature_blob_name1[,name2,...]" " save_feature_dataset_name1[,name2,...] num_mini_batches db_type" " [CPU/GPU] [DEVICE_ID=0]\n" "Note: you can extract multiple features in one pass by specifying" " multiple feature blob names and dataset names seperated by ','." " The names cannot contain white space characters and the number of blobs" " and datasets must be equal."; return 1; } int arg_pos = num_required_args; arg_pos = num_required_args; if (argc > arg_pos && strcmp(argv[arg_pos], "GPU") == 0) { LOG(ERROR)<< "Using GPU"; uint device_id = 0; if (argc > arg_pos + 1) { device_id = atoi(argv[arg_pos + 1]); CHECK_GE(device_id, 0); } LOG(ERROR) << "Using Device_id=" << device_id; Caffe::SetDevice(device_id); Caffe::set_mode(Caffe::GPU); } else { LOG(ERROR) << "Using CPU"; Caffe::set_mode(Caffe::CPU); } arg_pos = 0; // the name of the executable std::string pretrained_binary_proto(argv[++arg_pos]); // Expected prototxt contains at least one data layer such as // the layer data_layer_name and one feature blob such as the // fc7 top blob to extract features. /* layers { name: "data_layer_name" type: DATA data_param { source: "/path/to/your/images/to/extract/feature/images_leveldb" mean_file: "/path/to/your/image_mean.binaryproto" batch_size: 128 crop_size: 227 mirror: false } top: "data_blob_name" top: "label_blob_name" } layers { name: "drop7" type: DROPOUT dropout_param { dropout_ratio: 0.5 } bottom: "fc7" top: "fc7" } */ std::string feature_extraction_proto(argv[++arg_pos]); shared_ptr<Net<Dtype> > feature_extraction_net( new Net<Dtype>(feature_extraction_proto, caffe::TEST)); feature_extraction_net->CopyTrainedLayersFrom(pretrained_binary_proto); std::string extract_feature_blob_names(argv[++arg_pos]); std::vector<std::string> blob_names; caffe::string_split(&blob_names, extract_feature_blob_names, ","); std::string save_feature_dataset_names(argv[++arg_pos]); std::vector<std::string> dataset_names; caffe::string_split(&dataset_names, save_feature_dataset_names, ","); CHECK_EQ(blob_names.size(), dataset_names.size()) << " the number of blob names and dataset names must be equal"; size_t num_features = blob_names.size(); for (size_t i = 0; i < num_features; i++) { CHECK(feature_extraction_net->has_blob(blob_names[i])) << "Unknown feature blob name " << blob_names[i] << " in the network " << feature_extraction_proto; } int num_mini_batches = atoi(argv[++arg_pos]); std::vector<shared_ptr<db::DB> > feature_dbs; std::vector<shared_ptr<db::Transaction> > txns; const char* db_type = argv[++arg_pos]; for (size_t i = 0; i < num_features; ++i) { LOG(INFO)<< "Opening dataset " << dataset_names[i]; shared_ptr<db::DB> db(db::GetDB(db_type)); db->Open(dataset_names.at(i), db::NEW); feature_dbs.push_back(db); shared_ptr<db::Transaction> txn(db->NewTransaction()); txns.push_back(txn); } LOG(ERROR)<< "Extacting Features"; Datum datum; const int kMaxKeyStrLength = 100; char key_str[kMaxKeyStrLength]; std::vector<Blob<float>*> input_vec; std::vector<int> image_indices(num_features, 0); for (int batch_index = 0; batch_index < num_mini_batches; ++batch_index) { feature_extraction_net->Forward(input_vec); for (int i = 0; i < num_features; ++i) { const shared_ptr<Blob<Dtype> > feature_blob = feature_extraction_net ->blob_by_name(blob_names[i]); int batch_size = feature_blob->num(); int dim_features = feature_blob->count() / batch_size; const Dtype* feature_blob_data; for (int n = 0; n < batch_size; ++n) { datum.set_height(feature_blob->height()); datum.set_width(feature_blob->width()); datum.set_channels(feature_blob->channels()); datum.clear_data(); datum.clear_float_data(); feature_blob_data = feature_blob->cpu_data() + feature_blob->offset(n); for (int d = 0; d < dim_features; ++d) { datum.add_float_data(feature_blob_data[d]); } int length = snprintf(key_str, kMaxKeyStrLength, "%010d", image_indices[i]); string out; CHECK(datum.SerializeToString(&out)); txns.at(i)->Put(std::string(key_str, length), out); ++image_indices[i]; if (image_indices[i] % 1000 == 0) { txns.at(i)->Commit(); txns.at(i).reset(feature_dbs.at(i)->NewTransaction()); LOG(ERROR)<< "Extracted features of " << image_indices[i] << " query images for feature blob " << blob_names[i]; } } // for (int n = 0; n < batch_size; ++n) } // for (int i = 0; i < num_features; ++i) } // for (int batch_index = 0; batch_index < num_mini_batches; ++batch_index) // write the last batch for (int i = 0; i < num_features; ++i) { if (image_indices[i] % 1000 != 0) { txns.at(i)->Commit(); } LOG(ERROR)<< "Extracted features of " << image_indices[i] << " query images for feature blob " << blob_names[i]; feature_dbs.at(i)->Close(); } LOG(ERROR)<< "Successfully extracted the features!"; return 0; }
bool operator== (int num) { std::unique_lock<std::mutex> lck(*mtx_); cv_->wait(lck, [this, num]()->bool { return *count_ == num; }); *count_ = 0; return true; }
/*! Constitutive law */ void FCPM::go(shared_ptr<IGeom>& _geom, shared_ptr<IPhys>& _phys, Interaction* I){ const ScGeom& geom=*static_cast<ScGeom*>(_geom.get()); FreshConcretePhys& phys=*static_cast<FreshConcretePhys*>(_phys.get()); const int id1 = I->getId1(); const int id2 = I->getId2(); const BodyContainer& bodies = *scene->bodies; const State& de1 = *static_cast<State*>(bodies[id1]->state.get()); const State& de2 = *static_cast<State*>(bodies[id2]->state.get()); //Calculation of the max penetretion and the radius of the overlap area Sphere* s1=dynamic_cast<Sphere*>(bodies[id1]->shape.get()); Sphere* s2=dynamic_cast<Sphere*>(bodies[id2]->shape.get()); Real dist; Real contactRadius; Real OverlapRadius; if (s1 and s2) { phys.maxPenetration=s1->radius * phys.Penetration1 + s2->radius * phys.Penetration2; dist = s1->radius + s2->radius - geom.penetrationDepth; OverlapRadius = pow(((4 * pow(dist,2) * pow(s1->radius,2) - pow((pow(dist,2) - pow(s2->radius,2) + pow(s1->radius,2)),2)) / (4 * pow(dist,2))),(1.0/2.0)); //contactRadius = (pow(s1->radius,2) + pow(s2->radius,2))/(s1->radius + s2->radius); contactRadius = s1->radius; } else if (s1 and not(s2)) { phys.maxPenetration=s1->radius * phys.Penetration1; dist = s1->radius - geom.penetrationDepth; OverlapRadius =pow((pow(s1->radius,2) - pow(dist,2)),(1.0/2.0)); contactRadius = s1->radius; } else { phys.maxPenetration=s2->radius * phys.Penetration2; dist = s2->radius - geom.penetrationDepth; OverlapRadius = pow((pow(s2->radius,2) - pow(dist,2)),(1.0/2.0)); contactRadius = s2->radius; } Vector3r& shearForce = phys.shearForce; if (I->isFresh(scene)) shearForce=Vector3r(0,0,0); const Real& dt = scene->dt; shearForce = geom.rotate(shearForce); // Handle periodicity. const Vector3r shift2 = scene->isPeriodic ? scene->cell->intrShiftPos(I->cellDist): Vector3r::Zero(); const Vector3r shiftVel = scene->isPeriodic ? scene->cell->intrShiftVel(I->cellDist): Vector3r::Zero(); const Vector3r c1x = (geom.contactPoint - de1.pos); const Vector3r c2x = (geom.contactPoint - de2.pos - shift2); const Vector3r relativeVelocity = (de1.vel+de1.angVel.cross(c1x)) - (de2.vel+de2.angVel.cross(c2x)) + shiftVel; const Real normalVelocity = geom.normal.dot(relativeVelocity); const Vector3r shearVelocity = relativeVelocity-normalVelocity*geom.normal; //Normal Force Real OverlapArea; Real MaxArea; OverlapArea = 3.1415 * pow(OverlapRadius,2); MaxArea = 3.1415 * pow(contactRadius,2); Real Mult; if(OverlapRadius < contactRadius){ Mult = OverlapArea / MaxArea; } else{ Mult = 1; } Real Fn; if(geom.penetrationDepth>=0){ //Compression if(normalVelocity>=0){ if (geom.penetrationDepth >= phys.maxPenetration){ Fn = phys.knI * (geom.penetrationDepth - phys.previousun) + phys.previousElasticN + phys.cnI * normalVelocity; phys.previousElasticN += phys.knI * (geom.penetrationDepth - phys.previousun); phys.normalForce = Fn * geom.normal; phys.t = 0; phys.t2 = 0; //phys.previousElasticTensionN = 0; } else{ Fn = Mult * phys.kn * (geom.penetrationDepth - phys.previousun) + Mult * phys.previousElasticN + phys.cn * normalVelocity; phys.previousElasticN += Mult * phys.kn * (geom.penetrationDepth - phys.previousun); phys.finalElasticN += Mult * phys.kn * (geom.penetrationDepth - phys.previousun); phys.normalForce = Fn * geom.normal; phys.t = 0; phys.t2 = 0; //phys.previousElasticTensionN = 0; } } //Tension else if(normalVelocity<0){ if(phys.t == 0){ phys.maxNormalComp = - phys.finalElasticN; //printf("------> %E \n", phys.maxNormalComp); phys.RupOverlap = phys.previousun; //throw runtime_error("STOP"); phys.t = 1; } Real MaxTension = phys.maxNormalComp * 0.25; Real FnTension = phys.previousElasticTensionN + Mult * phys.kn * dt * normalVelocity; //printf("===:: %E \n", MaxTension); //printf("===:: %E \n", FnTension); if (FnTension > MaxTension && phys.t2 == 0){ Fn = phys.previousElasticTensionN + Mult * phys.kn * dt * normalVelocity; phys.previousElasticTensionN = Fn; phys.normalForce = Fn * geom.normal; phys.RupOverlap = geom.penetrationDepth; //phys.previousElasticN = 0; //printf("===-- %E \n", Fn); } else{ //phys.DamageTension = geom.penetrationDepth / (phys.maxPenetration - phys.maxPenetration * phys.RupTension); //phys.previousElasticTensionN -= phys.DamageTension * Mult * phys.kn * dt * normalVelocity; phys.t2 = 1; Fn = MaxTension * geom.penetrationDepth / phys.RupOverlap; phys.normalForce = Fn * geom.normal; //printf("===// %E \n", Fn); //throw runtime_error("STOP"); } } } else{ Fn = 0; phys.normalForce = Fn * geom.normal; phys.finalElasticN = 0; } phys.previousun = geom.penetrationDepth; //Shear Force shearForce += phys.ks*dt*shearVelocity; Vector3r shearForceVisc = Vector3r::Zero(); const Real maxFs = phys.normalForce.squaredNorm() * std::pow(phys.tangensOfFrictionAngle,2); if( shearForce.squaredNorm() > maxFs ){ // Then Mohr-Coulomb is violated (so, we slip), // we have the max value of the shear force, so // we consider only friction damping. const Real ratio = sqrt(maxFs) / shearForce.norm(); shearForce *= ratio; } else{ // Then no slip occurs we consider friction damping + viscous damping. shearForceVisc = phys.cs*shearVelocity; } if (I->isActive) { const Vector3r f = phys.normalForce + shearForce + shearForceVisc; addForce (id1,-f,scene); addForce (id2, f,scene); addTorque(id1,-c1x.cross(f),scene); addTorque(id2, c2x.cross(f),scene); } }
void UI::Push(const shared_ptr<Panel> &panel) { panel->SetUI(this); toPush.push_back(panel); }
SinkCounter() { cv_.reset(new condition_variable); mtx_.reset(new mutex); count_.reset(new int(0)); }
void ServicesDbReader::_addTagsToElement(shared_ptr<Element> element) { bool ok; Tags& tags = element->getTags(); if (tags.contains("hoot:status")) { QString statusStr = tags.get("hoot:status"); bool ok; const int statusInt = statusStr.toInt(&ok); Status status = static_cast<Status::Type>(statusInt); if (ok && status.getEnum() >= Status::Invalid && status.getEnum() <= Status::Conflated) { element->setStatus(status); } else { LOG_WARN("Invalid status: " + statusStr + " for element with ID: " + QString::number(element->getId())); } tags.remove("hoot:status"); } if (tags.contains("type")) { Relation* r = dynamic_cast<Relation*>(element.get()); if (r) { r->setType(tags["type"]); tags.remove("type"); } } if (tags.contains("error:circular")) { element->setCircularError(tags.get("error:circular").toDouble(&ok)); if (!ok) { try { double tv = tags.getLength("error:circular").value(); element->setCircularError(tv); ok = true; } catch (const HootException& e) { ok = false; } if (!ok) { LOG_WARN("Error parsing error:circular."); } } tags.remove("error:circular"); } else if (tags.contains("accuracy")) { element->setCircularError(tags.get("accuracy").toDouble(&ok)); if (!ok) { try { double tv = tags.getLength("accuracy").value(); element->setCircularError(tv); ok = true; } catch (const HootException& e) { ok = false; } if (!ok) { LOG_WARN("Error parsing accuracy."); } } tags.remove("accuracy"); } }
ContainerFrame::ContainerFrame(const Point& pos, shared_ptr<ResourceCtl> res, const std::string& title, shared_ptr<Inventory> inv) : UIFrame(pos, inv->getSize().modMul(INVENTORY_ICON_SIZE).modAdd(20, 20), res, title) { _inv = inv; _contArea = make_shared<ContainerArea>(Point(10, 10 + _titleHeight), _inv->getSize(), this); }
void ServicesDbReader::_readBounded(shared_ptr<OsmMap> map, const ElementType& elementType) { LOG_DEBUG("IN ServicesDbReader::readBounded(,)..."); long long lastId = LLONG_MIN; shared_ptr<Element> element; QStringList tags; bool firstElement = true; QStringList bboxParts = _bbox.split(","); double minLat = bboxParts[1].toDouble(); double minLon = bboxParts[0].toDouble(); double maxLat = bboxParts[3].toDouble(); double maxLon = bboxParts[2].toDouble(); // determine is Services or Osm Api DB ServicesDb::DbType connectionType = _database.getDatabaseType(); // contact the DB and select all shared_ptr<QSqlQuery> elementResultsIterator = _database.selectBoundedElements(_osmElemId, elementType, _bbox); // split the reading of Services and Osm Api DB upfront to avoid extra inefficiency of if-else calls // inside the isActive loop switch ( connectionType ) { case ServicesDb::DBTYPE_SERVICES: //need to check isActive, rather than next() here b/c resultToElement actually calls next() and //it will always return an extra null node at the end, unfortunately (see comments in //ServicesDb::resultToElement) while (elementResultsIterator->isActive()) { shared_ptr<Element> element = _resultToElement(*elementResultsIterator, elementType, *map ); //this check is necessary due to an inefficiency in ServicesDb::resultToElement if (element.get()) { if (_status != Status::Invalid) { element->setStatus(_status); } map->addElement(element); } } break; case ServicesDb::DBTYPE_OSMAPI: // check if db active or not assert(elementResultsIterator->isActive()); switch (elementType.getEnum()) { /////////////////////////////////////////////////////////////////// // NODES /////////////////////////////////////////////////////////////////// case ElementType::Node: while( elementResultsIterator->next() ) { long long id = elementResultsIterator->value(0).toLongLong(); if( lastId != id ) { // process the complete element only after the first element created if(!firstElement) { if(tags.size()>0) { element->setTags( ServicesDb::unescapeTags(tags.join(", ")) ); _addTagsToElement( element ); } if (_status != Status::Invalid) { element->setStatus(_status); } map->addElement(element); tags.clear(); } // extract the node contents except for the tags element = _resultToNode_OsmApi(*elementResultsIterator, *map); lastId = id; firstElement = false; } // read the tag for as many rows as there are tags // need to get into form "key1"=>"val1", "key2"=>"val2", ... QString result = _database.extractTagFromRow_OsmApi(elementResultsIterator, elementType.getEnum()); if(result != "") tags << result; } // process the last complete element only if an element has been created if(!firstElement) { if(tags.size()>0) { element->setTags( ServicesDb::unescapeTags(tags.join(", ")) ); _addTagsToElement( element ); } if (_status != Status::Invalid) { element->setStatus(_status); } map->addElement(element); tags.clear(); } break; /////////////////////////////////////////////////////////////////// // WAYS /////////////////////////////////////////////////////////////////// case ElementType::Way: while( elementResultsIterator->next() ) { long long wayId = elementResultsIterator->value(0).toLongLong(); shared_ptr<QSqlQuery> nodeInfoIterator = _database.selectNodesForWay( wayId ); bool foundOne = false; while( nodeInfoIterator->next() && !foundOne) { // do the bounds check double lat = nodeInfoIterator->value(ServicesDb::NODES_LATITUDE).toLongLong()/(double)ServicesDb::COORDINATE_SCALE; double lon = nodeInfoIterator->value(ServicesDb::NODES_LONGITUDE).toLongLong()/(double)ServicesDb::COORDINATE_SCALE; if(lat >= minLat && lat <= maxLat && lon >= minLon && lon <= maxLon) foundOne = true; // ToDo: process boundary condition } if( foundOne ) { // we have a polygon, so now you have to do some work; else go on to the next way_id // process the way into a data structure shared_ptr<Element> element = _resultToWay_OsmApi(*elementResultsIterator, *map); // get the way tags shared_ptr<QSqlQuery> wayTagIterator = _database.selectTagsForWay_OsmApi( wayId ); while( wayTagIterator->next() ) { // test for blank tag QString val1 = wayTagIterator->value(1).toString(); QString val2 = wayTagIterator->value(2).toString(); QString tag = ""; if(val1!="" || val2!="") tag = "\""+val1+"\"=>\""+val2+"\""; if(tag != "") tags << tag; } if(tags.size()>0) { element->setTags( ServicesDb::unescapeTags(tags.join(", ")) ); _addTagsToElement( element ); } if (_status != Status::Invalid) { element->setStatus(_status); } map->addElement(element); tags.clear(); } } break; /////////////////////////////////////////////////////////////////// // RELATIONS /////////////////////////////////////////////////////////////////// case ElementType::Relation: while( elementResultsIterator->next() ) { _processRelation(*elementResultsIterator, *map); } break; default: throw HootException(QString("Unexpected element type: %1").arg(elementType.toString())); } break; default: throw HootException("_read cannot operate on unsupported database type"); break; } LOG_DEBUG("LEAVING ServicesDbReader::_read..."); }
void ServicesDbReader::_read(shared_ptr<OsmMap> map, const ElementType& elementType) { LOG_DEBUG("IN ServicesDbReader::read(,)..."); long long lastId = LLONG_MIN; shared_ptr<Element> element; QStringList tags; bool firstElement = true; // determine is Services or Osm Api DB ServicesDb::DbType connectionType = _database.getDatabaseType(); // contact the DB and select all shared_ptr<QSqlQuery> elementResultsIterator = _database.selectAllElements(_osmElemId, elementType); // split the reading of Services and Osm Api DB upfront to avoid extra inefficiency of if-else calls // inside the isActive loop switch ( connectionType ) { case ServicesDb::DBTYPE_SERVICES: //need to check isActive, rather than next() here b/c resultToElement actually calls next() and //it will always return an extra null node at the end, unfortunately (see comments in //ServicesDb::resultToElement) while (elementResultsIterator->isActive()) { shared_ptr<Element> element = _resultToElement(*elementResultsIterator, elementType, *map ); //this check is necessary due to an inefficiency in ServicesDb::resultToElement if (element.get()) { if (_status != Status::Invalid) { element->setStatus(_status); } map->addElement(element); } } break; case ServicesDb::DBTYPE_OSMAPI: // check if db active or not assert(elementResultsIterator->isActive()); while( elementResultsIterator->next() ) { long long id = elementResultsIterator->value(0).toLongLong(); if( lastId != id ) { // process the complete element only after the first element created if(!firstElement) { if(tags.size()>0) { element->setTags( ServicesDb::unescapeTags(tags.join(", ")) ); _addTagsToElement( element ); } if (_status != Status::Invalid) { element->setStatus(_status); } map->addElement(element); tags.clear(); } // extract the node contents except for the tags switch (elementType.getEnum()) { case ElementType::Node: element = _resultToNode_OsmApi(*elementResultsIterator, *map); break; case ElementType::Way: element = _resultToWay_OsmApi(*elementResultsIterator, *map); break; case ElementType::Relation: element = _resultToRelation_OsmApi(*elementResultsIterator, *map); break; default: throw HootException(QString("Unexpected element type: %1").arg(elementType.toString())); } lastId = id; firstElement = false; } // read the tag for as many rows as there are tags // need to get into form "key1"=>"val1", "key2"=>"val2", ... QString result = _database.extractTagFromRow_OsmApi(elementResultsIterator, elementType.getEnum()); if(result != "") tags << result; } // process the last complete element only if an element has been created if(!firstElement) { if(tags.size()>0) { element->setTags( ServicesDb::unescapeTags(tags.join(", ")) ); _addTagsToElement( element ); } if (_status != Status::Invalid) { element->setStatus(_status); } map->addElement(element); tags.clear(); } break; default: throw HootException("_read cannot operate on unsupported database type"); break; } LOG_DEBUG("LEAVING ServicesDbReader::_read..."); }
//从撤单中生成新的报单 void Trader::generateOrderFromCanceledOrder(const shared_ptr<Order> &order){ shared_ptr<Order> newOrder = make_shared<Order>(); newOrder->moveToThread(QCoreApplication::instance()->thread()); newOrder->setInvestorId(order->getInvestorId()); newOrder->setStrategyId(order->getStrategyId()); newOrder->setInstructionId(order->getInstructionId()); newOrder->setInstrumentId(order->getInstrumentId()); newOrder->setDirection(order->getDirection()); newOrder->setOpenCloseFlag(order->getOpenCloseFlag()); double price = order->getPrice(); //获得该合约的最小价格变动单位,如果买则买价增加,如果卖则卖价减小 auto instruments = BackgroundTrader::getInstance()->getInstruments(); auto &info = instruments[order->getInstrumentId()]; double minPrice = info->getMinimumUnit(); if (order->getDirection() == 'b'){ price += minPrice; } else{ price -= minPrice; } newOrder->setPrice(price); newOrder->setOriginalVolume(order->getRestVolume()); newOrder->setTradedVolume(0); newOrder->setRestVolume(newOrder->getOriginalVolume()); newOrder->setOpenCloseFlag(order->getOpenCloseFlag()); newOrder->setOrderStatus('a'); if (newOrder->getOpenCloseFlag() == '1'){ //当收到平仓字段时对合约进行判断,如果是上海期货的合约则自动平今 if (info->getExchangeId() == "SHFE"){ splitSHFEOrder(newOrder, "0"); //限价单标志0 return; } } //执行指令 executeOrder(newOrder, "0"); }
void BooksDBUtil::removeAllTags(shared_ptr<Book> book) { book->removeAllTags(); }
void BooksDBUtil::cloneTag(shared_ptr<Book> book, shared_ptr<Tag> from, shared_ptr<Tag> to, bool includeSubTags) { if (book->cloneTag(from, to, includeSubTags)) { BooksDB::Instance().saveTags(book); } }
void print_trigger_effs(const shared_ptr<ProcessHistograms> & ph, const string & selection){ auto h = ph->get_histogram(selection, "lepton_trigger"); cout << "lepton trigger efficiency (w.r.t. offline lepton selection): " << h.histo->GetBinContent(2) / (h.histo->GetBinContent(1) + h.histo->GetBinContent(2)) << endl; h = ph->get_histogram(selection, "lepton_triggermatch"); cout << "lepton trigger matching efficiency (after offline selection and trigger): " << h.histo->GetBinContent(2) / (h.histo->GetBinContent(1) + h.histo->GetBinContent(2))<< endl; }
void UIFrame::addElement(shared_ptr<UIElement> el) { el->setParent(this); el->setZlevel(_zlevel + 1); _elements.push_back(el); }
void dump_histo(const shared_ptr<ProcessHistograms> & ph, const string & selection, const string & hname){ auto h = ph->get_histogram(selection, hname); for(int i=1; i<=h.histo->GetNbinsX(); ++i){ cout << i << " (" << h.histo->GetXaxis()->GetBinLowEdge(i) << "--" << h.histo->GetXaxis()->GetBinUpEdge(i) << ")" << h.histo->GetBinContent(i) << endl; } }
//---------- shared_ptr<NodeHost> Patch::addNewNode(shared_ptr<BaseFactory> factory, const ofRectangle & bounds) { auto newNode = factory->makeUntyped(); newNode->init(); return this->addNode(newNode, bounds); }
void DecodeTrace::create_decoder_form(int index, shared_ptr<data::decode::Decoder> &dec, QWidget *parent, QFormLayout *form) { const GSList *l; assert(dec); const srd_decoder *const decoder = dec->decoder(); assert(decoder); const bool decoder_deletable = index > 0; pv::widgets::DecoderGroupBox *const group = new pv::widgets::DecoderGroupBox( QString::fromUtf8(decoder->name), nullptr, decoder_deletable); group->set_decoder_visible(dec->shown()); if (decoder_deletable) { delete_mapper_.setMapping(group, index); connect(group, SIGNAL(delete_decoder()), &delete_mapper_, SLOT(map())); } show_hide_mapper_.setMapping(group, index); connect(group, SIGNAL(show_hide_decoder()), &show_hide_mapper_, SLOT(map())); QFormLayout *const decoder_form = new QFormLayout; group->add_layout(decoder_form); // Add the mandatory channels for (l = decoder->channels; l; l = l->next) { const struct srd_channel *const pdch = (struct srd_channel *)l->data; QComboBox *const combo = create_channel_selector(parent, dec, pdch); connect(combo, SIGNAL(currentIndexChanged(int)), this, SLOT(on_channel_selected(int))); decoder_form->addRow(tr("<b>%1</b> (%2) *") .arg(QString::fromUtf8(pdch->name)) .arg(QString::fromUtf8(pdch->desc)), combo); const ChannelSelector s = {combo, dec, pdch}; channel_selectors_.push_back(s); } // Add the optional channels for (l = decoder->opt_channels; l; l = l->next) { const struct srd_channel *const pdch = (struct srd_channel *)l->data; QComboBox *const combo = create_channel_selector(parent, dec, pdch); connect(combo, SIGNAL(currentIndexChanged(int)), this, SLOT(on_channel_selected(int))); decoder_form->addRow(tr("<b>%1</b> (%2)") .arg(QString::fromUtf8(pdch->name)) .arg(QString::fromUtf8(pdch->desc)), combo); const ChannelSelector s = {combo, dec, pdch}; channel_selectors_.push_back(s); } // Add the options shared_ptr<binding::Decoder> binding( new binding::Decoder(decoder_stack_, dec)); binding->add_properties_to_form(decoder_form, true); bindings_.push_back(binding); form->addRow(group); decoder_forms_.push_back(group); }
void MVLobbyState::render(shared_ptr<MVPlayer> player) const { player->writeLine(MVEnum::messageToString(MVEnum::WAITING_FOR_PLAYER)); }
int operator++ () { std::unique_lock<std::mutex> lck(*mtx_); ++(*count_); cv_->notify_all(); }
regex_byref_matcher(shared_ptr<regex_impl<BidiIter> > const &impl) : wimpl_(impl) , pimpl_(impl.get()) { BOOST_ASSERT(this->pimpl_); }
/*! Iphys functor */ void Ip2_FreshConcreteMat_FreshConcreteMat_FreshConcretePhys::go( const shared_ptr<Material>& b1 , const shared_ptr<Material>& b2 , const shared_ptr<Interaction>& interaction){ if(interaction->phys) return; FreshConcreteMat* mat1 = static_cast<FreshConcreteMat*>(b1.get()); FreshConcreteMat* mat2 = static_cast<FreshConcreteMat*>(b2.get()); Real mass1 = 1.0; Real mass2 = 1.0; mass1=Body::byId(interaction->getId1())->state->mass; mass2=Body::byId(interaction->getId2())->state->mass; //Rheological parameters for the external core const Real kn1 = mat1->kn*mass1; const Real cn1 = mat1->cn*mass1; const Real ks1 = mat1->ks*mass1; const Real cs1 = mat1->cs*mass1; const Real kn2 = mat2->kn*mass2; const Real cn2 = mat2->cn*mass2; const Real ks2 = mat2->ks*mass2; const Real cs2 = mat2->cs*mass2; //Rheological parameters for the inner core const Real knI1 = mat1->knI*mass1; const Real cnI1 = mat1->cnI*mass1; const Real ksI1 = mat1->ksI*mass1; const Real csI1 = mat1->csI*mass1; const Real knI2 = mat2->knI*mass2; const Real cnI2 = mat2->cnI*mass2; const Real ksI2 = mat2->ksI*mass2; const Real csI2 = mat2->csI*mass2; FreshConcretePhys* phys = new FreshConcretePhys(); //Rheological parameters for the external core if ((kn1>0) or (kn2>0)) { phys->kn = 1/( ((kn1>0)?1/kn1:0) + ((kn2>0)?1/kn2:0) ); } else { phys->kn = 0; } if ((ks1>0) or (ks2>0)) { phys->ks = 1/( ((ks1>0)?1/ks1:0) + ((ks2>0)?1/ks2:0) ); } else { phys->ks = 0; } phys->cn = (cn1?1/cn1:0) + (cn2?1/cn2:0); phys->cn = phys->cn?1/phys->cn:0; phys->cs = (cs1?1/cs1:0) + (cs2?1/cs2:0); phys->cs = phys->cs?1/phys->cs:0; phys->tangensOfFrictionAngle = std::tan(std::min(mat1->frictionAngle, mat2->frictionAngle)); phys->shearForce = Vector3r(0,0,0); //Rheological parameters for the inner core if ((knI1>0) or (knI2>0)) { phys->knI = 1/( ((knI1>0)?1/knI1:0) + ((knI2>0)?1/knI2:0) ); } else { phys->knI = 0; } if ((ksI1>0) or (ksI2>0)) { phys->ksI = 1/( ((ksI1>0)?1/ksI1:0) + ((ksI2>0)?1/ksI2:0) ); } else { phys->ksI = 0; } phys->cnI = (cnI1?1/cnI1:0) + (cnI2?1/cnI2:0); phys->cnI = phys->cnI?1/phys->cnI:0; phys->csI = (csI1?1/csI1:0) + (csI2?1/csI2:0); phys->csI = phys->csI?1/phys->csI:0; phys->tangensOfFrictionAngleI = std::tan(std::min(mat1->frictionAngleI, mat2->frictionAngleI)); phys->shearForceI = Vector3r(0,0,0); phys->Penetration1=mat1->SecPhaseThickness; phys->Penetration2=mat2->SecPhaseThickness; interaction->phys = shared_ptr<FreshConcretePhys>(phys); }
void TimelineLayoutHelper::apply_drop_to_modelTree (TimelineLayoutHelper::DropPoint const& drop) { if(drop.relation == None) return; const shared_ptr<model::Sequence> sequence = get_sequence(); // Freeze the timeline widget - it must be done manually later timelineWidget.freeze_update_tracks(); // Get the tracks shared_ptr<model::Track> &dragging_track = *draggingTrackIter; REQUIRE(dragging_track); REQUIRE(dragging_track != sequence); shared_ptr<model::Track> &target_track = *drop.target; REQUIRE(target_track); REQUIRE(target_track != sequence); // Detach the track from the old parent shared_ptr<model::ParentTrack> old_parent = sequence->find_descendant_track_parent(dragging_track); REQUIRE(old_parent); // The track must have a parent old_parent->get_child_track_list().remove(dragging_track); if (drop.relation == Before || drop.relation == After) { // Find the new parent track shared_ptr<model::ParentTrack> new_parent = sequence->find_descendant_track_parent(target_track); REQUIRE(new_parent); // The track must have a parent // Find the destination point observable_list< shared_ptr<model::Track> > &dest = new_parent->get_child_track_list(); list< shared_ptr<model::Track> >::iterator iter; for (iter = dest.begin(); iter != dest.end(); iter++) { if(*iter == target_track) break; } REQUIRE(iter != dest.end()); // The target must be // in the destination // We have to jump on 1 if we want to insert after if(drop.relation == After) iter++; // Insert at this point dest.insert(iter, dragging_track); } else if (drop.relation == FirstChild || drop.relation == LastChild) { shared_ptr<model::ParentTrack> new_parent = dynamic_pointer_cast<model::ParentTrack, model::Track>( target_track); REQUIRE(new_parent); // The track must have a parent if (drop.relation == FirstChild) new_parent->get_child_track_list().push_front(dragging_track); else if (drop.relation == LastChild) new_parent->get_child_track_list().push_back(dragging_track); } else ASSERT(0); // Unexpected value of relation // Thaw the timeline widget timelineWidget.thaw_update_tracks(); }
//-------------------------------------------------------------- static bool shouldRemove(shared_ptr<ofxBox2dBaseShape>shape) { return !ofRectangle(0, -400, ofGetWidth(), ofGetHeight()+400).inside(shape->getPosition()); }
void get_handler( const shared_ptr< Session > session ) { session->close( OK, "OK", { { "Connection", "close" } } ); }
void error_handler( const int, const exception&, const shared_ptr< Session > session ) { session->close( 0, "I see nothing!", { { "Content-Length", "14" } } ); }
void head_handler( const shared_ptr< Session >& session ) { session->close( 200, "Hello, World!", { { "Content-Length", "13" }, { "Connection", "close" } } ); }
bool SignatureAdder::SetSignature(shared_ptr<Message> pMessage, shared_ptr<const Domain> pSenderDomain, shared_ptr<const Account> pSenderAccount, shared_ptr<MessageData> &pMessageData) //---------------------------------------------------------------------------() // DESCRIPTION: // Sets the signature of the message, based on the signature in the account // settings and domain settings. //---------------------------------------------------------------------------() { if (!pMessage) { // Input error return false; } if (!pSenderDomain) { // Not a local sender - nothing to do. return false; } if (!pSenderDomain->GetAddSignaturesToLocalMail() && _GetMessageIsLocal(pMessage)) { // The message is local, but we have configured // the server not to add signatures to local email. return false; } String sSignaturePlainText; String sSignatureHTML; // First check if an account signature has been specified. if (pSenderAccount && pSenderAccount->GetEnableSignature()) { sSignaturePlainText = pSenderAccount->GetSignaturePlainText(); sSignatureHTML = pSenderAccount->GetSignatureHTML(); if (!sSignaturePlainText.IsEmpty() && sSignatureHTML.IsEmpty()) { // Plain text specified but not HTML. Copy plain text to HTML. sSignatureHTML = sSignaturePlainText; sSignatureHTML.Replace(_T("\r\n"), _T("<br>\r\n")); } } if (pSenderDomain->GetEnableSignature()) { String sDomainPlainText = pSenderDomain->GetSignaturePlainText(); String sDomainHTML = pSenderDomain->GetSignatureHTML(); if (!sDomainPlainText.IsEmpty() && sDomainHTML.IsEmpty()) { // Plain text specified but not HTML. Copy plain text to HTML. sDomainHTML = sDomainPlainText; sDomainHTML.Replace(_T("\r\n"), _T("<br>\r\n")); } // Check if we should overwrite the account signature with the // domain signature, if we should append it, or if we just should // keep it. if (pSenderDomain->GetSignatureMethod() == HM::Domain::SMSetIfNotSpecifiedInAccount) { if (sSignaturePlainText.IsEmpty()) sSignaturePlainText = sDomainPlainText; if (sSignatureHTML.IsEmpty()) sSignatureHTML = sDomainHTML; } else if (pSenderDomain->GetSignatureMethod() == HM::Domain::SMAppendToAccountSignature) { sSignaturePlainText += "\r\n\r\n" + sDomainPlainText; sSignatureHTML += "<br><br>" + sDomainHTML; } else if (pSenderDomain->GetSignatureMethod() == HM::Domain::SMOverwriteAccountSignature) { sSignaturePlainText = sDomainPlainText; sSignatureHTML = sDomainHTML; } } if (sSignaturePlainText.IsEmpty() && sSignatureHTML.IsEmpty()) { // No signature should be created. return false; } // A signature should be created. if (!pMessageData) { pMessageData = shared_ptr<MessageData>(new MessageData()); shared_ptr<Account> emptyAccount; if (!pMessageData->LoadFromMessage(emptyAccount, pMessage)) return false; } if (!pSenderDomain->GetAddSignaturesToReplies() && _GetMessageIsReply(pMessageData)) { // The message is a reply, but we have configured the // server not to add signatures to replies return false; } String sCurrentBodyPlainText = pMessageData->GetBody(); String sCurrentBodyHTML = pMessageData->GetHTMLBody(); if (!sSignaturePlainText.IsEmpty()) sCurrentBodyPlainText += "\r\n" + sSignaturePlainText; if (!sCurrentBodyHTML.IsEmpty() && !sSignatureHTML.IsEmpty()) sCurrentBodyHTML += "<br>" + sSignatureHTML; if (pSenderAccount) { sCurrentBodyPlainText.ReplaceNoCase(_T("%User.FirstName%"), pSenderAccount->GetPersonFirstName()); sCurrentBodyPlainText.ReplaceNoCase(_T("%User.LastName%"), pSenderAccount->GetPersonLastName()); sCurrentBodyHTML.ReplaceNoCase(_T("%User.FirstName%"), pSenderAccount->GetPersonFirstName()); sCurrentBodyHTML.ReplaceNoCase(_T("%User.LastName%"), pSenderAccount->GetPersonLastName()); } if (!sCurrentBodyPlainText.IsEmpty() && pMessageData->GetHasBodyType("text/plain")) pMessageData->SetBody(sCurrentBodyPlainText); if (!sCurrentBodyHTML.IsEmpty() && pMessageData->GetHasBodyType("text/html")) pMessageData->SetHTMLBody(sCurrentBodyHTML); return true; }
void io_chain_t::push_back(const shared_ptr<io_data_t> &element) { // Ensure we never push back NULL assert(element.get() != NULL); std::vector<shared_ptr<io_data_t> >::push_back(element); }