angularOscillatingDisplacementPointPatchVectorField::
angularOscillatingDisplacementPointPatchVectorField
(
const pointPatch& p,
const DimensionedField<vector, pointMesh>& iF,
const dictionary& dict
)
:
fixedValuePointPatchVectorField(p, iF, dict),
axis_(dict.lookup("axis")),
origin_(dict.lookup("origin")),
angle0_(readScalar(dict.lookup("angle0"))),
amplitude_(readScalar(dict.lookup("amplitude"))),
omega_(readScalar(dict.lookup("omega")))
{
if (!dict.found("value"))
{
updateCoeffs();
}
if (dict.found("p0"))
{
p0_ = vectorField("p0", dict , p.size());
}
else
{
p0_ = p.localPoints();
}
}
void Foam::isentropicTotalTemperatureFvPatchScalarField::updateCoeffs
(
const vectorField& Up
)
{
updateCoeffs();
}
oscillatingVelocityPointPatchVectorField::
oscillatingVelocityPointPatchVectorField
(
const pointPatch& p,
const DimensionedField<vector, pointMesh>& iF,
const dictionary& dict
)
:
fixedValuePointPatchVectorField(p, iF, dict),
amplitude_(dict.lookup("amplitude")),
omega_(readScalar(dict.lookup("omega")))
{
if (!dict.found("value"))
{
updateCoeffs();
}
if (dict.found("p0"))
{
p0_ = vectorField("p0", dict , p.size());
}
else
{
p0_ = p.localPoints();
}
}
timeVaryingMappedFixedValueFvPatchField<Type>::
timeVaryingMappedFixedValueFvPatchField
(
const fvPatch& p,
const DimensionedField<Type, volMesh>& iF,
const dictionary& dict
)
:
fixedValueFvPatchField<Type>(p, iF),
fieldTableName_(iF.name()),
setAverage_(readBool(dict.lookup("setAverage"))),
perturb_(dict.lookupOrDefault("perturb", 1E-5)),
referenceCS_(NULL),
nearestVertex_(0),
nearestVertexWeight_(0),
sampleTimes_(0),
startSampleTime_(-1),
startSampledValues_(0),
startAverage_(pTraits<Type>::zero),
endSampleTime_(-1),
endSampledValues_(0),
endAverage_(pTraits<Type>::zero)
{
dict.readIfPresent("fieldTableName", fieldTableName_);
if (dict.found("value"))
{
fvPatchField<Type>::operator==(Field<Type>("value", dict, p.size()));
}
else
{
updateCoeffs();
}
}
engineTimeVaryingTotalPressureFvPatchScalarField::engineTimeVaryingTotalPressureFvPatchScalarField
(
const fvPatch& p,
const DimensionedField<scalar, volMesh>& iF,
const dictionary& dict
)
:
fixedValueFvPatchScalarField(p, iF),
UName_(dict.lookup("U")),
phiName_(dict.lookup("phi")),
rhoName_(dict.lookup("rho")),
psiName_(dict.lookup("psi")),
gamma_(readScalar(dict.lookup("gamma"))),
p0_("p0", dict, p.size()),
timeDataFileName_(fileName(dict.lookup("timeDataFileName")).expand()),
timeDataPtr_(NULL),
engineDB_((refCast<const engineTime>(this->db().time())))
{
if (dict.found("value"))
{
fvPatchField<scalar>::operator=
(
scalarField("value", dict, p.size())
);
}
else
{
updateCoeffs();
fvPatchField<scalar>::operator=(p0_);
}
}
Foam::
timeVaryingMappedFixedValuePointPatchField<Type>::
timeVaryingMappedFixedValuePointPatchField
(
const pointPatch& p,
const DimensionedField<Type, pointMesh>& iF,
const dictionary& dict
)
:
fixedValuePointPatchField<Type>(p, iF),
fieldTableName_(iF.name()),
setAverage_(readBool(dict.lookup("setAverage"))),
perturb_(dict.lookupOrDefault("perturb", 1E-5)),
mapperPtr_(NULL),
sampleTimes_(0),
startSampleTime_(-1),
startSampledValues_(0),
startAverage_(pTraits<Type>::zero),
endSampleTime_(-1),
endSampledValues_(0),
endAverage_(pTraits<Type>::zero)
{
dict.readIfPresent("fieldTableName", fieldTableName_);
updateCoeffs();
}
void Foam::totalPressureFvPatchScalarField::updateCoeffs()
{
updateCoeffs
(
p0(),
patch().lookupPatchField<volVectorField, vector>(UName())
);
}
PeakController::PeakController( Model * _parent,
PeakControllerEffect * _peak_effect ) :
Controller( Controller::PeakController, _parent, tr( "Peak Controller" ) ),
m_peakEffect( _peak_effect ),
m_currentSample( 0.0f )
{
setSampleExact( true );
if( m_peakEffect )
{
connect( m_peakEffect, SIGNAL( destroyed( ) ),
this, SLOT( handleDestroyedEffect( ) ) );
}
connect( Engine::mixer(), SIGNAL( sampleRateChanged() ), this, SLOT( updateCoeffs() ) );
connect( m_peakEffect->attackModel(), SIGNAL( dataChanged() ), this, SLOT( updateCoeffs() ) );
connect( m_peakEffect->decayModel(), SIGNAL( dataChanged() ), this, SLOT( updateCoeffs() ) );
m_coeffNeedsUpdate = true;
}
void wedgeFvPatchField<scalar>::evaluate(const Pstream::commsTypes)
{
if (!updated())
{
updateCoeffs();
}
operator==(patchInternalField());
}
void Foam::fvPatchField<Type>::evaluate(const Pstream::commsTypes)
{
if (!updated_)
{
updateCoeffs();
}
updated_ = false;
}
void Foam::basicSymmetryFvPatchField<Foam::scalar>::evaluate
(
const Pstream::commsTypes
)
{
if (!updated())
{
updateCoeffs();
}
scalargpuField::operator=(patchInternalField());
transformFvPatchField<scalar>::evaluate();
}
void SRFTotalTemperatureFvPatchScalarField::updateCoeffs()
{
const fvPatchVectorField& U =
patch().lookupPatchField<volVectorField, vector>(UName_);
// If relative, include the effect of the SRF
if (relative_)
{
// Get reference to the SRF model
const SRF::SRFModel& srf =
db().lookupObject<SRF::SRFModel>("SRFProperties");
// Determine patch velocity due to SRF
const vectorField SRFSurfaceNormalVelocity =
srf.velocity(patch().Cf());
updateCoeffs(U - SRFSurfaceNormalVelocity);
}
else
{
updateCoeffs(U);
}
}
Foam::translatingWallVelocityFvPatchVectorField::
translatingWallVelocityFvPatchVectorField
(
const fvPatch& p,
const DimensionedField<vector, volMesh>& iF,
const dictionary& dict
)
:
fixedValueFvPatchField<vector>(p, iF),
U_(Function1<vector>::New("U", dict))
{
// Evaluate the wall velocity
updateCoeffs();
}
rotatingWallVelocityFvPatchVectorField::rotatingWallVelocityFvPatchVectorField
(
const fvPatch& p,
const DimensionedField<vector, volMesh>& iF,
const dictionary& dict
)
:
fixedValueFvPatchField<vector>(p, iF),
origin_(dict.lookup("origin")),
axis_(dict.lookup("axis")),
omega_(readScalar(dict.lookup("omega")))
{
// Evaluate the wall velocity
updateCoeffs();
}
oscillatingDisplacementPointPatchVectorField::
oscillatingDisplacementPointPatchVectorField
(
const pointPatch& p,
const DimensionedField<vector, pointMesh>& iF,
const dictionary& dict
)
:
fixedValuePointPatchVectorField(p, iF, dict),
amplitude_(dict.lookup("amplitude")),
omega_(readScalar(dict.lookup("omega")))
{
if (!dict.found("value"))
{
updateCoeffs();
}
}
void Foam::fluxCorrectedVelocityFvPatchVectorField::evaluate
(
const Pstream::commsTypes
)
{
if (!updated())
{
updateCoeffs();
}
zeroGradientFvPatchVectorField::evaluate();
const surfaceScalarField& phi =
db().lookupObject<surfaceScalarField>(phiName_);
const fvsPatchField<scalar>& phip =
patch().patchField<surfaceScalarField, scalar>(phi);
const vectorgpuField n(patch().nf());
const gpuField<scalar>& magS = patch().magSf();
if (phi.dimensions() == dimVelocity*dimArea)
{
operator==(*this - n*(n & *this) + n*phip/magS);
}
else if (phi.dimensions() == dimDensity*dimVelocity*dimArea)
{
const fvPatchField<scalar>& rhop =
patch().lookupPatchField<volScalarField, scalar>(rhoName_);
operator==(*this - n*(n & *this) + n*phip/(rhop*magS));
}
else
{
FatalErrorIn
(
"fluxCorrectedVelocityFvPatchVectorField::evaluate()"
)
<< "dimensions of phi are incorrect\n"
<< " on patch " << this->patch().name()
<< " of field " << this->dimensionedInternalField().name()
<< " in file " << this->dimensionedInternalField().objectPath()
<< exit(FatalError);
}
}
Foam::waveDisplacementPointPatchVectorField::
waveDisplacementPointPatchVectorField
(
const pointPatch& p,
const DimensionedField<vector, pointMesh>& iF,
const dictionary& dict
)
:
fixedValuePointPatchField<vector>(p, iF, dict),
amplitude_(dict.lookup("amplitude")),
omega_(readScalar(dict.lookup("omega"))),
waveNumber_(dict.lookupOrDefault<vector>("waveNumber", vector::zero))
{
if (!dict.found("value"))
{
updateCoeffs();
}
}
Foam::timeVaryingUniformFixedValueFvPatchField<Type>::
timeVaryingUniformFixedValueFvPatchField
(
const fvPatch& p,
const DimensionedField<Type, volMesh>& iF,
const dictionary& dict
)
:
fixedValueFvPatchField<Type>(p, iF),
timeSeries_(dict)
{
if (dict.found("value"))
{
fvPatchField<Type>::operator==(Field<Type>("value", dict, p.size()));
}
else
{
updateCoeffs();
}
}
sixDoFRigidBodyDisplacementPointPatchVectorField::
sixDoFRigidBodyDisplacementPointPatchVectorField
(
const pointPatch& p,
const DimensionedField<vector, pointMesh>& iF,
const dictionary& dict
)
:
fixedValuePointPatchField<vector>(p, iF, dict),
motion_(dict),
rhoInf_(1.0),
rhoName_(dict.lookupOrDefault<word>("rhoName", "rho")),
lookupGravity_(-1),
g_(vector::zero),
relaxationFactor_(dict.lookupOrDefault<scalar>("relaxationFactor", 1))
{
if (rhoName_ == "rhoInf")
{
rhoInf_ = readScalar(dict.lookup("rhoInf"));
}
if (dict.readIfPresent("g", g_))
{
lookupGravity_ = -2;
}
if (!dict.found("value"))
{
updateCoeffs();
}
if (dict.found("initialPoints"))
{
initialPoints_ = vectorField("initialPoints", dict , p.size());
}
else
{
initialPoints_ = p.localPoints();
}
}
timeVaryingMappedFixedValueFvPatchField<Type>::
timeVaryingMappedFixedValueFvPatchField
(
const fvPatch& p,
const DimensionedField<Type, volMesh>& iF,
const dictionary& dict
)
:
fixedValueFvPatchField<Type>(p, iF),
setAverage_(readBool(dict.lookup("setAverage"))),
referenceCS_(NULL),
nearestVertex_(0),
nearestVertexWeight_(0),
sampleTimes_(0),
startSampleTime_(-1),
startSampledValues_(0),
startAverage_(pTraits<Type>::zero),
endSampleTime_(-1),
endSampledValues_(0),
endAverage_(pTraits<Type>::zero)
{
if (debug)
{
Pout<< "timeVaryingMappedFixedValue : construct from dictionary"
<< endl;
}
if (dict.found("value"))
{
fvPatchField<Type>::operator==(Field<Type>("value", dict, p.size()));
}
else
{
updateCoeffs();
}
}
void engineTimeVaryingTotalPressureFvPatchScalarField::updateCoeffs()
{
updateCoeffs(lookupPatchField<volVectorField, vector>(UName_));
}
int main (int argc, char* argv[])
{
SAMPLE sample; /* training sample */
LEARN_PARM learn_parm;
KERNEL_PARM kernel_parm;
STRUCT_LEARN_PARM struct_parm;
STRUCTMODEL structmodel;
int alg_type;
svm_struct_learn_api_init(argc,argv);
read_input_parameters(argc,argv,trainfile,modelfile,&verbosity,
&struct_verbosity,&struct_parm,&learn_parm,
&kernel_parm,&alg_type);
if(struct_verbosity>=1) {
//verbose = true;
printf("Reading training examples..."); fflush(stdout);
}
/* read the training examples */
sample=read_struct_examples(trainfile,&struct_parm);
if(struct_verbosity>=1) {
printf("done\n"); fflush(stdout);
}
string config_tmp;
bool update_loss_function = false;
if(Config::Instance()->getParameter("update_loss_function", config_tmp)) {
update_loss_function = config_tmp.c_str()[0] == '1';
}
printf("[Main] update_loss_function=%d\n", (int)update_loss_function);
if(!update_loss_function) {
printf("update_loss_function should be true\n");
exit(-1);
}
eUpdateType updateType = UPDATE_NODE_EDGE;
if(Config::Instance()->getParameter("update_type", config_tmp)) {
updateType = (eUpdateType)atoi(config_tmp.c_str());
}
printf("[Main] update_type=%d\n", (int)updateType);
mkdir(loss_dir, 0777);
// check if parameter vector files exist
const char* parameter_vector_dir = "parameter_vector";
int idx = 0;
string parameter_vector_dir_last = findLastFile(parameter_vector_dir, "", &idx);
string parameter_vector_file_pattern = parameter_vector_dir_last + "/iteration_";
int idx_1 = 1;
string parameter_vector_file_last = findLastFile(parameter_vector_file_pattern, ".txt", &idx_1);
printf("[Main] Checking parameter vector file %s\n", parameter_vector_file_last.c_str());
// vectors used to store RF weights
vector<double>* alphas = new vector<double>[sample.n];
vector<double>* alphas_edge = 0;
if(updateType == UPDATE_NODE_EDGE) {
alphas_edge = new vector<double>[sample.n];
}
int alphas_idx = 0;
if(fileExists("alphas.txt") && fileExists(parameter_vector_file_last)) {
// Loading alpha coefficients
ifstream ifs("alphas.txt");
string line;
int lineIdx = 0;
while(lineIdx < sample.n && getline(ifs, line)) {
vector<string> tokens;
splitString(line, tokens);
for(vector<string>::iterator it = tokens.begin();
it != tokens.end(); ++it) {
alphas[lineIdx].push_back(atoi(it->c_str()));
}
++lineIdx;
}
ifs.close();
if(lineIdx > 0) {
alphas_idx = alphas[0].size();
}
// Loading parameters
printf("[Main] Found parameter vector file %s\n", parameter_vector_file_last.c_str());
struct_parm.ssvm_iteration = idx + 1;
update_output_dir(struct_parm.ssvm_iteration);
//EnergyParam param(parameter_vector_file_last.c_str());
//updateCoeffs(sample, param, struct_parm, updateType, alphas, alphas_idx);
//alphas_idx = 1;
} else {
struct_parm.ssvm_iteration = 0;
// insert alpha coefficients for first iteration
for(int i = 0; i < sample.n; ++i) {
alphas[i].push_back(1);
}
ofstream ofs("alphas.txt", ios::app);
int i = 0;
for(; i < sample.n - 1; ++i) {
ofs << alphas[i][alphas_idx] << " ";
}
if(i < sample.n) {
ofs << alphas[i][alphas_idx];
}
ofs << endl;
ofs.close();
// edges
for(int i = 0; i < sample.n; ++i) {
alphas_edge[i].push_back(1);
}
ofstream ofse("alphas_edge.txt", ios::app);
i = 0;
for(; i < sample.n - 1; ++i) {
ofse << alphas_edge[i][alphas_idx] << " ";
}
if(i < sample.n) {
ofse << alphas_edge[i][alphas_idx];
}
ofse << endl;
ofse.close();
++alphas_idx;
}
const int nMaxIterations = 5;
bool bIterate = true;
do {
printf("-----------------------------------------SSVM-ITERATION-%d-START\n",
struct_parm.ssvm_iteration);
struct_parm.iterationId = 1;
/* Do the learning and return structmodel. */
if(alg_type == 0)
svm_learn_struct(sample,&struct_parm,&learn_parm,&kernel_parm,&structmodel,NSLACK_ALG);
else if(alg_type == 1)
svm_learn_struct(sample,&struct_parm,&learn_parm,&kernel_parm,&structmodel,NSLACK_SHRINK_ALG);
else if(alg_type == 2)
svm_learn_struct_joint(sample,&struct_parm,&learn_parm,&kernel_parm,&structmodel,ONESLACK_PRIMAL_ALG);
else if(alg_type == 3)
svm_learn_struct_joint(sample,&struct_parm,&learn_parm,&kernel_parm,&structmodel,ONESLACK_DUAL_ALG);
else if(alg_type == 4)
svm_learn_struct_joint(sample,&struct_parm,&learn_parm,&kernel_parm,&structmodel,ONESLACK_DUAL_CACHE_ALG);
else if(alg_type == 9)
svm_learn_struct_joint_custom(sample,&struct_parm,&learn_parm,&kernel_parm,&structmodel);
else
exit(1);
char _modelfile[BUFFER_SIZE];
//sprintf(_modelfile, "%s_%d", modelfile, struct_parm.ssvm_iteration);
sprintf(_modelfile, "%s_%d", modelfile, struct_parm.ssvm_iteration);
printf("[Main] Writing learned model to %s\n", _modelfile);
write_struct_model(_modelfile, &structmodel, &struct_parm);
// Run inference on training data and increase loss for misclassified points
printf("[Main] Loading learned model to %s\n", _modelfile);
EnergyParam param(_modelfile);
updateCoeffs(sample, param, struct_parm, updateType, alphas, alphas_edge,
struct_parm.ssvm_iteration + 1);
ofstream ofs("alphas.txt", ios::app);
int i = 0;
for(; i < sample.n - 1; ++i) {
ofs << alphas[i][alphas_idx] << " ";
}
if(i < sample.n) {
ofs << alphas[i][alphas_idx];
}
ofs << endl;
ofs.close();
ofstream ofse("alphas_edge.txt", ios::app);
i = 0;
for(; i < sample.n - 1; ++i) {
ofse << alphas_edge[i][alphas_idx] << " ";
}
if(i < sample.n) {
ofse << alphas_edge[i][alphas_idx];
}
ofse << endl;
ofse.close();
++alphas_idx;
printf("-----------------------------------------SSVM-ITERATION-%d-END\n",
struct_parm.ssvm_iteration);
++struct_parm.ssvm_iteration;
bIterate = (nMaxIterations == -1 || struct_parm.ssvm_iteration < nMaxIterations);
} while(bIterate);
// Output final segmentation for all examples
long nExamples = sample.n;
int nRFs = struct_parm.ssvm_iteration;
double* lossPerLabel = 0;
labelType* groundTruthLabels = 0;
for(int i = 0; i < nExamples; i++) { /*** example loop ***/
Slice_P* slice = sample.examples[i].x.slice;
Feature* feature = sample.examples[i].x.feature;
//map<sidType, nodeCoeffType>* nodeCoeffs = sample.examples[i].x.nodeCoeffs;
//map<sidType, edgeCoeffType>* edgeCoeffs = sample.examples[i].x.edgeCoeffs;
map<sidType, nodeCoeffType>* nodeCoeffs = 0;
map<sidType, edgeCoeffType>* edgeCoeffs = 0;
int nNodes = slice->getNbSupernodes();
stringstream soutPb;
soutPb << loss_dir;
soutPb << "pb_";
soutPb << getNameFromPathWithoutExtension(slice->getName());
soutPb << "_";
soutPb << "combined";
//soutPb << setw(5) << setfill('0') << ssvm_iteration;
soutPb << ".tif";
printf("[Main] Exporting %s\n", soutPb.str().c_str());
labelType* inferredLabels =
computeCombinedLabels(slice, feature, groundTruthLabels,
lossPerLabel, nRFs, alphas, i,
nodeCoeffs, edgeCoeffs, soutPb.str().c_str());
stringstream sout;
sout << loss_dir;
sout << getNameFromPathWithoutExtension(slice->getName());
sout << "_";
sout << "combined";
//sout << setw(5) << setfill('0') << ssvm_iteration;
sout << ".tif";
printf("[Main] Exporting %s\n", sout.str().c_str());
slice->exportOverlay(sout.str().c_str(), inferredLabels);
stringstream soutBW;
soutBW << loss_dir;
soutBW << getNameFromPathWithoutExtension(slice->getName());
soutBW << "_";
soutBW << "combined";
//soutBW << setw(5) << setfill('0') << ssvm_iteration;
soutBW << "_BW.tif";
printf("[Main] Exporting %s\n", soutBW.str().c_str());
slice->exportSupernodeLabels(soutBW.str().c_str(),
struct_parm.nClasses,
inferredLabels, nNodes,
&(struct_parm.labelToClassIdx));
delete[] inferredLabels;
}
free_struct_sample(sample);
free_struct_model(structmodel);
svm_struct_learn_api_exit();
return 0;
}
void Foam::timeVaryingMappedTotalPressureFvPatchScalarField::updateCoeffs()
{
updateCoeffs(lookupPatchField<volVectorField, vector>(UName_));
}
void Foam::timeVaryingUniformTotalPressureFvPatchScalarField::updateCoeffs()
{
updateCoeffs(patch().lookupPatchField<volVectorField, vector>(UName_));
}