Foam::CollidingCloud<CloudType>::CollidingCloud
(
const word& cloudName,
const volScalarField& rho,
const volVectorField& U,
const volScalarField& mu,
const dimensionedVector& g,
bool readFields
)
:
CloudType(cloudName, rho, U, mu, g, false),
constProps_(this->particleProperties()),
collisionModel_(nullptr)
{
if (this->solution().steadyState())
{
FatalErrorInFunction
<< "Collision modelling not currently available for steady state "
<< "calculations" << exit(FatalError);
}
if (this->solution().active())
{
setModels();
if (readFields)
{
parcelType::readFields(*this);
this->deleteLostParticles();
}
}
}
Foam::SprayCloud<CloudType>::SprayCloud
(
const word& cloudName,
const volScalarField& rho,
const volVectorField& U,
const dimensionedVector& g,
const SLGThermo& thermo,
bool readFields
)
:
CloudType(cloudName, rho, U, g, thermo, false),
sprayCloud(),
cloudCopyPtr_(NULL),
averageParcelMass_(0.0),
atomizationModel_(NULL),
breakupModel_(NULL),
stochasticCollisionModel_(NULL)
{
if (this->solution().active())
{
setModels();
averageParcelMass_ = this->injection().averageParcelMass();
if (readFields)
{
parcelType::readFields(*this, this->composition());
}
Info << "Average parcel mass: " << averageParcelMass_ << endl;
}
}
/*
* MainWindow methods
*/
MainWindow::MainWindow(QWidget *parent)
: QWidget(parent)
{
setModels();
setWidgets();
setWindowIcon(QIcon(":/images/window_icon.png"));
m_linesCounter = new LinesCounter(f_countLines_STL);
}
void PerfTimelineModelManager::finalize()
{
QVector<PerfTimelineModel *> finished;
QHash<quint32, PerfProfilerTraceManager::Thread> threads = m_traceManager->threads();
for (auto it = m_unfinished.begin(), end = m_unfinished.end(); it != end; ++it) {
PerfTimelineModel *model = *it;
const PerfProfilerTraceManager::Thread &thread = m_traceManager->thread(model->tid());
if (thread.enabled) {
model->setDisplayName(displayNameForThread(thread, m_traceManager));
model->finalize();
finished.append(model);
} else {
delete model;
}
}
m_unfinished.clear();
const qint64 frequency = m_traceManager->samplingFrequency();
for (PerfTimelineModel *model : qAsConst(finished)) {
model->setSamplingFrequency(frequency);
threads.remove(model->tid());
}
for (const PerfProfilerTraceManager::Thread &remaining : threads) {
if (!remaining.enabled)
continue;
PerfTimelineModel *model = new PerfTimelineModel(
remaining.pid, remaining.tid, remaining.firstEvent, remaining.lastEvent, this);
model->setDisplayName(displayNameForThread(remaining, m_traceManager));
model->finalize();
model->setSamplingFrequency(frequency);
finished.append(model);
}
std::sort(finished.begin(), finished.end(), [](PerfTimelineModel *a, PerfTimelineModel *b) {
return a->tid() < b->tid();
});
QVariantList modelsToAdd;
for (PerfTimelineModel *model : finished)
modelsToAdd.append(QVariant::fromValue(model));
setModels(modelsToAdd);
}
MainWindow::MainWindow( QWidget* parent ) : QMainWindow( parent ), ui( new Ui::MainWindow )
{
// initialise private variables
m_undoview = nullptr;
m_tabs = new MainTabWidget();
// setup ui for main window including central widget of tabs
ui->setupUi( this );
setCentralWidget( m_tabs );
resize( 1200, 650 );
// ensure menus and plan tab are kept up-to-date when current tab changes
slotTabChange( m_tabs->currentIndex() );
connect( m_tabs, SIGNAL(currentChanged(int)), this, SLOT(slotTabChange(int)),
Qt::UniqueConnection );
// update edit menu with undostack undo & redo actions
setModels();
}
Foam::KinematicCloud<CloudType>::KinematicCloud
(
const word& cloudName,
const volScalarField& rho,
const volVectorField& U,
const volScalarField& mu,
const dimensionedVector& g,
bool readFields
)
:
CloudType(rho.mesh(), cloudName, false),
kinematicCloud(),
cloudCopyPtr_(NULL),
mesh_(rho.mesh()),
particleProperties_
(
IOobject
(
cloudName + "Properties",
rho.mesh().time().constant(),
rho.mesh(),
IOobject::MUST_READ_IF_MODIFIED,
IOobject::NO_WRITE
)
),
solution_(mesh_, particleProperties_.subDict("solution")),
constProps_(particleProperties_, solution_.active()),
subModelProperties_
(
particleProperties_.subOrEmptyDict("subModels", solution_.active())
),
rndGen_
(
label(0),
solution_.steadyState() ?
particleProperties_.lookupOrDefault<label>("randomSampleSize", 100000)
: -1
),
cellOccupancyPtr_(),
rho_(rho),
U_(U),
mu_(mu),
g_(g),
pAmbient_(0.0),
forces_
(
*this,
mesh_,
subModelProperties_.subOrEmptyDict
(
"particleForces",
solution_.active()
),
solution_.active()
),
functions_
(
*this,
particleProperties_.subOrEmptyDict("cloudFunctions"),
solution_.active()
),
dispersionModel_(NULL),
injectionModel_(NULL),
patchInteractionModel_(NULL),
surfaceFilmModel_(NULL),
UIntegrator_(NULL),
UTrans_
(
new DimensionedField<vector, volMesh>
(
IOobject
(
this->name() + "UTrans",
this->db().time().timeName(),
this->db(),
IOobject::READ_IF_PRESENT,
IOobject::AUTO_WRITE
),
mesh_,
dimensionedVector("zero", dimMass*dimVelocity, vector::zero)
)
),
UCoeff_
(
new DimensionedField<scalar, volMesh>
(
IOobject
(
this->name() + "UCoeff",
this->db().time().timeName(),
this->db(),
IOobject::READ_IF_PRESENT,
IOobject::AUTO_WRITE
),
mesh_,
dimensionedScalar("zero", dimMass, 0.0)
)
)
{
if (solution_.active())
{
setModels();
if (readFields)
{
parcelType::readFields(*this);
}
}
if (solution_.resetSourcesOnStartup())
{
resetSourceTerms();
}
}
