Id ReadKkit::buildTable( const vector< string >& args )
{
string head;
string clean = cleanPath( args[2] );
string tail = pathTail( clean, head ); // Name of xtab
Id pa = shell_->doFind( head ).id;
assert( pa != Id() );
Id tab;
int mode = atoi( args[ tableMap_[ "step_mode" ] ].c_str() );
if ( mode == TAB_IO ) {
} else if ( mode == TAB_LOOP || mode == TAB_ONCE ) {
tab = shell_->doCreate( "StimulusTable", pa, tail, 1 );
assert( tab != Id() );
double stepSize = atof( args[ tableMap_[ "stepsize" ] ].c_str() );
Field< double >::set( tab, "stepSize", stepSize );
if ( mode == TAB_LOOP )
Field< bool >::set( tab, "doLoop", 1 );
double input = atof( args[ tableMap_[ "input" ] ].c_str() );
Field< double >::set( tab, "startTime", -input );
// The other StimulusTable parameters will have to wait till the
// loadTab is invoked.
}
string temp = clean.substr( 10 );
tabIds_[ temp ] = tab;
Id info = buildInfo( tab, tableMap_, args );
return tab;
}
Id ReadKkit::buildReac( const vector< string >& args )
{
string head;
string clean = cleanPath( args[2] );
string tail = pathTail( clean, head );
Id pa = shell_->doFind( head ).id;
assert( pa != Id() );
double kf = atof( args[ reacMap_[ "kf" ] ].c_str() );
double kb = atof( args[ reacMap_[ "kb" ] ].c_str() );
// We have a slight problem because MOOSE has a more precise value for
// NA than does kkit. Here we assume that the conc units from Kkit are
// meant to be OK, so they override the #/cell (lower case k) units.
// So we convert all the Kfs and Kbs in the entire system after
// the model has been created, once we know the order of each reac.
Id reac = shell_->doCreate( "Reac", pa, tail, 1 );
reacIds_[ clean.substr( 10 ) ] = reac;
// Here is another hack: The native values stored in the reac are
// Kf and Kb, in conc units. However the 'clean' values from kkit
// are the number values numKf and numKb. In the
// function convertReacRatesToNumUnits we take the numKf and numKb and
// do proper conc scaling.
Field< double >::set( reac, "Kf", kf );
Field< double >::set( reac, "Kb", kb );
Id info = buildInfo( reac, reacMap_, args );
numReacs_++;
return reac;
}
void VersionInfoInterface::logBuildInfo() const {
log() << "git version: " << gitVersion();
#if defined(MONGO_CONFIG_SSL) && MONGO_CONFIG_SSL_PROVIDER == MONGO_CONFIG_SSL_PROVIDER_OPENSSL
log() << openSSLVersion("OpenSSL version: ");
#endif
log() << "allocator: " << allocator();
std::stringstream ss;
ss << "modules: ";
auto modules_list = modules();
if (modules_list.size() == 0) {
ss << "none";
} else {
for (const auto& m : modules_list) {
ss << m << " ";
}
}
log() << ss.str();
log() << "build environment:";
for (auto&& envDataEntry : buildInfo()) {
if (std::get<3>(envDataEntry)) {
auto val = std::get<1>(envDataEntry);
if (val.size() == 0)
continue;
log() << " " << std::get<0>(envDataEntry) << ": " << std::get<1>(envDataEntry);
}
}
}
/**
* There is a problem with this conversion, because of the discrepancy of
* the correct NA and the version (6e23) used in kkit. I take the
* concentration as authoritative, not the # of molecules. This is because
* I use conc units for the rates as well, and to use n for pools and
* conc for reactions will always introduce errors. This is still not
* a great solution, because, for example, simulations involving receptor
* traffic are originally framed in terms of number of receptors, not conc.
*/
Id ReadKkit::buildPool( const vector< string >& args )
{
string head;
string clean = cleanPath( args[2] );
string tail = pathTail( clean, head );
Id pa = shell_->doFind( head ).id;
assert( pa != Id() );
double nInit = atof( args[ poolMap_[ "nInit" ] ].c_str() );
double vsf = atof( args[ poolMap_[ "vol" ] ].c_str() );
/**
* vsf is vol scale factor, which is what GENESIS stores in 'vol' field
* n = vsf * conc( uM )
* Also, n = ( conc (uM) / 1e6 ) * NA * vol
* so, vol = 1e6 * vsf / NA
*/
double vol = 1.0e3 * vsf / KKIT_NA; // Converts volscale to actual vol in m^3
int slaveEnable = atoi( args[ poolMap_[ "slave_enable" ] ].c_str() );
double diffConst = atof( args[ poolMap_[ "DiffConst" ] ].c_str() );
// I used -ve D as a flag to replace pool-specific D
// with the global value of D. Here we just ignore it.
if ( diffConst < 0 )
diffConst = 0;
Id pool;
if ( slaveEnable == 0 ) {
pool = shell_->doCreate( "Pool", pa, tail, 1 );
} else if ( slaveEnable & 4 ) {
pool = shell_->doCreate( "BufPool", pa, tail, 1 );
} else {
pool = shell_->doCreate( "Pool", pa, tail, 1 );
/*
cout << "ReadKkit::buildPool: Unknown slave_enable flag '" <<
slaveEnable << "' on " << clean << "\n";
*/
poolFlags_[pool] = slaveEnable;
}
assert( pool != Id() );
// skip the 10 chars of "/kinetics/"
poolIds_[ clean.substr( 10 ) ] = pool;
Field< double >::set( pool, "nInit", nInit );
Field< double >::set( pool, "diffConst", diffConst );
// SetGet1< double >::set( pool, "setVolume", vol );
separateVols( pool, vol );
poolVols_[pool] = vol;
Id info = buildInfo( pool, poolMap_, args );
/*
cout << setw( 20 ) << head << setw( 15 ) << tail << " " <<
setw( 12 ) << nInit << " " <<
vol << " " << diffConst << " " <<
slaveEnable << endl;
*/
numPools_++;
return pool;
}
/*! Constructor
* \param[in] name name for the log file
* The build parameters are logged first
*/
logger(const std::string & name, printLevel print = coarse)
: globalPrintLevel_(print), policy_(new logPolicy)
{
if(!policy_) {
PCMSOLVER_ERROR("LOGGER: Unable to create the logger instance");
}
policy_->open_ostream(name);
// Write the logfile header
logStream_ << "\t\tPCMSolver execution log\n"
<< buildInfo() << "\n\t\tLog started : " << getTime() << std::endl;
}
/* affichage */
void display(void)
{
glEnable(GL_DEPTH_TEST);
glClear (GL_COLOR_BUFFER_BIT);
glClear (GL_DEPTH_BUFFER_BIT);
glPushMatrix();
buildInfo();
buildPlateau();
buildSnake();
buildNouriture();
glPopMatrix();
glutSwapBuffers();
}
Id ReadKkit::buildGroup( const vector< string >& args )
{
string head;
string tail = pathTail( cleanPath( args[2] ), head );
Id pa = shell_->doFind( head ).id;
assert( pa != Id() );
Id group = shell_->doCreate( "Neutral", pa, tail, 1 );
assert( group != Id() );
Id info = buildInfo( group, groupMap_, args );
numOthers_++;
return group;
}
void VersionInfoInterface::appendBuildInfo(BSONObjBuilder* result) const {
*result << "version" << version() << "gitVersion" << gitVersion()
#if defined(_WIN32)
<< "targetMinOS" << targetMinOS()
#endif
<< "modules" << modules() << "allocator" << allocator() << "javascriptEngine"
<< jsEngine() << "sysInfo"
<< "deprecated";
BSONArrayBuilder versionArray(result->subarrayStart("versionArray"));
versionArray << majorVersion() << minorVersion() << patchVersion() << extraVersion();
versionArray.done();
BSONObjBuilder opensslInfo(result->subobjStart("openssl"));
#ifdef MONGO_CONFIG_SSL
#if MONGO_CONFIG_SSL_PROVIDER == MONGO_CONFIG_SSL_PROVIDER_OPENSSL
opensslInfo << "running" << openSSLVersion() << "compiled" << OPENSSL_VERSION_TEXT;
#elif MONGO_CONFIG_SSL_PROVIDER == MONGO_CONFIG_SSL_PROVIDER_WINDOWS
opensslInfo << "running"
<< "Windows SChannel";
#elif MONGO_CONFIG_SSL_PROVIDER == MONGO_CONFIG_SSL_PROVIDER_APPLE
opensslInfo << "running"
<< "Apple Secure Transport";
#else
#error "Unknown SSL Provider"
#endif // MONGO_CONFIG_SSL_PROVIDER
#else
opensslInfo << "running"
<< "disabled"
<< "compiled"
<< "disabled";
#endif
opensslInfo.done();
BSONObjBuilder buildvarsInfo(result->subobjStart("buildEnvironment"));
for (auto&& envDataEntry : buildInfo()) {
if (std::get<2>(envDataEntry)) {
buildvarsInfo << std::get<0>(envDataEntry) << std::get<1>(envDataEntry);
}
}
buildvarsInfo.done();
*result << "bits" << (int)sizeof(void*) * 8;
result->appendBool("debug", kDebugBuild);
result->appendNumber("maxBsonObjectSize", BSONObjMaxUserSize);
}
/**
* @brief Returns commands that overlap c, but will not be canceled by c
* @return a vector containing commands that overlap c
*/
std::vector<Command> CCommandAI::GetOverlapQueued(Command &c){
std::deque<Command>::iterator ci = commandQue.end();
std::vector<Command> v;
BuildInfo buildInfo(c);
if(ci != commandQue.begin()){
do{
--ci; //iterate from the end and dont check the current order
if((ci->id==c.id || (c.id<0 && ci->id<0)) && ci->params.size()==c.params.size()){
if(c.params.size()==1) //we assume the param is a unit or feature id
{
if(ci->params[0]==c.params[0])
v.push_back(*ci);
}
else if(c.params.size()>=3) //we assume this means that the first 3 makes a position
{
BuildInfo other;
if(other.Parse(*ci)){
if(buildInfo.def && other.def
&& (fabs(buildInfo.pos.x-other.pos.x)*2 > max(buildInfo.GetXSize(), other.GetXSize())*SQUARE_SIZE
|| fabs(buildInfo.pos.z-other.pos.z)*2 > max(buildInfo.GetYSize(), other.GetYSize())*SQUARE_SIZE)
&& fabs(buildInfo.pos.x-other.pos.x)*2 < (buildInfo.GetXSize() + other.GetXSize())*SQUARE_SIZE
&& fabs(buildInfo.pos.z-other.pos.z)*2 < (buildInfo.GetYSize() + other.GetYSize())*SQUARE_SIZE)
{
v.push_back(*ci);
}
} else {
if((buildInfo.pos-other.pos).SqLength2D()<17*17)
v.push_back(*ci);
}
}
}
}while(ci!=commandQue.begin());
}
return v;
}
void BatchBuildDlg::GetBuildInfoList(std::list<QueueCommand>& buildInfoList)
{
bool clean_log(true);
for (unsigned int i=0; i<m_checkListConfigurations->GetCount(); i++) {
if (m_checkListConfigurations->IsChecked(i)) {
wxString text = m_checkListConfigurations->GetString(i);
wxString project = text.BeforeFirst(wxT('|'));
wxString config = text.AfterFirst(wxT('|'));
project.Trim().Trim(false);
config.Trim().Trim(false);
// get the selected configuration to be built
BuildConfigPtr bldConf = WorkspaceST::Get()->GetProjBuildConf(project, config);
if (bldConf) {
QueueCommand buildInfo(project, config, true, m_cmd);
// handle custom build projects properly
if (bldConf->IsCustomBuild()) {
buildInfo.SetKind(QueueCommand::kCustomBuild);
switch (m_cmd) {
case QueueCommand::kBuild:
buildInfo.SetCustomBuildTarget(wxT("Build"));
break;
case QueueCommand::kClean:
buildInfo.SetCustomBuildTarget(wxT("Clean"));
break;
}
}
buildInfo.SetCleanLog(clean_log);
buildInfoList.push_back(buildInfo);
clean_log = false;
}
}
}
}
int main (int argc, char **argv)
{
// our invocation information
InstanceInfo instanceInfo;
// fill in the structure for the invocation
buildInfo(&instanceInfo, argc, argv);
// this can be done using either RexxCreateInterpreter or RexxStart
if (instanceInfo.callType == InstanceInfo::INSTANCE)
{
// go invoke this
invokeProgram(&instanceInfo);
}
else
{
invokeRexxStart(&instanceInfo);
}
// if no error, then push the return result on to the queue
if (instanceInfo.rc == 0)
{
CONSTRXSTRING result;
MAKERXSTRING(result, instanceInfo.returnResult, strlen(instanceInfo.returnResult));
RexxAddQueue("TESTQUEUE", &result, RXQUEUE_LIFO);
}
else
{
CONSTRXSTRING result;
char errorResult[50];
sprintf(errorResult, "%d %d", instanceInfo.rc, instanceInfo.code);
MAKERXSTRING(result, errorResult, strlen(errorResult));
RexxAddQueue("TESTQUEUE", &result, RXQUEUE_LIFO);
}
return (int)instanceInfo.rc; // return the error indicator
}
Id ReadKkit::buildEnz( const vector< string >& args )
{
string head;
string clean = cleanPath( args[2] );
string tail = pathTail( clean, head );
Id pa = shell_->doFind( head ).id;
assert ( pa != Id() );
double k1 = atof( args[ enzMap_[ "k1" ] ].c_str() );
double k2 = atof( args[ enzMap_[ "k2" ] ].c_str() );
double k3 = atof( args[ enzMap_[ "k3" ] ].c_str() );
// double volscale = atof( args[ enzMap_[ "vol" ] ].c_str() );
double nComplexInit =
atof( args[ enzMap_[ "nComplexInit" ] ].c_str() );
// double vol = atof( args[ enzMap_[ "vol" ] ].c_str());
bool isMM = atoi( args[ enzMap_[ "usecomplex" ] ].c_str());
assert( poolVols_.find( pa ) != poolVols_.end() );
// double vol = poolVols_[ pa ];
/**
* vsf is vol scale factor, which is what GENESIS stores in 'vol' field
* n = vsf * conc( uM )
* Also, n = ( conc (uM) / 1e6 ) * NA * vol
* so, vol = 1e6 * vsf / NA
*/
if ( isMM ) {
Id enz = shell_->doCreate( "MMenz", pa, tail, 1 );
assert( enz != Id () );
string mmEnzPath = clean.substr( 10 );
mmEnzIds_[ mmEnzPath ] = enz;
assert( k1 > EPSILON );
double Km = ( k2 + k3 ) / k1;
Field< double >::set( enz, "Km", Km );
Field< double >::set( enz, "kcat", k3 );
Id info = buildInfo( enz, enzMap_, args );
numMMenz_++;
return enz;
} else {
Id enz = shell_->doCreate( "Enz", pa, tail, 1 );
// double parentVol = Field< double >::get( pa, "volume" );
assert( enz != Id () );
string enzPath = clean.substr( 10 );
enzIds_[ enzPath ] = enz;
// Need to figure out what to do about these. Perhaps it is OK
// to do this assignments in raw #/cell units.
Field< double >::set( enz, "k3", k3 );
Field< double >::set( enz, "k2", k2 );
Field< double >::set( enz, "k1", k1 );
string cplxName = tail + "_cplx";
string cplxPath = enzPath + "/" + cplxName;
Id cplx = shell_->doCreate( "Pool", enz, cplxName, 1 );
assert( cplx != Id () );
poolIds_[ cplxPath ] = cplx;
// Field< double >::set( cplx, "nInit", nComplexInit );
Field< double >::set( cplx, "nInit", nComplexInit );
// Use this later to assign mesh entries to enz cplx.
enzCplxMols_.push_back( pair< Id, Id >( pa, cplx ) );
separateVols( cplx, -1 ); // -1 vol is a flag to defer mesh assignment for the cplx pool.
ObjId ret = shell_->doAddMsg( "OneToAll",
ObjId( enz, 0 ), "cplx",
ObjId( cplx, 0 ), "reac" );
assert( ret != ObjId() );
// cplx()->showFields();
// enz()->showFields();
// pa()->showFields();
Id info = buildInfo( enz, enzMap_, args );
numEnz_++;
return enz;
}
}
QString Quassel::configDirPath() {
if(!_configDirPath.isEmpty())
return _configDirPath;
if(Quassel::isOptionSet("datadir")) {
qWarning() << "Obsolete option --datadir used!";
_configDirPath = Quassel::optionValue("datadir");
} else if(Quassel::isOptionSet("configdir")) {
_configDirPath = Quassel::optionValue("configdir");
} else {
#ifdef Q_WS_MAC
// On Mac, the path is always the same
_configDirPath = QDir::homePath() + "/Library/Application Support/Quassel/";
#else
// We abuse QSettings to find us a sensible path on the other platforms
# ifdef Q_WS_WIN
// don't use the registry
QSettings::Format format = QSettings::IniFormat;
# else
QSettings::Format format = QSettings::NativeFormat;
# endif
QSettings s(format, QSettings::UserScope, QCoreApplication::organizationDomain(), buildInfo().applicationName);
QFileInfo fileInfo(s.fileName());
_configDirPath = fileInfo.dir().absolutePath();
#endif /* Q_WS_MAC */
}
if(!_configDirPath.endsWith(QDir::separator()) && !_configDirPath.endsWith('/'))
_configDirPath += QDir::separator();
QDir qDir(_configDirPath);
if(!qDir.exists(_configDirPath)) {
if(!qDir.mkpath(_configDirPath)) {
qCritical() << "Unable to create Quassel config directory:" << qPrintable(qDir.absolutePath());
return QString();
}
}
return _configDirPath;
}
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
Foam::cfdemCloud::cfdemCloud
(
const fvMesh& mesh
)
:
mesh_(mesh),
couplingProperties_
(
IOobject
(
"couplingProperties",
mesh_.time().constant(),
mesh_,
IOobject::MUST_READ,
IOobject::NO_WRITE
)
),
liggghtsCommandDict_
(
IOobject
(
"liggghtsCommands",
mesh_.time().constant(),
mesh_,
IOobject::MUST_READ,
IOobject::NO_WRITE
)
),
solveFlow_(true),
solveScalarTransport_(true),
verbose_(false),
debug_(false),
allowCFDsubTimestep_(true),
ignore_(false),
modelType_(couplingProperties_.lookup("modelType")),
positions_(NULL),
velocities_(NULL),
fluidVel_(NULL),
fAcc_(NULL),
impForces_(NULL),
expForces_(NULL),
DEMForces_(NULL),
Cds_(NULL),
radii_(NULL),
voidfractions_(NULL),
cellIDs_(NULL),
particleWeights_(NULL),
particleVolumes_(NULL),
particleV_(NULL),
dragPrev_(NULL),
numberOfParticles_(0),
d32_(-1),
numberOfParticlesChanged_(false),
arraysReallocated_(false),
forceModels_(couplingProperties_.lookup("forceModels")),
momCoupleModels_(couplingProperties_.lookup("momCoupleModels")),
liggghtsCommandModelList_(liggghtsCommandDict_.lookup("liggghtsCommandModels")),
turbulenceModelType_(couplingProperties_.lookup("turbulenceModelType")),
isLES_(false),
cg_(1.),
cgOK_(true),
impDEMdrag_(false),
impDEMdragAcc_(false),
imExSplitFactor_(1.0),
treatVoidCellsAsExplicitForce_(false),
useDDTvoidfraction_("off"),
ddtVoidfraction_
(
IOobject
(
"ddtVoidfraction",
mesh.time().timeName(),
mesh,
IOobject::NO_READ,
IOobject::AUTO_WRITE
),
mesh,
dimensionedScalar("zero", dimensionSet(0,0,-1,0,0), 0) // 1/s
),
checkPeriodicCells_(false),
turbulence_
(
#if defined(version24Dev)
mesh.lookupObject<turbulenceModel>
#elif defined(version21) || defined(version16ext)
#ifdef compre
mesh.lookupObject<compressible::turbulenceModel>
#else
mesh.lookupObject<incompressible::turbulenceModel>
#endif
#elif defined(version15)
mesh.lookupObject<incompressible::RASModel>
#endif
(
turbulenceModelType_
)
),
turbulenceMultiphase_
(
IOobject
(
"turbulenceMultiphase",
mesh.time().timeName(),
mesh,
IOobject::NO_READ,
IOobject::AUTO_WRITE
),
mesh,
#ifdef compre
dimensionedScalar("zero", dimensionSet(1,-1,-1,0,0), 0) // kg/m/s
#else
dimensionedScalar("zero", dimensionSet(0,2,-1,0,0), 0) // m²/s
#endif
),
locateModel_
(
locateModel::New
(
couplingProperties_,
*this
)
),
/*momCoupleModel_
(
momCoupleModel::New
(
couplingProperties_,
*this
)
),*/
dataExchangeModel_
(
dataExchangeModel::New
(
couplingProperties_,
*this
)
),
IOModel_
(
IOModel::New
(
couplingProperties_,
*this
)
),
probeModel_
(
probeModel::New
(
couplingProperties_,
*this,
(char *)"none",
(char *)"none"
)
),
voidFractionModel_
(
voidFractionModel::New
(
couplingProperties_,
*this
)
),
averagingModel_
(
averagingModel::New
(
couplingProperties_,
*this
)
),
clockModel_
(
clockModel::New
(
couplingProperties_,
*this
)
),
smoothingModel_
(
smoothingModel::New
(
couplingProperties_,
*this
)
),
meshMotionModel_
(
meshMotionModel::New
(
couplingProperties_,
*this
)
)
{
#include "versionInfo.H"
global buildInfo(couplingProperties_,*this);
buildInfo.info();
//-- apply debug Mode to sub models
// set debug flag according to env
debug_ = buildInfo.debugMode();
// overwrite debug flag if found in dict
if (couplingProperties_.found("debug"))
debug_=Switch(couplingProperties_.lookup("debug"));
// apply flag
if(!debugMode()) ddtVoidfraction_.writeOpt() = IOobject::NO_WRITE;
if(!debugMode()) turbulenceMultiphase_.writeOpt() = IOobject::NO_WRITE;
voidFractionM().applyDebugSettings(debugMode());
averagingM().applyDebugSettings(debugMode());
//--
dataExchangeM().setCG();
Info << "If BC are important, please provide volScalarFields -imp/expParticleForces-" << endl;
if (couplingProperties_.found("solveFlow"))
solveFlow_=Switch(couplingProperties_.lookup("solveFlow"));
if (couplingProperties_.found("solveScalarTransport"))
solveScalarTransport_=Switch(couplingProperties_.lookup("solveScalarTransport"));
if (couplingProperties_.found("imExSplitFactor"))
imExSplitFactor_ = readScalar(couplingProperties_.lookup("imExSplitFactor"));
if(imExSplitFactor_>1.0)
FatalError << "You have set imExSplitFactor > 1 in your couplingProperties. Must be <=1."
<< abort(FatalError);
if(imExSplitFactor_<0.0)
FatalError << "You have set imExSplitFactor < 0 in your couplingProperties. Must be >=0"
<< abort(FatalError);
if (couplingProperties_.found("treatVoidCellsAsExplicitForce"))
treatVoidCellsAsExplicitForce_ = readBool(couplingProperties_.lookup("treatVoidCellsAsExplicitForce"));
if (couplingProperties_.found("verbose")) verbose_=true;
if (couplingProperties_.found("ignore")) ignore_=true;
if (turbulenceModelType_=="LESProperties")
{
isLES_ = true;
Info << "WARNING - LES functionality not yet tested!" << endl;
}
if (couplingProperties_.found("useDDTvoidfraction"))
{
useDDTvoidfraction_=word(couplingProperties_.lookup("useDDTvoidfraction"));
if(useDDTvoidfraction_==word("a") ||
useDDTvoidfraction_==word("b") ||
useDDTvoidfraction_==word("off")
)
Info << "choice for ddt(voidfraction) = " << useDDTvoidfraction_ << endl;
else
FatalError << "Model " << useDDTvoidfraction_
<< " is not a valid choice for ddt(voidfraction). Choose a or b or off."
<< abort(FatalError);
}
else
Info << "ignoring ddt(voidfraction)" << endl;
forceModel_ = new autoPtr<forceModel>[nrForceModels()];
for (int i=0;i<nrForceModels();i++)
{
forceModel_[i] = forceModel::New
(
couplingProperties_,
*this,
forceModels_[i]
);
forceModel_[i]().applyDebugSettings(debugMode());
}
momCoupleModel_ = new autoPtr<momCoupleModel>[momCoupleModels_.size()];
for (int i=0;i<momCoupleModels_.size();i++)
{
momCoupleModel_[i] = momCoupleModel::New
(
couplingProperties_,
*this,
momCoupleModels_[i]
);
momCoupleModel_[i]().applyDebugSettings(debugMode());
}
// run liggghts commands from cfdem
liggghtsCommand_ = new autoPtr<liggghtsCommandModel>[liggghtsCommandModelList_.size()];
for (int i=0;i<liggghtsCommandModelList_.size();i++)
{
liggghtsCommand_[i] = liggghtsCommandModel::New
(
liggghtsCommandDict_,
*this,
liggghtsCommandModelList_[i],
i
);
}
Switch cgWarnOnly_(couplingProperties_.lookupOrDefault<Switch>("cgWarnOnly", true));
if (!cgOK_ && cg_ > 1)
{
if(cgWarnOnly_)
Warning<< "at least one of your models is not fit for cg !!!"<< endl;
else
FatalError<< "at least one of your models is not fit for cg !!!"<< abort(FatalError);
}
// check if sim is fully peridic box
const polyBoundaryMesh& patches = mesh_.boundaryMesh();
int nPatchesCyclic(0);
int nPatchesNonCyclic(0);
forAll(patches, patchI)
{
const polyPatch& pp = patches[patchI];
#if defined(versionExt32)
if (isA<cyclicPolyPatch>(pp))
nPatchesCyclic++;
else if (!isA<processorPolyPatch>(pp))
nPatchesNonCyclic++;
#else
if (isA<cyclicPolyPatch>(pp) || isA<cyclicAMIPolyPatch>(pp))
nPatchesCyclic++;
else if (!isA<processorPolyPatch>(pp))
nPatchesNonCyclic++;
#endif
}
if(nPatchesNonCyclic==0)
checkPeriodicCells_=true;
if(nPatchesCyclic>0 && nPatchesNonCyclic>0)
{
if(verbose_) Info << "nPatchesNonCyclic=" << nPatchesNonCyclic << ", nPatchesCyclic=" << nPatchesCyclic << endl;
Warning << "Periodic handing is disabled because the domain is not fully periodic!\n" << endl;
}
}
