std::time_t vishnu::string_lc_to_utc_time_t(const std::string& ts,const std::string& utcOffset) { // two aliases for convenience namespace bps= boost::posix_time; namespace bg=boost::gregorian; namespace blt=boost::local_time; std::cout << " convert " << ts << " " << utcOffset << " in utc time\n"; boost::local_time::time_zone_ptr tz(new boost::local_time::posix_time_zone(utcOffset)); bps::ptime t; if (std::string::npos==ts.find(":")){ t=bps::ptime(bg::from_string(ts)); } else{ t= bps::ptime (bps::time_from_string(ts)); } bps::ptime epoch(bg::date(1970,1,1)); blt::local_date_time ldt(t.date(), t.time_of_day(),tz,blt::local_date_time::NOT_DATE_TIME_ON_ERROR); bps::time_duration::sec_type x = (ldt.utc_time() - epoch).total_seconds(); return std::time_t(x); }
void LClock::LocaleChange(){ //Refresh all the time zone information TZMenu->clear(); TZMenu->addAction(tr("Use System Time")); TZMenu->addSeparator(); QList<QByteArray> TZList = QTimeZone::availableTimeZoneIds(); //Orgnize time zones for smaller menus (Continent/Country/City) // Note: id = Continent/City QStringList info; for(int i=0; i<TZList.length(); i++){ QTimeZone tz(TZList[i]); if(!QString(tz.id()).contains("/")){ continue; } info << "::::"+QString(tz.id()).section("/",0,0)+"::::"+QLocale::countryToString(tz.country())+"::::"+QString(tz.id()).section("/",1,100).replace("_"," ")+"::::"+QString(tz.id()); } //Now sort alphabetically info.sort(); //Now create the menu tree QString continent, country; //current continent/country QMenu *tmpC=0; //continent menu QMenu *tmpCM=0; //country menu for(int i=0; i<info.length(); i++){ //Check if different continent if(info[i].section("::::",1,1)!=continent){ if(tmpC!=0){ if(tmpCM!=0 && !tmpCM->isEmpty()){ tmpC->addMenu(tmpCM); } if(!tmpC->isEmpty()){ TZMenu->addMenu(tmpC); } } tmpC = new QMenu(this); tmpC->setTitle(info[i].section("::::",1,1)); tmpCM = new QMenu(this); tmpCM->setTitle(info[i].section("::::",2,2)); //Check if different country }else if(info[i].section("::::",2,2)!=country){ if(tmpC!=0 && tmpCM!=0 && !tmpCM->isEmpty()){ tmpC->addMenu(tmpCM); } tmpCM = new QMenu(this); tmpCM->setTitle(info[i].section("::::",2,2)); } //Now create the entry within the country menu if(tmpCM!=0){ QAction *act = new QAction(info[i].section("::::",3,3), this); act->setWhatsThis(info[i].section("::::",4,4) ); tmpCM->addAction(act); } //Save the values for the next run continent = info[i].section("::::",1,1); country = info[i].section("::::",2,2); if(i== info.length()-1){ //last go through - save all menus if(tmpCM!=0 && tmpC!=0 && !tmpCM->isEmpty()){ tmpC->addMenu(tmpCM); } if(tmpC!=0 && !tmpC->isEmpty()){ TZMenu->addMenu(tmpC); } } } }
int ONVIF::SystemDateAndTime::qt_metacall(QMetaObject::Call _c, int _id, void **_a) { _id = QObject::qt_metacall(_c, _id, _a); if (_id < 0) return _id; if (_c == QMetaObject::InvokeMetaMethod) { if (_id < 6) qt_static_metacall(this, _c, _id, _a); _id -= 6; } else if (_c == QMetaObject::RegisterMethodArgumentMetaType) { if (_id < 6) *reinterpret_cast<int*>(_a[0]) = -1; _id -= 6; } #ifndef QT_NO_PROPERTIES else if (_c == QMetaObject::ReadProperty) { void *_v = _a[0]; switch (_id) { case 0: *reinterpret_cast< DateTimeType*>(_v) = dateTimeType(); break; case 1: *reinterpret_cast< bool*>(_v) = daylightSavings(); break; case 2: *reinterpret_cast< QString*>(_v) = tz(); break; case 3: *reinterpret_cast< QDateTime*>(_v) = utcTime(); break; case 4: *reinterpret_cast< QDateTime*>(_v) = localTime(); break; case 5: *reinterpret_cast< bool*>(_v) = result(); break; default: break; } _id -= 6; } else if (_c == QMetaObject::WriteProperty) { void *_v = _a[0]; switch (_id) { case 0: setDateTimeType(*reinterpret_cast< DateTimeType*>(_v)); break; case 1: setDaylightSavings(*reinterpret_cast< bool*>(_v)); break; case 2: setTz(*reinterpret_cast< QString*>(_v)); break; case 3: setutcTime(*reinterpret_cast< QDateTime*>(_v)); break; case 4: setlocalTime(*reinterpret_cast< QDateTime*>(_v)); break; case 5: setResult(*reinterpret_cast< bool*>(_v)); break; default: break; } _id -= 6; } else if (_c == QMetaObject::ResetProperty) { _id -= 6; } else if (_c == QMetaObject::QueryPropertyDesignable) { _id -= 6; } else if (_c == QMetaObject::QueryPropertyScriptable) { _id -= 6; } else if (_c == QMetaObject::QueryPropertyStored) { _id -= 6; } else if (_c == QMetaObject::QueryPropertyEditable) { _id -= 6; } else if (_c == QMetaObject::QueryPropertyUser) { _id -= 6; } else if (_c == QMetaObject::RegisterPropertyMetaType) { if (_id < 6) *reinterpret_cast<int*>(_a[0]) = -1; _id -= 6; } #endif // QT_NO_PROPERTIES return _id; }
void mmReportBudget::SetBudgetMonth(wxString budgetYearStr, wxDateTime& startDate, wxDateTime& endDate) const { wxStringTokenizer tz(budgetYearStr,"-"); wxString yearStr = tz.GetNextToken(); wxString monthStr = tz.GetNextToken(); int month = wxAtoi(monthStr) - 1; startDate.SetMonth((wxDateTime::Month)month); SetDateToEndOfMonth(month,endDate); }
/* Update a single route segment lengths Also, compute total route length by summing segment distances. */ void Route::UpdateSegmentDistance( RoutePoint *prp0, RoutePoint *prp, double planspeed ) { double slat1 = prp0->m_lat, slon1 = prp0->m_lon; double slat2 = prp->m_lat, slon2 = prp->m_lon; // Calculate the absolute distance from 1->2 double dd; // why are we using mercator rather than great circle here?? [sean 8-11-2015] DistanceBearingMercator( slat1, slon1, slat2, slon2, 0, &dd ); // And store in Point 2 prp->m_seg_len = dd; m_route_length += dd; // If Point1 Description contains VMG, store it for Properties Dialog in Point2 // If Point1 Description contains ETD, store it in Point1 if( planspeed > 0. ) { double vmg = 0.0; wxDateTime etd; if( prp0->m_MarkDescription.Find( _T("VMG=") ) != wxNOT_FOUND ) { wxString s_vmg = ( prp0->m_MarkDescription.Mid( prp0->m_MarkDescription.Find( _T("VMG=") ) + 4 ) ).BeforeFirst( ';' ); if( !s_vmg.ToDouble( &vmg ) ) vmg = planspeed; } double legspeed = planspeed; if( vmg > 0.1 && vmg < 1000. ) legspeed = vmg; if( legspeed > 0.1 && legspeed < 1000. ) { m_route_time += 3600. * dd / legspeed; prp->m_seg_vmg = legspeed; } prp0->m_seg_etd = wxInvalidDateTime; if( prp0->m_MarkDescription.Find( _T("ETD=") ) != wxNOT_FOUND ) { wxString s_etd = ( prp0->m_MarkDescription.Mid( prp0->m_MarkDescription.Find( _T("ETD=") ) + 4 ) ).BeforeFirst( ';' ); const wxChar *parse_return = etd.ParseDateTime( s_etd ); if( parse_return ) { wxString tz( parse_return ); if( tz.Find( _T("UT") ) != wxNOT_FOUND ) prp0->m_seg_etd = etd; else if( tz.Find( _T("LMT") ) != wxNOT_FOUND ) { prp0->m_seg_etd = etd; long lmt_offset = (long) ( ( prp0->m_lon * 3600. ) / 15. ); wxTimeSpan lmt( 0, 0, (int) lmt_offset, 0 ); prp0->m_seg_etd -= lmt; } else prp0->m_seg_etd = etd.ToUTC(); } } } }
bool MrPlotter::setTimeZone(QByteArray timezone) { QTimeZone tz(timezone); if (!tz.isValid()) { return false; } this->timeaxis.setTimeZone(tz); return false; }
inline auto make_parameter_memory_pair( onnx::NodeProto const& node, int param_index, mkldnn::memory::format format, std::unordered_map<std::string, instant::array> const& parameter_table, mkldnn::engine const& engine) { auto const& name = node.input(param_index); auto const& arr = find_value(parameter_table, name); mkldnn::memory::dims tz(arr.dims().begin(), arr.dims().end()); auto mem = mkldnn::memory( {{{tz}, mkldnn::memory::data_type::f32, format}, engine}, const_cast<void*>(arr.data())); return std::make_pair(name, mem); }
static void init_env (void) { #ifndef USE_PAM char *cp; #endif char *tmp; tmp = getenv ("LANG"); if (NULL != tmp) { addenv ("LANG", tmp); } /* * Add the timezone environmental variable so that time functions * work correctly. */ tmp = getenv ("TZ"); if (NULL != tmp) { addenv ("TZ", tmp); } #ifndef USE_PAM else { cp = getdef_str ("ENV_TZ"); if (NULL != cp) { addenv (('/' == *cp) ? tz (cp) : cp, NULL); } } #endif /* !USE_PAM */ /* * Add the clock frequency so that profiling commands work * correctly. */ tmp = getenv ("HZ"); if (NULL != tmp) { addenv ("HZ", tmp); } #ifndef USE_PAM else { cp = getdef_str ("ENV_HZ"); if (NULL != cp) { addenv (cp, NULL); } } #endif /* !USE_PAM */ }
void Fractal::Mandel2Init (void) { static const char *info[] = { "\ebMandelbrot set for\eb", mandel2_size, (const char *) mandel2_bits, "", "", "The image plane of the complex valued parameter \etmu\et", "with Re=(x1..x2) and Im=(y1..y2) is drawn.", "The complex start value \etz(0)\et of the iteration can be", "set in the Args(Re,Im) field (default is 0).", NULL }; Info = info; FractalMethod = &Fractal::Mandel2; xLo = -2.5, xHi = 1.5; yLo = -1.5; yHi = 1.5; xParm = yParm = 0; // usually start with z(0) = (0,0) }
//--------------------------------------------------------- void NDG3D::Normals3D() //--------------------------------------------------------- { // function [nx, ny, nz, sJ] = Normals3D() // Purpose : Compute outward pointing normals at // elements faces as well as surface Jacobians GeometricFactors3D(); // interpolate geometric factors to face nodes DMat frx=rx(Fmask,All), fsx=sx(Fmask,All), ftx=tx(Fmask,All); DMat fry=ry(Fmask,All), fsy=sy(Fmask,All), fty=ty(Fmask,All); DMat frz=rz(Fmask,All), fsz=sz(Fmask,All), ftz=tz(Fmask,All); // build normals nx.resize(4*Nfp, K); ny.resize(4*Nfp, K); nz.resize(4*Nfp, K); Index1D fid1(1,Nfp), fid2(Nfp+1,2*Nfp), fid3(2*Nfp+1,3*Nfp), fid4(3*Nfp+1,4*Nfp); // face 1 nx(fid1, All) = -ftx(fid1,All); ny(fid1, All) = -fty(fid1,All); nz(fid1, All) = -ftz(fid1,All); // face 2 nx(fid2, All) = -fsx(fid2,All); ny(fid2, All) = -fsy(fid2,All); nz(fid2, All) = -fsz(fid2,All); // face 3 nx(fid3, All) = frx(fid3,All) + fsx(fid3,All) + ftx(fid3,All); ny(fid3, All) = fry(fid3,All) + fsy(fid3,All) + fty(fid3,All); nz(fid3, All) = frz(fid3,All) + fsz(fid3,All) + ftz(fid3,All); // face 4 nx(fid4, All) = -frx(fid4,All); ny(fid4, All) = -fry(fid4,All); nz(fid4, All) = -frz(fid4,All); // normalise sJ = sqrt(sqr(nx) + sqr(ny) + sqr(nz)); nx.div_element(sJ); ny.div_element(sJ); nz.div_element(sJ); sJ.mult_element(J(Fmask, All)); //sJ=sJ.*J(Fmask(:),:); }
inline auto make_variable_memory_table( std::vector<std::tuple<std::string, instant::array, mkldnn::memory::format>>& input_list, mkldnn::engine const& engine) { std::unordered_map< std::string, std::tuple<const mkldnn::memory, mkldnn::memory::format>> memory_table; for(auto& input : input_list) { auto& arr = std::get<1>(input); auto format = std::get<2>(input); mkldnn::memory::dims tz(arr.dims().begin(), arr.dims().end()); auto mem = mkldnn::memory( {{{tz}, mkldnn::memory::data_type::f32, format}, engine}, arr.data()); auto const& name = std::get<0>(input); memory_table.insert({name, std::make_tuple(mem, format)}); } return memory_table; }
void read_temperature(VectorScalar &T0, VectorScalar &Tz, const std::string &file) { T0.clear(); Tz.clear(); std::string line; std::ifstream temp(file); getline(temp,line); while(!temp.eof()) { Scalar t(0.),tz(0.); temp >> t >> tz; if(temp.good()) { T0.push_back(t); Tz.push_back(tz); } } temp.close(); return; }
void ZDAmsg::setMsg(std::string msg){ boost::regex reg("^(\\d{2})(\\d{2})(\\d{2})(\\.\\d{1,3})?,(\\d{2}),(\\d{2}),(\\d{4}),(\\d{2}),(\\d{2})$"); boost::cmatch matches; if(boost::regex_search(msg.c_str(), matches, reg)){ std::string ts(matches[MATCH_YEAR]+"-"+matches[MATCH_MONTH]+"-"+matches[MATCH_DAY]+" "+matches[MATCH_HOUR]+":"+matches[MATCH_MINUTE]+":"+matches[MATCH_SECOND]+matches[MATCH_SUBSECOND]); try{ std::string sign = (boost::lexical_cast<int>(matches[MATCH_ZONE_HOURS])>=0?"+":"-"); std::string tz("UTC"+sign+matches[MATCH_ZONE_HOURS]+":"+matches[MATCH_ZONE_MINUTES]); zone = boost::local_time::posix_time_zone(tz); time_date = boost::posix_time::time_from_string(ts); } catch(const boost::bad_lexical_cast&){ std::cerr << "Problem with command format. Cannot parse date:" << ts << std::endl; return; } } else{ throw std::invalid_argument("Cannot parse RMC message!"); } }
void DateTimeTester::timeZones() { QByteArray tz("TZ=Europe/Copenhagen"); putenv(tz.data()); QTimeZone testZone("Europe/London"); DateTime dt1(QDate(2006, 1, 1), QTime(8, 0, 0, 0 ), testZone); DateTime dt2 = dt1; qDebug()<<dt1<<dt2; QCOMPARE(dt1.timeZone(), dt2.timeZone()); dt2 += Duration(1, 0, 0, 0, 0); qDebug()<<dt2; QCOMPARE(dt1.timeZone(), dt2.timeZone()); dt2 -= Duration(1, 0, 0, 0, 0); qDebug()<<dt1<<dt2; QCOMPARE(dt1.timeZone(), dt2.timeZone()); QCOMPARE(dt2, dt1); dt2 = dt1 + Duration(1, 0, 0, 0, 0); qDebug()<<dt1<<dt2; QCOMPARE(dt1.timeZone(), dt2.timeZone()); dt2 = dt2 - Duration(1, 0, 0, 0, 0); qDebug()<<dt1<<dt2; QCOMPARE(dt1.timeZone(), dt2.timeZone()); QCOMPARE(dt2, dt1); DateTime dt3 = QDateTime(QDate(2006, 1, 1), QTime(8, 0, 0, 0 ), testZone); qDebug()<<dt3; QCOMPARE(dt3.timeZone(), testZone); DateTime dt4(QDateTime(QDate(2006, 1, 1), QTime(8, 0, 0, 0 ), Qt::UTC)); dt4 += Duration(1, 0, 0, 0, 0); qDebug()<<dt4; QCOMPARE(dt4.timeSpec(), Qt::UTC); }
wxDateTime RoutePoint::GetETD() { if( m_seg_etd.IsValid() ) { if(!GetETA().IsValid() || m_seg_etd > GetETA()) { return m_seg_etd; } else { return GetETA(); } } else { if( m_MarkDescription.Find( _T("ETD=") ) != wxNOT_FOUND ) { wxDateTime etd = wxInvalidDateTime; wxString s_etd = ( m_MarkDescription.Mid(m_MarkDescription.Find( _T("ETD=") ) + 4 ) ).BeforeFirst( ';' ); const wxChar *parse_return = etd.ParseDateTime( s_etd ); if( parse_return ) { wxString tz( parse_return ); if( tz.Find( _T("UT") ) != wxNOT_FOUND ) { m_seg_etd = etd; } else { if( tz.Find( _T("LMT") ) != wxNOT_FOUND ) { m_seg_etd = etd; long lmt_offset = (long) ( ( m_lon * 3600. ) / 15. ); wxTimeSpan lmt( 0, 0, (int) lmt_offset, 0 ); m_seg_etd -= lmt; } else { m_seg_etd = etd.ToUTC(); } } if( etd.IsValid() && (!GetETA().IsValid() || etd > GetETA()) ) { m_MarkDescription.Replace( s_etd, wxEmptyString); m_seg_etd = etd; return m_seg_etd; } else { return GetETA(); } } } } return wxInvalidDateTime; }
icu::TimeZone *get_time_zone(std::string const &time_zone) { if(!time_zone.empty()) { return icu::TimeZone::createTimeZone(time_zone.c_str()); } std::auto_ptr<icu::TimeZone> tz(icu::TimeZone::createDefault()); icu::UnicodeString id; tz->getID(id); // Check if there is a bug? if(id != icu::UnicodeString("localtime")) return tz.release(); // Now let's deal with the bug and run the fixed // search loop as that of ICU std::string real_id = get_time_zone_name(); if(real_id.empty()) { // if we failed fallback to ICU's time zone return tz.release(); } return icu::TimeZone::createTimeZone(real_id.c_str()); }
static jstring TimeZoneNames_getExemplarLocation(JNIEnv* env, jclass, jstring javaLocaleName, jstring javaTz) { ScopedIcuLocale icuLocale(env, javaLocaleName); if (!icuLocale.valid()) { return NULL; } UErrorCode status = U_ZERO_ERROR; UniquePtr<TimeZoneNames> names(TimeZoneNames::createInstance(icuLocale.locale(), status)); if (maybeThrowIcuException(env, "TimeZoneNames::createInstance", status)) { return NULL; } ScopedJavaUnicodeString tz(env, javaTz); if (!tz.valid()) { return NULL; } UnicodeString s; const UDate now(Calendar::getNow()); names->getDisplayName(tz.unicodeString(), UTZNM_EXEMPLAR_LOCATION, now, s); return env->NewString(s.getBuffer(), s.length()); }
long inst(long dat,long pp,long b) { long s; s=0; if (p[b][pp]==0) { fre++; p[b][pp]=fre; f[fre]=pp; d[fre]=dat; ss[fre]=1; tz(fre); return 0; } pp=p[b][pp]; if (dat<d[pp]) { ss[pp]++; s+=inst(dat,pp,0); } else s+=(inst(dat,pp,1)+ss[pp]); return s; }
/* Update the route segment lengths, storing each segment length in <destination> point. Also, compute total route length by summing segment distances. */ void Route::UpdateSegmentDistances( double planspeed ) { wxPoint rpt, rptn; float slat1, slon1, slat2, slon2; double route_len = 0.0; double route_time = 0.0; wxRoutePointListNode *node = pRoutePointList->GetFirst(); if( node ) { RoutePoint *prp0 = node->GetData(); slat1 = prp0->m_lat; slon1 = prp0->m_lon; node = node->GetNext(); while( node ) { RoutePoint *prp = node->GetData(); slat2 = prp->m_lat; slon2 = prp->m_lon; // Calculate the absolute distance from 1->2 double brg, dd; DistanceBearingMercator( slat1, slon1, slat2, slon2, &brg, &dd ); // And store in Point 2 prp->m_seg_len = dd; route_len += dd; slat1 = slat2; slon1 = slon2; // If Point1 Description contains VMG, store it for Properties Dialog in Point2 // If Point1 Description contains ETD, store it in Point1 if( planspeed > 0. ) { double vmg = 0.0; wxDateTime etd; if( prp0->m_MarkDescription.Find( _T("VMG=") ) != wxNOT_FOUND ) { wxString s_vmg = ( prp0->m_MarkDescription.Mid( prp0->m_MarkDescription.Find( _T("VMG=") ) + 4 ) ).BeforeFirst( ';' ); if( !s_vmg.ToDouble( &vmg ) ) vmg = planspeed; } double legspeed = planspeed; if( vmg > 0.1 && vmg < 1000. ) legspeed = vmg; if( legspeed > 0.1 && legspeed < 1000. ) { route_time += dd / legspeed; prp->m_seg_vmg = legspeed; } prp0->m_seg_etd = wxInvalidDateTime; if( prp0->m_MarkDescription.Find( _T("ETD=") ) != wxNOT_FOUND ) { wxString s_etd = ( prp0->m_MarkDescription.Mid( prp0->m_MarkDescription.Find( _T("ETD=") ) + 4 ) ).BeforeFirst( ';' ); const wxChar *parse_return = etd.ParseDateTime( s_etd ); if( parse_return ) { wxString tz( parse_return ); if( tz.Find( _T("UT") ) != wxNOT_FOUND ) prp0->m_seg_etd = etd; else if( tz.Find( _T("LMT") ) != wxNOT_FOUND ) { prp0->m_seg_etd = etd; long lmt_offset = (long) ( ( prp0->m_lon * 3600. ) / 15. ); wxTimeSpan lmt( 0, 0, (int) lmt_offset, 0 ); prp0->m_seg_etd -= lmt; } else prp0->m_seg_etd = etd.ToUTC(); } } } prp0 = prp; node = node->GetNext(); } } m_route_length = route_len; m_route_time = route_time * 3600.; }
/* * Find the location of the zoneinfo files and store in mZoneinfoDir. * Parse zone.tab and for each time zone, create a KSystemTimeZone instance. */ void KSystemTimeZonesPrivate::readZoneTab(bool update) { kDebug(161) << "readZoneTab(" << m_zonetab<< ")"; QStringList newZones; QFile f; f.setFileName(m_zonetab); if (!f.open(QIODevice::ReadOnly)) return; QTextStream str(&f); QRegExp lineSeparator("[ \t]"); QRegExp ordinateSeparator("[+-]"); if (!m_source) m_source = new KSystemTimeZoneSource; while (!str.atEnd()) { QString line = str.readLine(); if (line.isEmpty() || line[0] == '#') continue; QStringList tokens = KStringHandler::perlSplit(lineSeparator, line, 4); int n = tokens.count(); if (n < 3) { kError(161) << "readZoneTab(): invalid record: " << line << endl; continue; } // Got three tokens. Now check for two ordinates plus first one is "". int i = tokens[1].indexOf(ordinateSeparator, 1); if (i < 0) { kError(161) << "readZoneTab() " << tokens[2] << ": invalid coordinates: " << tokens[1] << endl; continue; } float latitude = convertCoordinate(tokens[1].left(i)); float longitude = convertCoordinate(tokens[1].mid(i)); // Add entry to list. if (tokens[0] == "??") tokens[0] = ""; // Solaris sets the empty Comments field to '-', making it not empty. // Clean it up. if (n > 3 && tokens[3] == "-") tokens[3] = ""; KSystemTimeZone tz(m_source, tokens[2], tokens[0], latitude, longitude, (n > 3 ? tokens[3] : QString())); if (update) { // Update the existing collection with the new zone definition newZones += tz.name(); KTimeZone oldTz = zone(tz.name()); if (oldTz.isValid()) oldTz.updateBase(tz); // the zone previously existed, so update its definition else add(tz); // the zone didn't previously exist, so add it } else add(tz); } f.close(); if (update) { // Remove any zones from the collection which no longer exist const ZoneMap oldZones = zones(); for (ZoneMap::ConstIterator it = oldZones.constBegin(); it != oldZones.constEnd(); ++it) { if (newZones.indexOf(it.key()) < 0) remove(it.value()); } } }
/*ARGSUSED*/ int main (int argc, char **argv) { #ifndef USE_PAM const char *env; #endif /* !USE_PAM */ char **envp = environ; TERMIO termio; int err = 0; #ifdef USE_TERMIO ioctl (0, TCGETA, &termio); termio.c_iflag |= (ICRNL | IXON); termio.c_oflag |= (OPOST | ONLCR); termio.c_cflag |= (CREAD); termio.c_lflag |= (ISIG | ICANON | ECHO | ECHOE | ECHOK); ioctl (0, TCSETAF, &termio); #endif #ifdef USE_TERMIOS tcgetattr (0, &termio); termio.c_iflag |= (ICRNL | IXON); termio.c_oflag |= (CREAD); termio.c_lflag |= (ECHO | ECHOE | ECHOK | ICANON | ISIG); tcsetattr (0, TCSANOW, &termio); #endif Prog = Basename (argv[0]); (void) setlocale (LC_ALL, ""); (void) bindtextdomain (PACKAGE, LOCALEDIR); (void) textdomain (PACKAGE); #ifdef USE_SYSLOG OPENLOG ("sulogin"); #endif initenv (); if (argc > 1) { close (0); close (1); close (2); if (open (argv[1], O_RDWR) >= 0) { dup (0); dup (0); } else { #ifdef USE_SYSLOG SYSLOG (LOG_WARN, "cannot open %s\n", argv[1]); closelog (); #endif exit (1); } } if (access (PASSWD_FILE, F_OK) == -1) { /* must be a password file! */ (void) puts (_("No password file")); #ifdef USE_SYSLOG SYSLOG (LOG_WARN, "No password file\n"); closelog (); #endif exit (1); } #if !defined(DEBUG) && defined(SULOGIN_ONLY_INIT) if (getppid () != 1) { /* parent must be INIT */ #ifdef USE_SYSLOG SYSLOG (LOG_WARN, "Pid == %d, not 1\n", getppid ()); closelog (); #endif exit (1); } #endif if ((isatty (0) == 0) || (isatty (1) == 0) || (isatty (2) == 0)) { #ifdef USE_SYSLOG closelog (); #endif exit (1); /* must be a terminal */ } /* If we were init, we need to start a new session */ if (getppid() == 1) { setsid(); if (ioctl(0, TIOCSCTTY, 1) != 0) { (void) fputs (_("TIOCSCTTY failed"), stderr); } } while (NULL != *envp) { /* add inherited environment, */ addenv (*envp, NULL); /* some variables change later */ envp++; } #ifndef USE_PAM env = getdef_str ("ENV_TZ"); if (NULL != env) { addenv (('/' == *env) ? tz (env) : env, NULL); } env = getdef_str ("ENV_HZ"); if (NULL != env) { addenv (env, NULL); /* set the default $HZ, if one */ } #endif /* !USE_PAM */ (void) strcpy (name, "root"); /* KLUDGE!!! */ (void) signal (SIGALRM, catch_signals); /* exit if the timer expires */ (void) alarm (ALARM); /* only wait so long ... */ while (true) { /* repeatedly get login/password pairs */ char *cp; pw_entry (name, &pwent); /* get entry from password file */ if (pwent.pw_name == (char *) 0) { /* * Fail secure */ (void) puts (_("No password entry for 'root'")); #ifdef USE_SYSLOG SYSLOG (LOG_WARN, "No password entry for 'root'\n"); closelog (); #endif exit (1); } /* * Here we prompt for the root password, or if no password * is given we just exit. */ /* get a password for root */ cp = getpass (_( "\n" "Type control-d to proceed with normal startup,\n" "(or give root password for system maintenance):")); /* * XXX - can't enter single user mode if root password is * empty. I think this doesn't happen very often :-). But * it will work with standard getpass() (no NULL on EOF). * --marekm */ if ((NULL == cp) || ('\0' == *cp)) { #ifdef USE_SYSLOG SYSLOG (LOG_INFO, "Normal startup\n"); closelog (); #endif (void) puts (""); #ifdef TELINIT execl (PATH_TELINIT, "telinit", RUNLEVEL, (char *) 0); #endif exit (0); } else { STRFCPY (pass, cp); strzero (cp); } if (valid (pass, &pwent)) { /* check encrypted passwords ... */ break; /* ... encrypted passwords matched */ } #ifdef USE_SYSLOG SYSLOG (LOG_WARN, "Incorrect root password\n"); #endif sleep (2); (void) puts (_("Login incorrect")); } strzero (pass); (void) alarm (0); (void) signal (SIGALRM, SIG_DFL); environ = newenvp; /* make new environment active */ (void) puts (_("Entering System Maintenance Mode")); #ifdef USE_SYSLOG SYSLOG (LOG_INFO, "System Maintenance Mode\n"); #endif #ifdef USE_SYSLOG closelog (); #endif /* exec the shell finally. */ err = shell (pwent.pw_shell, (char *) 0, environ); return ((err == ENOENT) ? E_CMD_NOTFOUND : E_CMD_NOEXEC); }
//----------------------------------------------------------------------------- HADT MGL_EXPORT mgl_datac_subdata_ext(HCDT d, HCDT xx, HCDT yy, HCDT zz) { if(!xx || !yy || !zz) { mglData tmp; tmp.a[0]=-1; return mgl_datac_subdata_ext(d,xx?xx:&tmp,yy?yy:&tmp,zz?zz:&tmp); } long n=0,m=0,l=0,j,k; bool ix=false, iy=false, iz=false; if(xx->GetNz()>1) // 3d data { n = xx->GetNx(); m = xx->GetNy(); l = xx->GetNz(); j = yy->GetNN(); if(j>1 && j!=n*m*l) return 0; // wrong sizes k = zz->GetNN(); if(k>1 && k!=n*m*l) return 0; // wrong sizes ix = true; iy = j>1; iz = k>1; } else if(yy->GetNz()>1) { n = yy->GetNx(); m = yy->GetNy(); l = yy->GetNz(); j = xx->GetNN(); if(j>1 && j!=n*m*l) return 0; // wrong sizes k = zz->GetNN(); if(k>1 && k!=n*m*l) return 0; // wrong sizes iy = true; ix = j>1; iz = k>1; } else if(zz->GetNz()>1) { n = zz->GetNx(); m = zz->GetNy(); l = zz->GetNz(); j = yy->GetNN(); if(j>1 && j!=n*m*l) return 0; // wrong sizes k = xx->GetNN(); if(k>1 && k!=n*m*l) return 0; // wrong sizes iz = true; iy = j>1; ix = k>1; } else if(xx->GetNy()>1) // 2d data { n = xx->GetNx(); m = xx->GetNy(); l = 1; j = yy->GetNx()*yy->GetNy(); if(j>1 && j!=n*m) return 0; // wrong sizes k = zz->GetNx()*zz->GetNy(); if(k>1 && k!=n*m) return 0; // wrong sizes ix = true; iy = j>1; iz = k>1; } else if(yy->GetNy()>1) { n = yy->GetNx(); m = yy->GetNy(); l = 1; j = xx->GetNx()*xx->GetNy(); if(j>1 && j!=n*m) return 0; // wrong sizes k = zz->GetNx()*zz->GetNy(); if(k>1 && k!=n*m) return 0; // wrong sizes iy = true; ix = j>1; iz = k>1; } else if(zz->GetNy()>1) { n = zz->GetNx(); m = zz->GetNy(); l = 1; j = yy->GetNx()*yy->GetNy(); if(j>1 && j!=n*m) return 0; // wrong sizes k = xx->GetNx()*xx->GetNy(); if(k>1 && k!=n*m) return 0; // wrong sizes iz = true; iy = j>1; ix = k>1; } long nx=d->GetNx(),ny=d->GetNy(),nz=d->GetNz(); long vx=long(xx->v(0)), vy=long(yy->v(0)), vz=long(zz->v(0)); const mglDataC *dd = dynamic_cast<const mglDataC *>(d); if(n*m*l>1) // this is 2d or 3d data { mglDataV tx(n,m,l),ty(n,m,l),tz(n,m,l); if(!ix) { xx = &tx; if(vx>=0) tx.Fill(vx); else tx.All(); } if(!iy) { yy = &ty; if(vy>=0) ty.Fill(vy); else ty.All(); } if(!iz) { zz = &tz; if(vz>=0) tz.Fill(vz); else tz.All(); } mglDataC *r=new mglDataC(n,m,l); if(dd) #pragma omp parallel for for(long i0=0;i0<n*m*l;i0++) { register long x=long(0.5+xx->vthr(i0)), y=long(0.5+yy->vthr(i0)), z=long(0.5+zz->vthr(i0)); r->a[i0] = (x>=0 && x<nx && y>=0 && y<ny && z>=0 && z<nz)?dd->a[x+nx*(y+ny*z)]:NAN; } else #pragma omp parallel for for(long i0=0;i0<n*m*l;i0++) { register long x=long(0.5+xx->vthr(i0)), y=long(0.5+yy->vthr(i0)), z=long(0.5+zz->vthr(i0)); r->a[i0] = (x>=0 && x<nx && y>=0 && y<ny && z>=0 && z<nz)?d->v(x,y,z):NAN; } return r; } // this is 1d data -> try as normal SubData() mglDataV tx(nx),ty(ny),tz(nz); tx.Fill(0,nx-1); ty.Fill(0,ny-1); tz.Fill(0,nz-1); if(xx->GetNx()>1 || vx>=0) n=xx->GetNx(); else { n=nx; xx = &tx; } if(yy->GetNx()>1 || vy>=0) m=yy->GetNx(); else { m=ny; yy = &ty; } if(zz->GetNx()>1 || vz>=0) l=zz->GetNx(); else { l=nz; zz = &tz; } mglDataC *r=new mglDataC(n,m,l); if(dd) #pragma omp parallel for collapse(3) for(long k=0;k<l;k++) for(long j=0;j<m;j++) for(long i=0;i<n;i++) { register long x=long(0.5+xx->v(i)), y=long(0.5+yy->v(j)), z=long(0.5+zz->v(k)); r->a[i+n*(j+m*k)] = (x>=0 && x<nx && y>=0 && y<ny && z>=0 && z<nz)?dd->a[x+nx*(y+ny*z)]:NAN; } else #pragma omp parallel for collapse(3) for(long k=0;k<l;k++) for(long j=0;j<m;j++) for(long i=0;i<n;i++) { register long x=long(0.5+xx->v(i)), y=long(0.5+yy->v(j)), z=long(0.5+zz->v(k)); r->a[i+n*(j+m*k)] = (x>=0 && x<nx && y>=0 && y<ny && z>=0 && z<nz)?d->v(x,y,z):NAN; } if(m==1) { r->ny=r->nz; r->nz=1; }// "squeeze" dimensions if(n==1) { r->nx=r->ny; r->ny=r->nz; r->nz=1; r->NewId();} return r; }
// test wxDateTime -> text conversion void DateTimeTestCase::TestTimeFormat() { // some information may be lost during conversion, so store what kind // of info should we recover after a round trip enum CompareKind { CompareNone, // don't try comparing CompareBoth, // dates and times should be identical CompareYear, // don't compare centuries (fails for 2 digit years) CompareDate, // dates only CompareTime // time only }; static const struct { CompareKind compareKind; const char *format; } formatTestFormats[] = { { CompareYear, "---> %c" }, // %c could use 2 digit years { CompareDate, "Date is %A, %d of %B, in year %Y" }, { CompareYear, "Date is %x, time is %X" }, // %x could use 2 digits { CompareTime, "Time is %H:%M:%S or %I:%M:%S %p" }, { CompareNone, "The day of year: %j, the week of year: %W" }, { CompareDate, "ISO date without separators: %Y%m%d" }, { CompareBoth, "RFC 2822 string: %Y-%m-%d %H:%M:%S.%l %z" }, }; const long timeZonesOffsets[] = { wxDateTime::TimeZone(wxDateTime::Local).GetOffset(), // Fictitious TimeZone offsets to ensure time zone formating and // interpretation works -(3600 + 2*60), 3*3600 + 30*60 }; static const Date formatTestDates[] = { { 29, wxDateTime::May, 1976, 18, 30, 00, 0.0, wxDateTime::Inv_WeekDay }, { 31, wxDateTime::Dec, 1999, 23, 30, 00, 0.0, wxDateTime::Inv_WeekDay }, { 6, wxDateTime::Feb, 1937, 23, 30, 00, 0.0, wxDateTime::Inv_WeekDay }, { 6, wxDateTime::Feb, 1856, 23, 30, 00, 0.0, wxDateTime::Inv_WeekDay }, { 6, wxDateTime::Feb, 1857, 23, 30, 00, 0.0, wxDateTime::Inv_WeekDay }, { 29, wxDateTime::May, 2076, 18, 30, 00, 0.0, wxDateTime::Inv_WeekDay }, // FIXME: the test with 02:15:25 time doesn't pass because of DST // computation problems, we get back 03:15:25 { 29, wxDateTime::Feb, 2400, 04, 15, 25, 0.0, wxDateTime::Inv_WeekDay }, #if 0 // Need to add support for BCE dates. { 01, wxDateTime::Jan, -52, 03, 16, 47, 0.0, wxDateTime::Inv_WeekDay }, #endif }; for ( unsigned idxtz = 0; idxtz < WXSIZEOF(timeZonesOffsets); ++idxtz ) { wxDateTime::TimeZone tz(timeZonesOffsets[idxtz]); const bool isLocalTz = tz.GetOffset() == -wxGetTimeZone(); for ( size_t d = 0; d < WXSIZEOF(formatTestDates); d++ ) { wxDateTime dt = formatTestDates[d].DT(); for ( unsigned n = 0; n < WXSIZEOF(formatTestFormats); n++ ) { const char *fmt = formatTestFormats[n].format; // skip the check with %p for those locales which have empty AM/PM strings: // for those locales it's impossible to pass the test with %p... wxString am, pm; wxDateTime::GetAmPmStrings(&am, &pm); if (am.empty() && pm.empty() && wxStrstr(fmt, "%p") != NULL) continue; // what can we recover? CompareKind kind = formatTestFormats[n].compareKind; // When using a different time zone we must perform a time zone // conversion below which doesn't always work correctly, check // for the cases when it doesn't. if ( !isLocalTz ) { // DST computation doesn't work correctly for dates above // 2038 currently on the systems with 32 bit time_t. if ( dt.GetYear() >= 2038 ) continue; // We can't compare just dates nor just times when doing TZ // conversion as both are affected by the DST: for the // dates, the DST can switch midnight to 23:00 of the // previous day while for the times DST can be different // for the original date and today. if ( kind == CompareDate || kind == CompareTime ) continue; } // do convert date to string wxString s = dt.Format(fmt, tz); // convert back wxDateTime dt2; const char *result = dt2.ParseFormat(s, fmt); if ( !result ) { // conversion failed - should it have? WX_ASSERT_MESSAGE( ("Test #%u failed: failed to parse \"%s\"", n, s), kind == CompareNone ); } else // conversion succeeded { // currently ParseFormat() doesn't support "%Z" and so is // incapable of parsing time zone part used at the end of date // representations in many (but not "C") locales, compensate // for it ourselves by simply consuming and ignoring it while ( *result && (*result >= 'A' && *result <= 'Z') ) result++; WX_ASSERT_MESSAGE( ("Test #%u failed: \"%s\" was left unparsed in \"%s\"", n, result, s), !*result ); // Without "%z" we can't recover the time zone used in the // call to Format() so we need to call MakeFromTimezone() // explicitly. if ( !strstr(fmt, "%z") && !isLocalTz ) dt2.MakeFromTimezone(tz); switch ( kind ) { case CompareYear: if ( dt2.GetCentury() != dt.GetCentury() ) { CPPUNIT_ASSERT_EQUAL(dt.GetYear() % 100, dt2.GetYear() % 100); dt2.SetYear(dt.GetYear()); } // fall through and compare everything case CompareBoth: CPPUNIT_ASSERT_EQUAL( dt, dt2 ); break; case CompareDate: CPPUNIT_ASSERT( dt.IsSameDate(dt2) ); break; case CompareTime: CPPUNIT_ASSERT( dt.IsSameTime(dt2) ); break; case CompareNone: wxFAIL_MSG( wxT("unexpected") ); break; } } } } } wxDateTime dt; #if 0 // special case which was known to fail CPPUNIT_ASSERT( dt.ParseFormat("02/06/1856", "%x") ); CPPUNIT_ASSERT_EQUAL( 1856, dt.GetYear() ); #endif // also test %l separately CPPUNIT_ASSERT( dt.ParseFormat("12:23:45.678", "%H:%M:%S.%l") ); CPPUNIT_ASSERT_EQUAL( 678, dt.GetMillisecond() ); // test special case of %l matching 0 milliseconds CPPUNIT_ASSERT( dt.ParseFormat("12:23:45.000", "%H:%M:%S.%l") ); CPPUNIT_ASSERT_EQUAL( 0, dt.GetMillisecond() ); // test partially specified dates too wxDateTime dtDef(26, wxDateTime::Sep, 2008); CPPUNIT_ASSERT( dt.ParseFormat("17", "%d") ); CPPUNIT_ASSERT_EQUAL( 17, dt.GetDay() ); // test some degenerate cases CPPUNIT_ASSERT( !dt.ParseFormat("", "%z") ); CPPUNIT_ASSERT( !dt.ParseFormat("", "%%") ); // test compilation of some calls which should compile (and not result in // ambiguity because of char*<->wxCStrData<->wxString conversions) wxString s("foo"); CPPUNIT_ASSERT( !dt.ParseFormat("foo") ); CPPUNIT_ASSERT( !dt.ParseFormat(wxT("foo")) ); CPPUNIT_ASSERT( !dt.ParseFormat(s) ); dt.ParseFormat(s.c_str()); // Simply test compilation of this one. CPPUNIT_ASSERT( !dt.ParseFormat("foo", "%c") ); CPPUNIT_ASSERT( !dt.ParseFormat(wxT("foo"), "%c") ); CPPUNIT_ASSERT( !dt.ParseFormat(s, "%c") ); dt.ParseFormat(s.c_str(), "%c"); CPPUNIT_ASSERT( !dt.ParseFormat("foo", wxT("%c")) ); CPPUNIT_ASSERT( !dt.ParseFormat(wxT("foo"), wxT("%c")) ); CPPUNIT_ASSERT( !dt.ParseFormat(s, "%c") ); dt.ParseFormat(s.c_str(), wxT("%c")); wxString spec("%c"); CPPUNIT_ASSERT( !dt.ParseFormat("foo", spec) ); CPPUNIT_ASSERT( !dt.ParseFormat(wxT("foo"), spec) ); CPPUNIT_ASSERT( !dt.ParseFormat(s, spec) ); dt.ParseFormat(s.c_str(), spec); }
// we use a tree architecture to build the subzones int VEF::divideIntoZones(Zone z, int nbZones){ TreeZone tz(z); TreeZone *father; int flag, flag2, depth; // used to determine the cutting axis flag = flag2 = depth = 0; Vertex bottom, middle_bottom, middle_top, top; bottom = middle_bottom = z.getZoneBottomVertex(); top = middle_top = z.getZoneTopVertex(); int id = 0; int rootFlag = 0; std::vector<TreeZone> parents; // store the parent trees relative to the one we manipulate for (int i = 0; i < nbZones; i++){ if (!(i % 2)){ if (flag % 3 == 0) // we cut along the x axis { Vertex vx(middle_top.getX() - (middle_top.getX() / 2), middle_top.getY(), middle_top.getZ()); Zone zl(bottom, vx, -1); TreeZone *l = new TreeZone(zl); tz.addLeftChild(l); //top.setX(vx.getX()); middle_top = vx; } if (flag % 3 == 1) // we cut along the y axis { Vertex vy(middle_top.getX(), middle_top.getY() - middle_top.getY() / 2, middle_top.getZ()); Zone zl(bottom, vy, -1); TreeZone *l = new TreeZone(zl); tz.addLeftChild(l); //top.setY(vy.getY()); middle_top = vy; } if (flag % 3 == 2) // we cut along the z axis { Vertex vz(middle_top.getX(), middle_top.getY(), middle_top.getZ() - middle_top.getZ() / 2); Zone zl(bottom, vz, -1); TreeZone *l = new TreeZone(zl); tz.addLeftChild(l); //top.setZ(vz.getZ()); middle_top = vz; } } else { if (flag2 % 3 == 0) // we cut along the x axis { Vertex vx(middle_bottom.getX() + (middle_bottom.getX() / 2), middle_bottom.getY(), middle_bottom.getZ()); Zone zr(vx, top, -1); TreeZone *r = new TreeZone(zr); tz.addRightChild(r); middle_bottom = vx; } if (flag2 % 3 == 1) // we cut along the y axis { Vertex vy(middle_bottom.getX(), middle_bottom.getY() + (middle_bottom.getY() / 2), middle_bottom.getZ()); Zone zr(vy, top, -1); TreeZone *r = new TreeZone(zr); tz.addRightChild(r); middle_bottom = vy; } if (flag2 % 3 == 2) // we cut along the z axis { Vertex vz(middle_bottom.getX(), middle_bottom.getY(), middle_bottom.getZ() + (middle_bottom.getZ() / 2)); Zone zr(vz, top, -1); TreeZone *r = new TreeZone(zr); tz.addRightChild(r); } if (depth){ if (!(*(father->getRightChild()) == tz)) { if (father->getRightChild()->getLeftChild() == NULL) { // the brother of t doesn't exist yet tz = *(father->getRightChild()); father = &(parents.back()); parents.pop_back(); } } } parents.push_back(*father); father = &tz; tz = *(tz.getLeftChild()); depth++; } } // depth-first search to add the zones we created (the leaves) into the zone vector while (tz.hasLeftChild()){ father = &tz; tz = *(tz.getLeftChild()); } tz.getRoot().setZoneId(id); m_zones.push_back(tz.getRoot()); id++; // we stop when we reach the root for the second time, i.e, when all the leaves have been found /*while(rootFlag != 1){ if (father->hasRightChild()){ father->getRightChild()->getRoot().setZoneId(id); m_zones.push_back(father->getRightChild()->getRoot()); } tz = father; if (depth){ father = parents.back(); parents.pop_back(); } depth--; }*/ return 0; }
//--------------------------------------------------------- void NDG3D::PoissonIPDG3D(CSd& spOP, CSd& spMM) //--------------------------------------------------------- { // function [OP,MM] = PoissonIPDG3D() // // Purpose: Set up the discrete Poisson matrix directly // using LDG. The operator is set up in the weak form DVec faceR("faceR"), faceS("faceS"), faceT("faceT"); DMat V2D; IVec Fm("Fm"); IVec i1_Nfp = Range(1,Nfp); double opti1=0.0, opti2=0.0; int i=0; umLOG(1, "\n ==> {OP,MM} assembly: "); opti1 = timer.read(); // time assembly // build local face matrices DMat massEdge[5]; // = zeros(Np,Np,Nfaces); for (i=1; i<=Nfaces; ++i) { massEdge[i].resize(Np,Np); } // face mass matrix 1 Fm = Fmask(All,1); faceR=r(Fm); faceS=s(Fm); V2D = Vandermonde2D(N, faceR, faceS); massEdge[1](Fm,Fm) = inv(V2D*trans(V2D)); // face mass matrix 2 Fm = Fmask(All,2); faceR = r(Fm); faceT = t(Fm); V2D = Vandermonde2D(N, faceR, faceT); massEdge[2](Fm,Fm) = inv(V2D*trans(V2D)); // face mass matrix 3 Fm = Fmask(All,3); faceS = s(Fm); faceT = t(Fm); V2D = Vandermonde2D(N, faceS, faceT); massEdge[3](Fm,Fm) = inv(V2D*trans(V2D)); // face mass matrix 4 Fm = Fmask(All,4); faceS = s(Fm); faceT = t(Fm); V2D = Vandermonde2D(N, faceS, faceT); massEdge[4](Fm,Fm) = inv(V2D*trans(V2D)); // build local volume mass matrix MassMatrix = trans(invV)*invV; DMat Dx("Dx"),Dy("Dy"),Dz("Dz"), Dx2("Dx2"),Dy2("Dy2"),Dz2("Dz2"); DMat Dn1("Dn1"),Dn2("Dn2"), mmE("mmE"), OP11("OP11"), OP12("OP12"); DMat mmE_All_Fm1, mmE_Fm1_Fm1, Dn2_Fm2_All; IMat rows1,cols1,rows2,cols2; int k1=0,f1=0,k2=0,f2=0,id=0; Index1D entries, entriesMM, idsM; IVec fidM,vidM,Fm1,vidP,Fm2; double lnx=0.0,lny=0.0,lnz=0.0,lsJ=0.0,hinv=0.0,gtau=0.0; double N1N1 = double((N+1)*(N+1)); int NpNp = Np*Np; // build DG derivative matrices int max_OP = (K*Np*Np*(1+Nfaces)); int max_MM = (K*Np*Np); // "OP" triplets (i,j,x), extracted to {Ai,Aj,Ax} IVec OPi(max_OP), OPj(max_OP), Ai,Aj; DVec OPx(max_OP), Ax; // "MM" triplets (i,j,x) IVec MMi(max_MM), MMj(max_MM); DVec MMx(max_MM); IVec OnesNp = Ones(Np); // global node numbering entries.reset(1,NpNp); entriesMM.reset(1,NpNp); OP12.resize(Np,Np); for (k1=1; k1<=K; ++k1) { if (! (k1%250)) { umLOG(1, "%d, ",k1); } rows1 = outer( Range((k1-1)*Np+1,k1*Np), OnesNp ); cols1 = trans(rows1); // Build local operators Dx = rx(1,k1)*Dr + sx(1,k1)*Ds + tx(1,k1)*Dt; Dy = ry(1,k1)*Dr + sy(1,k1)*Ds + ty(1,k1)*Dt; Dz = rz(1,k1)*Dr + sz(1,k1)*Ds + tz(1,k1)*Dt; OP11 = J(1,k1)*(trans(Dx)*MassMatrix*Dx + trans(Dy)*MassMatrix*Dy + trans(Dz)*MassMatrix*Dz); // Build element-to-element parts of operator for (f1=1; f1<=Nfaces; ++f1) { k2 = EToE(k1,f1); f2 = EToF(k1,f1); rows2 = outer( Range((k2-1)*Np+1, k2*Np), OnesNp ); cols2 = trans(rows2); fidM = (k1-1)*Nfp*Nfaces + (f1-1)*Nfp + i1_Nfp; vidM = vmapM(fidM); Fm1 = mod(vidM-1,Np)+1; vidP = vmapP(fidM); Fm2 = mod(vidP-1,Np)+1; id = 1+(f1-1)*Nfp + (k1-1)*Nfp*Nfaces; lnx = nx(id); lny = ny(id); lnz = nz(id); lsJ = sJ(id); hinv = std::max(Fscale(id), Fscale(1+(f2-1)*Nfp, k2)); Dx2 = rx(1,k2)*Dr + sx(1,k2)*Ds + tx(1,k2)*Dt; Dy2 = ry(1,k2)*Dr + sy(1,k2)*Ds + ty(1,k2)*Dt; Dz2 = rz(1,k2)*Dr + sz(1,k2)*Ds + tz(1,k2)*Dt; Dn1 = lnx*Dx + lny*Dy + lnz*Dz; Dn2 = lnx*Dx2 + lny*Dy2 + lnz*Dz2; mmE = lsJ*massEdge[f1]; gtau = 2.0 * N1N1 * hinv; // set penalty scaling if (EToE(k1,f1)==k1) { OP11 += ( gtau*mmE - mmE*Dn1 - trans(Dn1)*mmE ); // ok } else { // interior face variational terms OP11 += 0.5*( gtau*mmE - mmE*Dn1 - trans(Dn1)*mmE ); // extract mapped regions: mmE_All_Fm1 = mmE(All,Fm1); mmE_Fm1_Fm1 = mmE(Fm1,Fm1); Dn2_Fm2_All = Dn2(Fm2,All); OP12 = 0.0; // reset to zero OP12(All,Fm2) = -0.5*( gtau*mmE_All_Fm1 ); OP12(Fm1,All) -= 0.5*( mmE_Fm1_Fm1*Dn2_Fm2_All ); //OP12(All,Fm2) -= 0.5*(-trans(Dn1)*mmE_All_Fm1 ); OP12(All,Fm2) += 0.5*( trans(Dn1)*mmE_All_Fm1 ); // load this set of triplets #if (1) OPi(entries)=rows1; OPj(entries)=cols2, OPx(entries)=OP12; entries += (NpNp); #else //########################################################### // load only the lower triangle (after droptol test?) sk=0; start=entries(1); for (int i=1; i<=NpNp; ++i) { eid = start+i; id=entries(eid); rid=rows1(i); cid=cols2(i); if (rows1(rid) >= cid) { // take lower triangle if ( fabs(OP12(id)) > 1e-15) { // drop small entries ++sk; OPi(id)=rid; OPj(id)=cid, OPx(id)=OP12(id); } } } entries += sk; //########################################################### #endif } } OPi(entries )=rows1; OPj(entries )=cols1, OPx(entries )=OP11; MMi(entriesMM)=rows1; MMj(entriesMM)=cols1; MMx(entriesMM)=J(1,k1)*MassMatrix; entries += (NpNp); entriesMM += (NpNp); } umLOG(1, "\n ==> {OP,MM} to sparse\n"); entries.reset(1, entries.hi()-Np*Np); // Extract triplets from the large buffers. Note: this // requires copying each array, and since these arrays // can be HUGE(!), we force immediate deallocation: Ai=OPi(entries); OPi.Free(); Aj=OPj(entries); OPj.Free(); Ax=OPx(entries); OPx.Free(); umLOG(1, " ==> triplets ready (OP) nnz = %10d\n", entries.hi()); // adjust triplet indices for 0-based sparse operators Ai -= 1; Aj -= 1; MMi -= 1; MMj -= 1; int npk=Np*K; #if defined(NDG_USE_CHOLMOD) || defined(NDG_New_CHOLINC) // load only the lower triangle tril(OP) free args? spOP.load(npk,npk, Ai,Aj,Ax, sp_LT, false,1e-15, true); // {LT, false} -> TriL #else // select {upper,lower,both} triangles //spOP.load(npk,npk, Ai,Aj,Ax, sp_LT, true,1e-15,true); // LT -> enforce symmetry //spOP.load(npk,npk, Ai,Aj,Ax, sp_All,true,1e-15,true); // All-> includes "noise" //spOP.load(npk,npk, Ai,Aj,Ax, sp_UT, false,1e-15,true); // UT -> triu(OP) only #endif Ai.Free(); Aj.Free(); Ax.Free(); umLOG(1, " ==> triplets ready (MM) nnz = %10d\n", entriesMM.hi()); //------------------------------------------------------- // The mass matrix operator will NOT be factorised, // Load ALL elements (both upper and lower triangles): //------------------------------------------------------- spMM.load(npk,npk, MMi,MMj,MMx, sp_All,false,1.00e-15,true); MMi.Free(); MMj.Free(); MMx.Free(); opti2 = timer.read(); // time assembly umLOG(1, " ==> {OP,MM} converted to csc. (%g secs)\n", opti2-opti1); }