void Ether::registerRobotInEther(int32_t local_id,
int32_t id,
int32_t startingX,
int32_t startingY,
int32_t sector_size_x,
int32_t sector_size_y,
int32_t size_x,
int32_t size_y)
{
if(!fieldsAreCreated){
createFields(size_x, size_y, sector_size_x, sector_size_y);
emit drawSceneWithLines(size_x, size_y, sector_size_x, sector_size_y);
}
boost::shared_ptr<Robot> newRobot = boost::make_shared<Robot>(local_id, id);
newRobot->setXPos(DIAMETER);
newRobot->setYPos(DIAMETER);
_allRobotsOnScene.push_back(newRobot);
if (startingX>size_x-1) {
startingX=0;
}
if (startingY>size_y-1) {
startingY=0;
}
getFields().at(startingY+startingX*size_y).addRobot(getRobotWithMatchingId(id));
_client->current_position(id,startingX,startingY);
emit addRobotToSceneSignal(id);
emit robotProcessedSignal();
}
void GenericDatabase::initialize(IXMLContentPtr configuration, IFactory* factory)
{
m_Logger = factory->logger();
m_Logger->logTrace(__FILE__, __LINE__, "GenericDatabasePlugin", "void GenericDatabase::initialize(IXMLContent *configuration, QObjectLogging *logger, const QMap<QString, QString> &pluginStock)");
m_Name = configuration.dynamicCast<XMLCollection>()->get("name").dynamicCast<XMLElement>()->value();
createFields(configuration.dynamicCast<XMLCollection>()->get("fields"), factory);
m_TableName = configuration.dynamicCast<XMLCollection>()->get("tablename").dynamicCast<XMLElement>()->value();
m_SQLManager.initialize(configuration, factory);
}
Test::Test( QWidget *parent, const char *name )
: QWidget( parent, name )
{
setCaption("Testing KCharsets");
QWidget *d = qApp->desktop();
setGeometry((d->width()-320)>>1, (d->height()-160)>>1, 320, 160);
createFields();
show();
}
//---------------------------------------------------------------------------
int main(int argc, char *argv[])
{
argList args = setRootCase( argc, argv );
TimeHolder runTime=createTime( Time::controlDictName, args );
fvMeshHolder mesh = createMesh( runTime );
volScalarFieldHolder p; volVectorFieldHolder U;
surfaceScalarFieldHolder phi; singlePhaseTransportModelHolder laminarTransport;
incompressible::RASModelHolder turbulence;
label pRefCell = 0;
scalar pRefValue = 0.0;
createFields( runTime, mesh, p, U, phi, laminarTransport, turbulence, pRefCell, pRefValue );
scalar cumulativeContErr = initContinuityErrs();
simpleControlHolder simple(mesh);
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
Info<< "\nStarting time loop\n" << endl;
while (simple->loop())
{
Info<< "Time = " << runTime->timeName() << nl << endl;
p->storePrevIter();
// --- Pressure-velocity SIMPLE corrector
{
fvVectorMatrixHolder UEqn = fun_UEqn( U, phi, turbulence, p );
fun_pEqn( mesh, runTime, simple, U, phi, turbulence, p, UEqn, pRefCell, pRefValue, cumulativeContErr );
}
turbulence->correct();
runTime->write();
Info<< "ExecutionTime = " << runTime->elapsedCpuTime() << " s"
<< " ClockTime = " << runTime->elapsedClockTime() << " s"
<< nl << endl;
}
Info<< "End\n" << endl;
return 0;
}
// Chessboard ------------------------------------------------------
// Konstruktor
Chessboard::Chessboard(Mat ActualPicture)
{
// Saját képeim létrehozása:
ActualPicture.copyTo(GreyPicture);
// Átváltás HSV-be:
cv::cvtColor(GreyPicture, Hpic, cv::COLOR_BGR2HSV);
vector<cv::Mat> channels;
cv::split(Hpic, channels); // Színcsatornák leválasztása
channels[0].copyTo(Hpic);
channels[1].copyTo(Spic);
channels[2].copyTo(Vpic);
// Átváltás szürkeárnyalatosra a feldolgozáshoz:
cv::cvtColor(GreyPicture, GreyPicture, cv::COLOR_BGR2GRAY);
// Legyen a szürke kép a megjelenítõ:
GreyPicture.copyTo(DisplayPicture);
cv::cvtColor(DisplayPicture, DisplayPicture, CV_GRAY2BGR);
// Thresholdozott kép létrehozása:
GreyPicture.copyTo(ThreshPicture);
cv::medianBlur(ThreshPicture, ThreshPicture, 7); // Szûrés, hogy kevesebb zaj legyen benne
cv::medianBlur(ThreshPicture, ThreshPicture, 5);
cv::medianBlur(ThreshPicture, ThreshPicture, 3);
cv::adaptiveThreshold(ThreshPicture, ThreshPicture, 255, ADAPTIVE_THRESH_GAUSSIAN_C, THRESH_BINARY, 7, 0);
cv::erode(ThreshPicture, ThreshPicture, Mat()); // Zaj további kiszûrése erózióval
cv::dilate(ThreshPicture, ThreshPicture, Mat());
cv::dilate(ThreshPicture, ThreshPicture, Mat());
//cv::dilate(ThreshPicture, ThreshPicture, Mat());
// Transzformált sarkpont koordináták megkapása:
if (getCornerGoodCoordinates())
{
// Mezõk létrehozása:
createFields();
// Mezõkre kiírjuk amit tudni kell róluk:
writeInformationOnPicture();
// Sakktábla sikeresen létrejött:
Valid = true;
// Sakktábla validációs teszt
Valid = chessboardValidationTest();
}
}
//--------------------------------------------------------------------------
MetaDataForm::MetaDataForm(QWidget* parent)
: QWidget(parent), settings(new Settings(this))
{
createFields();
updateCollectionAutoCompletion();
createFileSystemWatcher();
QFormLayout* form = new QFormLayout;
form->addRow(tr("Date"), dateField);
form->addRow(tr("Collection"), collectionField);
form->addRow(tr("Category"), categoryField);
form->addRow(tr("Title"), titleField);
form->addRow(tr("Tags"), tagsField);
setLayout(form);
}
//---------------------------------------------------------------------------
int main(int argc, char *argv[])
{
argList args = setRootCase( argc, argv );
TimeHolder runTime=createTime( Time::controlDictName, args );
fvMeshHolder mesh = createMesh( runTime );
basicPsiThermoHolder pThermo; volScalarFieldHolder rho; volScalarFieldHolder p;
volScalarFieldHolder h; volScalarFieldHolder psi;
volVectorFieldHolder U; surfaceScalarFieldHolder phi;
compressible::turbulenceModelHolder turbulence;
volScalarFieldHolder DpDt;
result_createFields result = createFields( runTime, mesh, pThermo, rho, p, h, psi, U, phi, turbulence, DpDt );
dimensionedScalar rhoMax = result.m_rhoMax;
dimensionedScalar rhoMin = result.m_rhoMin;
MRFZonesHolder mrfZones;
porousZonesHolder pZones;
Switch pressureImplicitPorosity;
createZones( mesh, U, mrfZones, pZones, pressureImplicitPorosity );
scalar cumulativeContErr = initContinuityErrs();
pimpleControlHolder pimple(mesh);
Info<< "\nStarting time loop\n" << endl;
while (runTime->run())
{
bool adjustTimeStep; scalar maxCo; scalar maxDeltaT;
readTimeControls( runTime, adjustTimeStep, maxCo, maxDeltaT );
scalar coNum, meanCoNum;
compressibleCourantNo( runTime, mesh, phi, rho, coNum, meanCoNum );
setDeltaT( runTime, adjustTimeStep, maxCo, coNum, maxDeltaT );
(*runTime)++;
Info<< "Time = " << runTime->timeName() << nl << endl;
rhoEqn( rho, phi );
// --- Pressure-velocity PIMPLE corrector loop
for (pimple->start(); pimple->loop(); (*pimple)++)
{
if (pimple->nOuterCorr() != 1)
{
p->storePrevIter();
rho->storePrevIter();
}
fvVectorMatrixHolder UEqn = fun_Ueqn( pimple, rho, p, U, phi, turbulence, mrfZones, pZones );
fun_hEqn( pThermo, rho, p, h, phi, turbulence, DpDt );
// --- PISO loop
for (int corr=0; corr<pimple->nCorr(); corr++)
{
fun_pEqn( mesh, runTime, pimple, pThermo, rho, p, h, psi, U, phi, turbulence, UEqn,
mrfZones, DpDt, cumulativeContErr, corr, rhoMax, rhoMin );
}
if (pimple->turbCorr())
{
turbulence->correct();
}
}
runTime->write();
Info<< "ExecutionTime = " << runTime->elapsedCpuTime() << " s"
<< " ClockTime = " << runTime->elapsedClockTime() << " s"
<< nl << endl;
}
Info<< "End\n" << endl;
return 0;
}
//---------------------------------------------------------------------------
int main(int argc, char *argv[])
{
argList args = setRootCase( argc, argv );
TimeHolder runTime=createTime( Time::controlDictName, args );
fvMeshHolder mesh = createMesh( runTime );
IOdictionaryHolder transportProperties;
volScalarFieldHolder p;
volVectorFieldHolder U;
surfaceScalarFieldHolder phi;
label pRefCell = 0;
scalar pRefValue = 0.0;
dimensionedScalar nu = createFields( runTime, mesh, transportProperties, p, U, phi, pRefCell, pRefValue );
scalar cumulativeContErr = initContinuityErrs();
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
Info<< "\nStarting time loop\n" << endl;
while (runTime->loop())
{
Info<< "Time = " << runTime->timeName() << nl << endl;
dictionary pisoDict;
int nOuterCorr;
int nCorr;
int nNonOrthCorr;
bool momentumPredictor;
bool transonic;
readPISOControls( mesh, pisoDict, nOuterCorr, nCorr, nNonOrthCorr, momentumPredictor, transonic);
CourantNo( runTime, mesh, phi );
fvVectorMatrixHolder UEqn
(
fvm::ddt( U )
+ fvm::div( phi, U )
- fvm::laplacian( nu, U )
);
solve( UEqn == -fvc::grad( p ) );
// --- PISO loop
for (int corr=0; corr<nCorr; corr++)
{
volScalarFieldHolder rAU( 1.0 / volScalarFieldHolder( UEqn->A(), &UEqn ) );
U = rAU * volVectorFieldHolder( UEqn->H(), &UEqn );
phi = ( fvc::interpolate(U) & surfaceVectorFieldHolder( mesh->Sf(), &mesh ) ) + fvc::ddtPhiCorr(rAU, U, phi);
adjustPhi(phi, U, p);
for (int nonOrth=0; nonOrth<=nNonOrthCorr; nonOrth++)
{
fvScalarMatrixHolder pEqn
(
fvm::laplacian(rAU, p ) == fvc::div(phi)
);
pEqn->setReference(pRefCell, pRefValue);
pEqn->solve();
if (nonOrth == nNonOrthCorr)
{
phi -= pEqn->flux();
}
}
continuityErrors( runTime, mesh, phi, cumulativeContErr );
U -= rAU * fvc::grad(p);
U->correctBoundaryConditions();
}
runTime->write();
Info<< "ExecutionTime = " << runTime->elapsedCpuTime() << " s"
<< " ClockTime = " << runTime->elapsedClockTime() << " s"
<< nl << endl;
}
Info<< "End\n" << endl;
return 0;
}
//---------------------------------------------------------------------------
int main(int argc, char *argv[])
{
argList args = setRootCase( argc, argv );
TimeHolder runTime=createTime( Time::controlDictName, args );
fvMeshHolder mesh = createMeshNoClear( runTime );
singlePhaseTransportModelHolder fluid;
volScalarFieldHolder p;
volVectorFieldHolder U;
surfaceScalarFieldHolder phi;
label pRefCell = 0;
scalar pRefValue = 0.0;
createFields( runTime, mesh, fluid, p, U, phi, pRefCell, pRefValue );
scalar cumulativeContErr = initContinuityErrs();
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
Info<< "\nStarting time loop\n" << endl;
while (runTime->loop())
{
Info<< "Time = " << runTime->timeName() << nl << endl;
dictionary pisoDict; int nOuterCorr; int nCorr; int nNonOrthCorr;
bool momentumPredictor; bool transonic;
readPISOControls( mesh, pisoDict, nOuterCorr, nCorr, nNonOrthCorr, momentumPredictor, transonic);
scalar CoNum; scalar meanCoNum;
CourantNo( runTime, mesh, phi, CoNum, meanCoNum );
fluid->correct();
smart_tmp< fvVectorMatrix > UEqn( fvm::ddt( U() ) + fvm::div( phi(), U() ) - fvm::laplacian( fluid->nu(), U() ) );
solve( UEqn() == -fvc::grad( p() ));
// --- PISO loop
for (int corr=0; corr<nCorr; corr++)
{
smart_tmp< volScalarField > rAU( 1.0 / UEqn->A() );
U = rAU() * UEqn->H();
phi = ( fvc::interpolate( U() ) & mesh->Sf() ) + fvc::ddtPhiCorr( rAU(), U(), phi() );
adjustPhi(phi, U, p);
for (int nonOrth=0; nonOrth<=nNonOrthCorr; nonOrth++)
{
smart_tmp< fvScalarMatrix > pEqn( fvm::laplacian( rAU(), p() ) == fvc::div( phi() ) );
pEqn->setReference( pRefCell, pRefValue );
pEqn->solve();
if (nonOrth == nNonOrthCorr)
{
phi -= pEqn->flux();
}
}
continuityErrors( runTime, mesh, phi, cumulativeContErr );
U -= rAU() * fvc::grad( p() );
U->correctBoundaryConditions();
}
runTime->write();
Info << "ExecutionTime = " << runTime->elapsedCpuTime() << " s"
<< " ClockTime = " << runTime->elapsedClockTime() << " s"
<< nl << endl;
}
Info<< "End\n" << endl;
return 0;
}
//---------------------------------------------------------------------------
int main(int argc, char *argv[])
{
argList args = setRootCase( argc, argv );
TimeHolder runTime=createTime( Time::controlDictName, args );
fvMeshHolder mesh = createMesh( runTime );
uniformDimensionedVectorFieldHolder g = readGravitationalAcceleration( runTime, mesh );
volScalarFieldHolder T; volScalarFieldHolder p_rgh;
volVectorFieldHolder U; surfaceScalarFieldHolder phi;
singlePhaseTransportModelHolder laminarTransport;
incompressible::RASModelHolder turbulence;
volScalarFieldHolder rhok; volScalarFieldHolder kappat;
volScalarFieldHolder gh; surfaceScalarFieldHolder ghf;
volScalarFieldHolder p;
label pRefCell = 0;
scalar pRefValue = 0.0;
result_readTransportProperties result = createFields( runTime, mesh, g, T, p_rgh, U, phi, laminarTransport, turbulence, rhok,
kappat, gh, ghf, p, pRefCell, pRefValue );
dimensionedScalar& beta = result.m_beta;
dimensionedScalar& TRef = result.m_TRef;
dimensionedScalar& Pr = result.m_Pr;
dimensionedScalar& Prt = result.m_Prt;
scalar cumulativeContErr = initContinuityErrs();
simpleControlHolder simple(mesh);
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
Info<< "\nStarting time loop\n" << endl;
while (simple->loop())
{
Info<< "Time = " << runTime->timeName() << nl << endl;
p_rgh->storePrevIter();
// Pressure-velocity SIMPLE corrector
{
fvVectorMatrixHolder UEqn = fun_UEqn( mesh, simple, U, phi, turbulence, p, rhok, p_rgh, ghf );
fun_TEqn( phi, turbulence, kappat, T, rhok, beta, TRef, Prt, Pr );
fun_pEqn( mesh, runTime, simple, p, rhok, U, phi, turbulence, gh, ghf, p_rgh, UEqn, pRefCell, pRefValue, cumulativeContErr );
}
turbulence->correct();
runTime->write();
Info<< "ExecutionTime = " << runTime->elapsedCpuTime() << " s"
<< " ClockTime = " << runTime->elapsedClockTime() << " s"
<< nl << endl;
}
Info<< "End\n" << endl;
return 0;
}
