bool SubOutput::set_link()
{
p = &fake_in; src_obj = nullptr; linkType = LinkBad;
if( source.cval().isEmpty() ) {
linkType = LinkNone;
return true; // really?
}
if( !par ) {
return false;
}
Scheme *sch = par->getObjT<Scheme*>( "sch" );
if( !sch ) {
qWarning() << "scheme not found " << NWHE;
return false;
}
int lt;
const LinkedObj *srct = nullptr;
const double *cp = sch->getDoublePtr( source, <, &srct, 0 );
if( lt == LinkElm || lt == LinkSpec ) {
p = cp; src_obj = srct; linkType = lt;
} else {
qWarning() << "ptr not found for output " << source << NWHE;
return false;
}
return true;
}
Relation Relation::combinator(Relation& right)
{
Scheme temp;
vector <pair<int,int> > at_relation;
temp = my_values.combine_schemes(right.my_values, at_relation);
Relation result;
for (int i = 0; i < temp.size(); i++)
result.set_value(temp.at(i));
for (set<Tuple>::iterator it = Tuple_Set.begin(); it != Tuple_Set.end(); ++it)
for (set<Tuple>::iterator it2 = right.Tuple_Set.begin(); it2 != right.Tuple_Set.end(); ++it2)
{
Tuple t(*it);
if (t.joinable((*it2), at_relation))
{
t = t.combinator((*it2), at_relation);
result.set_tuple(t);
}
}
return result;
}
string Interpretter::outputFacts() {
string out = "";
// get a list of relations
for (auto relation : db) {
// print the relation
out += relation.first + "\n";
Scheme s = relation.second.getScheme();
set <Tuple> t = relation.second.getTuples();
// for each of the tuples in the relation's set
for (auto tuple : t) {
out += " ";
// for each of the attributes in the relation's scheme:
for (int attr = 0; attr < s.size(); attr++) {
// print the attribute
out += s[attr] + "=";
// print the value at the relation's tuple
out += tuple[attr] + " ";
}
if (tuple.size() > 0) {
out.pop_back();
}
out += "\n";
}
out += "\n";
}
return out;
}
void Relation::project(map<int, string>& variables)
{
set<Tuple> newTuples;
Scheme newScheme;
Tuple t;
for (auto& v : variables){
newScheme.addAttribute(scheme.getAttributes().at(v.first));
}
for (auto& tup : tuples){
for (auto& v : variables)
{
t.addAttValue(tup.at(v.first));
}
if (variables.size() > 0){
newTuples.insert(t);
t.clear();
}
}
tuples = newTuples;
scheme = newScheme;
setName("project");
}
/*************************************************************************
Loads a scheme
*************************************************************************/
Scheme* SchemeManager::loadScheme(const String& scheme_filename, const String& resourceGroup)
{
Logger::getSingleton().logEvent((utf8*)"Attempting to load Scheme from file '" + scheme_filename + "'.");
Scheme* tmp = new Scheme(scheme_filename, resourceGroup);
String name = tmp->getName();
d_schemes[name] = tmp;
return tmp;
}
void Relation::rename(map<int, string>& variables)
{
Scheme newScheme;
for (auto& v : variables){
newScheme.addAttribute(v.second);
}
scheme = newScheme;
setName("rename");
}
//------------------------------------------------------------------//
// ---------------- LAPLACE -- CELL CENTER -------------------------//
//------------------------------------------------------------------//
// (1) The following function is the core others use this function //
//------------------------------------------------------------------//
void Grid::triLaplace(triLinSys &axb, shared_ptr<Cell > f, double const &c) {
if (!thisVar) {cout << "Laplace0: Variable is not locked!!"<< endl; return; }
// cout << "LAPLACE !!!! "<< endl;
// cout << f->vol() << endl;
Scheme<double> sch = f->normGrad(thisVar);
auto area = f->vol().abs();
int n = f->next;
int p = f->prev;
for (auto i = 0; i < sch.size(); ++i) {
// cout << "[" << n << ", "<< p << "] "<< c << " : " << sch.val[i] << " : " << area;
auto flux = c*sch.val[i]*area;
//cout << " : " << flux << endl;
//cin.ignore().get();
if (n >= 0) axb.A(n, sch.ind[i]) -= flux/listCell[n]->vol().abs();
if (p >= 0) axb.A(p, sch.ind[i]) += flux/listCell[p]->vol().abs();
}
if (n >= 0) axb.b[n] += c*sch.c*area/listCell[n]->vol().abs();
if (p >= 0) axb.b[p] -= c*sch.c*area/listCell[p]->vol().abs();
return;
// int n = f->next;
// int p = f->prev;
// auto c0 = (p>=0) ? *(listCell.begin() + p) : f;
// auto c1 = (n>=0) ? *(listCell.begin() + n) : f;
// Vec3 dx = c1->getCoord() - c0->getCoord();
// Vec3 faceArea = f->vol();
// Vec3 norm = faceArea/faceArea.abs();
// if (p>=0 && n>=0) {
// double flux = c*faceArea.abs()/(dx*norm);
// axb.A[p][p] -= flux;
// axb.A[n][n] -= flux;
// axb.A[p][n] += flux;
// axb.A[n][p] += flux;
// return;
// } else {
// if (!thisVar) {cout<<"laplace0: Boundary is not locked!"<<endl; return;}
// auto bndr = (p >= 0) ? -n-1 : -p-1;
// auto row = (p >= 0) ? p : n;
// if (bndr < 0 || bndr >= thisVar->listBC.size() || !(thisVar->listBC[bndr])) {
// cout << "wrong with bndr : Value "<< bndr <<endl;
// return;
// }
// auto bc = thisVar->listBC[bndr];
// if (bc->type == 0) {
// double flux = c*faceArea.abs()/(dx*norm);
// axb.A[row][row] -= flux*(1.0 - bc->a_val);
// axb.b[row] -= flux*(bc->b_val);
// } else if (bc->type == 1) {
// double flux = c*faceArea.abs();
// if (n >= 0) flux = -flux;
// axb.A[row][row] += flux*(bc->a_val);
// axb.b[row] -= flux*(bc->b_val);
// } else {
// cout << "Type is not recognized!"<< endl;
// }
// }
return;
}
void Interpretter::evalSchemes(vector <Predicate>& schemeList) {
output += "Scheme Evaluation\n\n";
for (Predicate scheme : schemeList) { //a list of predicates
set <Tuple> tuples;
Scheme s;
for (auto param : scheme.getParams()) {
s.push_back(param.toString()); //for whatever reason, we can't have objects used from previous labs, so dump to string here
}
Relation r(scheme.getID(), s, tuples); //scheme.getParams() needs to be a set
db[r.getName()] = r;
//add relation to database
}
}
void RDBMSInterpreter::retrieveRelations()
{
for (vector<Scheme*>::iterator it = m_schemes.begin(); it != m_schemes.end(); it++)
{
Scheme* scheme = *it;
Relation relation(scheme->id(), scheme->idList());
readFacts(relation);
m_relations[relation.name()] = relation;
}
}
//static
uint SchemeUtils::calculateQuantumCost(const Scheme& scheme)
{
uint size = scheme.size();
if (size == 0)
return 0;
ReverseElement prevElement;
bool isPreviousElementWasUsedBefore = true;
uint cost = 0;
for (auto& element : scheme)
{
if (!isPreviousElementWasUsedBefore)
{
uint peresCost = 0;
if (isPeresGate(prevElement, element, &peresCost))
{
cost -= getElementQuantumCost(prevElement);
cost += peresCost;
isPreviousElementWasUsedBefore = true;
continue;
}
}
cost += getElementQuantumCost(element);
prevElement = element;
isPreviousElementWasUsedBefore = false;
}
return cost;
}
//----------------------------------------------------------------------------//
void SchemeManager::doPostObjectAdditionAction(Scheme& scheme)
{
if (d_autoLoadResources)
{
scheme.loadResources();
}
}
Scheme GtGenerator::generate(const TruthTable& table)
{
n = 0;
float time = 0;
{
AutoTimer timer(&time);
checkPermutationValidity(table);
tie(n, permutation) = getPermutation(table);
}
debugLog("GtGenerator::generate()-dump-permutation-creation-time", [=](ostream& out)->void
{
out << "Permutation creation time: ";
out << setiosflags(ios::fixed) << setprecision(2) << time / 1000;
out << " sec" << endl;
});
debugLog("GtGenerator::generate()-dump-permutation", [&](ostream& out)->void
{
out << "Permutation (non-fixed points number is " << permutation.getElementCount() << ")\n";
out << permutation << endl;
});
Scheme scheme;
if (permutation.length())
{
Scheme::iterator targetIter = scheme.end();
shared_ptr<PartialGtGenerator> partialGenerator(new PartialGtGenerator());
partialGenerator->setPermutation(permutation, n);
partialGenerator->prepareForGeneration();
while (partialGenerator)
partialGenerator = reducePermutation(partialGenerator, n, &scheme, &targetIter);
}
return scheme;
}
Scheme<double> Cell::phi(vector<shared_ptr<Boundary> > const &bc, int_2 bias) {
Scheme<double> sch;
if (next < 0 && prev < 0) {
sch.push_pair(id, 1.0);
} else {
// use next and prev to compute phi;
if (next >= 0 && prev >= 0) {
if (bias == 0) {
double dn = abs((grid->listCell[next]->getCoord() - getCoord())*vol());
double dp = abs((grid->listCell[prev]->getCoord() - getCoord())*vol());
sch.push_pair(prev, dn/(dn+dp));
sch.push_pair(next, dp/(dn+dp));
} else if (bias == -1) {
sch.push_pair(prev, 1.0);
} else if (bias == 1) {
sch.push_pair(next, 1.0);
}
} else {
auto bndr = (prev >= 0) ? -next-1 : -prev-1;
auto row = (prev >= 0) ? prev : next;
if (bc[bndr]->type == 0) {
sch.push_constant(bc[bndr]->b_val);
sch.push_pair(row, bc[bndr]->a_val);
} else if (bc[bndr]->type == 1) {
auto c0 = grid->listCell[row];
auto norm = vol(); norm = norm/norm.abs();
double dx = norm*(getCoord() - c0->getCoord());
sch.push_constant(dx*bc[bndr]->b_val);
sch.push_pair(row, (1.0 + dx*bc[bndr]->a_val));
} else {
cout << "Cell (Quad) :: interp :: boundary condition type not recognized " << endl;
exit(1);
}
}
}
return sch;
}
Scheme Relation::join_scheme(Relation r2) {
Scheme s = Scheme();
// Put in the whole first scheme
for (auto var : this->scheme)
s.push_back(var);
// Put in any additional vars from the second scheme
for (auto var1 : this->scheme) {
for (auto var2 : r2.scheme) {
if (std::find(s.begin(), s.end(), var2) == s.end()) {
s.push_back(var2);
}
}
}
return s;
}
bool Scheme::operator > (const Scheme& compare) const
{
return _tcsicmp(GetTitle(), compare.GetTitle()) > 0;
}
Scheme CompositeGenerator::generate(const TruthTable& table, ostream& outputLog)
{
float totalTime = 0;
float time = 0;
// process truth table with Reed-Muller generator
uint size = table.size();
uint n = (uint)(log(size) / log(2));
outputLog << "n = " << n << endl;
uint threshold = getRmGeneratorWeightThreshold(n);
outputLog << "RM generator index weight threshold: " << threshold << endl;
RmGenerator rmGenerator(threshold);
RmGenerator::SynthesisResult rmResult;
{
AutoTimer timer(&time);
rmGenerator.generate(table, &rmResult);
}
totalTime += time;
outputLog << "RM generator time: ";
logTime(outputLog, time);
outputLog << "RM scheme complexity: " << rmResult.scheme.size() << endl;
// process residual truth table with Group Theory based generator
GtGenerator gtGenerator;
Scheme gtLeftScheme;
Scheme gtRightScheme;
{
AutoTimer timer(&time);
gtLeftScheme = gtGenerator.generate(rmResult.leftMultTable);
gtRightScheme = gtGenerator.generate(rmResult.rightMultTable);
}
totalTime += time;
outputLog << "GT generator time: ";
logTime(outputLog, time);
outputLog << "GT left scheme complexity: " << gtLeftScheme.size() << endl;
outputLog << "GT right scheme complexity: " << gtRightScheme.size() << endl;
// combine GT and RM schemes
Scheme& scheme = rmResult.scheme;
RmGenerator::PushPolicy pushPolicy = rmGenerator.getPushPolicy();
if (pushPolicy.defaultPolicy)
{
if (gtLeftScheme.size() < gtRightScheme.size())
scheme.insert(scheme.begin(), gtLeftScheme.cbegin(), gtLeftScheme.cend());
else
scheme.insert(scheme.end(), gtRightScheme.cbegin(), gtRightScheme.cend());
}
else
{
scheme.insert(scheme.begin(), gtLeftScheme.cbegin(), gtLeftScheme.cend());
scheme.insert(scheme.end(), gtRightScheme.cbegin(), gtRightScheme.cend());
}
outputLog << "Complexity before optimization: " << scheme.size() << endl;
outputLog << "Quantum cost before optimization: ";
outputLog << SchemeUtils::calculateQuantumCost(scheme) << endl;
// optimize scheme complexity
PostProcessor postProcessor;
{
AutoTimer timer(&time);
scheme = postProcessor.optimize(scheme);
}
totalTime += time;
bool isValid = TruthTableUtils::checkSchemeAgainstPermutationVector(scheme, table);
assert(isValid, string("Generated scheme is not valid"));
// log post processing parameters
outputLog << "Optimization time: ";
logTime(outputLog, time);
outputLog << "Complexity after optimization: " << scheme.size() << endl;
outputLog << "Quantum cost after optimization: ";
outputLog << SchemeUtils::calculateQuantumCost(scheme) << endl;
outputLog << "Total time: ";
logTime(outputLog, totalTime);
return scheme;
}
void peanoclaw::native::fullswof2DMain(
peanoclaw::native::scenarios::SWEScenario& scenario,
tarch::la::Vector<DIMENSIONS,int> numberOfCells
) {
tarch::logging::Log _log("peanoclaw::native::fullswof2DMain(...)");
int ghostlayerWidth = 1;
FullSWOF2D_Parameters parameters(
ghostlayerWidth,
numberOfCells[0],
numberOfCells[1],
scenario.getInitialMinimalMeshWidth()[0],
scenario.getInitialMinimalMeshWidth()[1],
scenario.getDomainSize(),
scenario.getEndTime(),
#ifdef PEANOCLAW_FULLSWOF2D
scenario.enableRain(),
scenario.getFrictionCoefficient(),
#else
true,
0.0,
#endif
scenario.getBoundaryCondition(0, false),
scenario.getBoundaryCondition(0, true),
scenario.getBoundaryCondition(1, false),
scenario.getBoundaryCondition(1, true)
);
Choice_scheme * schemeWrapper;
schemeWrapper = new Choice_scheme(parameters);
Scheme* scheme = schemeWrapper->getInternalScheme();
tarch::la::Vector<DIMENSIONS,int> subcellIndex;
/** Water height.*/
TAB& h = scheme->getH();
for (int x = -ghostlayerWidth; x < numberOfCells(0)+ghostlayerWidth; x++) {
for (int y = -ghostlayerWidth; y < numberOfCells(1)+ghostlayerWidth; y++) {
assignList(subcellIndex) = x, y;
tarch::la::Vector<DIMENSIONS,double> position
= subcellIndex.convertScalar<double>() * tarch::la::invertEntries(numberOfCells.convertScalar<double>()) * scenario.getDomainSize();
position += scenario.getDomainOffset();
h[x+ghostlayerWidth][y+ghostlayerWidth] = scenario.getWaterHeight(
(float)x / numberOfCells[0] * scenario.getDomainSize()[0] + scenario.getDomainOffset()[0],
(float)y / numberOfCells[1] * scenario.getDomainSize()[1] + scenario.getDomainOffset()[1]
);
}
}
/** X Velocity.*/
TAB& u = scheme->getU();
for (int x = -ghostlayerWidth; x < numberOfCells(0)+ghostlayerWidth; x++) {
for (int y = -ghostlayerWidth; y < numberOfCells(1)+ghostlayerWidth; y++) {
assignList(subcellIndex) = x, y;
u[x+ghostlayerWidth][y+ghostlayerWidth] = scenario.getVeloc_u(
(float)x / numberOfCells[0] * scenario.getDomainSize()[0] + scenario.getDomainOffset()[0],
(float)y / numberOfCells[1] * scenario.getDomainSize()[1] + scenario.getDomainOffset()[1]
);
}
}
/** Y Velocity.*/
TAB& v = scheme->getV();
for (int x = -ghostlayerWidth; x < numberOfCells(0)+ghostlayerWidth; x++) {
for (int y = -ghostlayerWidth; y < numberOfCells(1)+ghostlayerWidth; y++) {
assignList(subcellIndex) = x, y;
v[x+ghostlayerWidth][y+ghostlayerWidth] = scenario.getVeloc_v(
(float)x / numberOfCells[0] * scenario.getDomainSize()[0] + scenario.getDomainOffset()[0],
(float)y / numberOfCells[1] * scenario.getDomainSize()[1] + scenario.getDomainOffset()[1]
);
}
}
/** Topography.*/
TAB& z = scheme->getZ();
for (int x = -ghostlayerWidth; x < numberOfCells(0)+ghostlayerWidth; x++) {
for (int y = -ghostlayerWidth; y < numberOfCells(1)+ghostlayerWidth; y++) {
assignList(subcellIndex) = x, y;
z[x+ghostlayerWidth][y+ghostlayerWidth] = scenario.getBathymetry(
(float)x / numberOfCells[0] * scenario.getDomainSize()[0] + scenario.getDomainOffset()[0],
(float)y / numberOfCells[1] * scenario.getDomainSize()[1] + scenario.getDomainOffset()[1]
);
}
}
tarch::timing::Watch runtimeWatch("peanoclaw::native", "fullswof2DMain", true);
double t = 0.0;
while(tarch::la::smaller(t, scenario.getEndTime())) {
//TODO unterweg debug
std::cout << "t=" << t << std::endl;
scheme->resetN();
schemeWrapper->calcul();
t += scheme->getTimestep();
}
runtimeWatch.stopTimer();
//Print maximum memory demand
logInfo("fullswof2DMain", "Peak resident set size: " << peanoclaw::statistics::getPeakRSS() << "b");
delete scheme;
}
Scheme<double> Cell::normGrad(vector<shared_ptr<Boundary> > const &bc) {
Scheme<double> sch;
if (next < 0 && prev < 0) {
// control volume of the cell;
cout << "You can only call form normGrad for a face!!! " << endl;
exit(1);
} else {
// use next and prev to compute phi;
if (next >= 0 && prev >= 0) {
if (grid->listCell[next]->level[orient] == grid->listCell[prev]->level[orient]) {
auto norm = vol();
auto area = norm.abs();
norm = norm/area;
auto dx = grid->listCell[next]->getCoord() - grid->listCell[prev]->getCoord();
auto onebydx = 1.0/(dx*norm);
sch.push_pair(next, onebydx);
sch.push_pair(prev, -onebydx);
} else { // this part is cell specific // 2d-3d
vector<Vec3> v;
vector<Scheme<double>> tmp;
auto norm = vol();
norm = norm/norm.abs();
v.push_back(grid->listCell[prev]->getCoord());
v.push_back(*(grid->listVertex[node[0]]));
v.push_back(grid->listCell[next]->getCoord());
v.push_back(*(grid->listVertex[node[1]]));
tmp.push_back(grid->listCell[prev]->phi(bc));
tmp.push_back(grid->listVertex[node[0]]->phi(bc));
tmp.push_back(grid->listCell[next]->phi(bc));
tmp.push_back(grid->listVertex[node[1]]->phi(bc));
tmp[3] += grid->listCell[prev]->phi(bc);
tmp[0] += grid->listVertex[node[0]]->phi(bc);
tmp[1] += grid->listCell[next]->phi(bc);
tmp[2] += grid->listVertex[node[1]]->phi(bc);
auto vol = 0.5*((v[3]-v[1])^(v[2]-v[0])).abs();
for (auto j = 0; j < 4; ++j) {
auto del = v[(j+1)%4] - v[j];
auto area = Vec3(-del[1], del[0], 0);
for (auto i = 0; i < tmp[j].size(); ++i)
sch.push_pair(tmp[j].ind[i], (0.5*tmp[j].val[i]/vol)*area*norm); //0.5 from average;
}
}
} else {
// cout << "**** " << vol() << " " << type << endl;
// cout << *(grid->listVertex[node[0]]) << " " << *(grid->listVertex[node[1]]) << endl;
auto bndr = (prev >= 0) ? -next-1 : -prev-1;
auto row = (prev >= 0) ? prev : next;
auto norm = vol();
auto area = norm.abs();
norm = norm/area;
auto dx = (next >= 0) ? grid->listCell[next]->getCoord() - getCoord() : getCoord() - grid->listCell[prev]->getCoord();
auto onebydx = 1.0/(dx*norm);
if (bc[bndr]->type == 0) {
if (row == next) onebydx = -onebydx;
sch.push_constant(bc[bndr]->b_val * onebydx);
sch.push_pair(row, (bc[bndr]->a_val - 1.0) * onebydx);
} else if (bc[bndr]->type == 1) {
sch.push_constant((bc[bndr]->b_val));
sch.push_pair(row, (bc[bndr]->a_val));
} else {
cout << "Cell (Line) :: grad :: boundary condition type not recognized " << endl;
exit(1);
}
}
}
return sch;
}
void REScintilla::SetRE(LPCSTR regex, bool bClearStyling)
{
// First of all build up the regular expression to use.
CToolREBuilder builder;
CA2CT regext(regex);
tstring result = builder.Build(regext);
CT2CA regexa(result.c_str());
m_customre = regexa;
/*if(m_pRE)
{
delete m_pRE;
m_pRE = NULL;
}*/
if(!m_pRE)
{
m_pRE = new sregex;
}
try
{
// We pass 0 to disable the default UTF-8 matching, we're in ASCII in output window
*m_pRE = sregex::compile(m_customre);
g_Context.m_frame->SetStatusText(_T(""));
}
catch(boost::xpressive::regex_error& ex)
{
size_t len = strlen(ex.what()) + m_customre.size() + 90;
TCHAR* buf = new TCHAR[len];
buf[len - 1] = NULL;
_sntprintf(buf, len - 1, _T("Custom Parser Error (%S): %S"), ex.what(), m_customre.c_str());
g_Context.m_frame->SetStatusText(buf);
delete [] buf;
delete m_pRE;
m_pRE = NULL;
}
if(!schemeLoaded)
{
// Now turn Scintilla into custom lex mode, first get styles from the output scheme.
Scheme* pScheme = SchemeManager::GetInstance()->SchemeByName("output");
if(pScheme && ::IsWindow(this->m_scihWnd))
{
pScheme->Load( *(static_cast<CScintilla*>(this)) );
// Override some nastiness inherited from the default schemes...
SPerform(SCI_SETCARETLINEVISIBLE, false);
SPerform(SCI_SETEDGEMODE, EDGE_NONE);
}
// Switch to container-based lexing...
SetLexer(SCLEX_CONTAINER);
}
if(bClearStyling)
{
// Clear all old styling...
ClearDocumentStyle();
// Now re-style the whole thing.
//Colourise(0, -1); - doesn't work for SCLEX_CONTAINER
ScintillaAccessor styler(this);
styler.SetCodePage(GetCodePage());
handleStyleNeeded(styler, 0, GetLength());
styler.Flush();
}
}