void _CDECL_ free_polygon_models (void)
{
int i;
LogErr ("unloading poly models\n");
for (i = 0; i < gameData.models.nPolyModels; i++) {
FreeModel (gameData.models.polyModels + i);
FreeModel (gameData.models.defPolyModels + i);
}
}
/*** Liberación de recursos ***/
void Free( void )
{
//Espada
FreeModel( &modeloEspada );
//HUD
glDeleteTextures( 1, &mapTex );
glDeleteTextures( 1, &dotTex );
glDeleteTextures( 1, &UnderwaterTex );
glDeleteTextures(1, &water);
glDeleteTextures(1, &hudNull);
glDeleteTextures(1, &oxBar);
//Terreno
FreeTerrain(&terrain);
//Agua
// FreeTerrain(&agua);
//Skybox
FreeSkybox(&skybox);
// Último
FreeOpenAL();
FreeOpenGL();
}
void IFaceposerModels::CloseAllModels( void )
{
int c = Count();
for ( int i = c - 1; i >= 0; i-- )
{
FreeModel( i );
}
}
XLMachineLearningLibliear::~XLMachineLearningLibliear()
{
for(std::vector<XLMachineLearningLibliear::feature*>::const_iterator it = ProblemX.begin() ; it != ProblemX.end() ; ++it )
{
delete [] *it;
}
FreeModel();
}
md2model::~md2model()
{
FreeModel();
int i;
for (i=0;i<mdl.header.num_frames;++i) {
delete [] vertData[i];
}
delete [] animVerts;
}
/**
* Load an OBJ model from file, in two passes.
*/
int
ReadOBJModel (const char *filename, struct obj_model_t *mdl)
{
FILE *fp;
fp = fopen (filename, "r");
if (!fp)
{
fprintf (stderr, "Error: couldn't open \"%s\"!\n", filename);
return 0;
}
/* reset model data */
memset (mdl, 0, sizeof (struct obj_model_t));
/* first pass: read model info */
if (!FirstPass (fp, mdl))
{
fclose (fp);
return 0;
}
rewind (fp);
/* memory allocation */
if (!MallocModel (mdl))
{
fclose (fp);
FreeModel (mdl);
return 0;
}
/* second pass: read model data */
if (!SecondPass (fp, mdl))
{
fclose (fp);
FreeModel (mdl);
return 0;
}
fclose (fp);
return 1;
}
/*
================
idCollisionModelManagerLocal::WriteCollisionModelForMapEntity
================
*/
bool idCollisionModelManagerLocal::WriteCollisionModelForMapEntity( const idMapEntity *mapEnt, const char *filename, const bool testTraceModel )
{
idFile *fp;
idStr name;
cm_model_t *model;
SetupHash();
model = CollisionModelForMapEntity( mapEnt );
model->name = filename;
name = filename;
name.SetFileExtension( CM_FILE_EXT );
common->Printf( "writing %s\n", name.c_str() );
fp = fileSystem->OpenFileWrite( name, "fs_devpath" );
if( !fp )
{
common->Printf( "idCollisionModelManagerLocal::WriteCollisionModelForMapEntity: Error opening file %s\n", name.c_str() );
FreeModel( model );
return false;
}
// write file id and version
fp->WriteFloatString( "%s \"%s\"\n\n", CM_FILEID, CM_FILEVERSION );
// write the map file crc
fp->WriteFloatString( "%u\n\n", 0 );
// write the collision model
WriteCollisionModel( fp, model );
fileSystem->CloseFile( fp );
if( testTraceModel )
{
idTraceModel trm;
TrmFromModel( model, trm );
}
FreeModel( model );
return true;
}
/**
* Load an OBJ model from file, in two passes.
*/
int LoadOBJ::ReadOBJModel (const char *filename)
{
FILE *fp;
fp = fopen (filename, "r");
if (!fp)
{
fprintf (stderr, "Error: couldn't open \"%s\"!\n", filename);
return 0;
}
//std::cout << "premem" << std::endl;
/* reset model data */
memset (&mdl, 0, sizeof (struct obj_model_t));
//std::cout << "memorioainitializado" << std::endl;
/* first pass: read model info */
if (!FirstPass (fp))
{
fclose (fp);
return 0;
}
rewind (fp);
/* memory allocation */
if (!MallocModel ())
{
fclose (fp);
FreeModel ();
return 0;
}
/* second pass: read model data */
if (!SecondPass (fp))
{
fclose (fp);
FreeModel ();
return 0;
}
fclose (fp);
return 1;
}
REPEAT(MAX_MODELS, i)
{
Model* model = &world->models[i];
if(model->active)
{
Error("Model #%d (%p) was still active when the world was destroyed.",
i, model);
FreeModel(model);
}
FreeShaderVariableSet(world->drawEntries[i].generatedVariableSet);
}
/*
================
idCollisionModelManagerLocal::GenerateCollisionMapForModel
================
*/
void idCollisionModelManagerLocal::GenerateCollisionMapForModel( const char *filename ) {
idFile *fp;
idStr name;
cm_model_t *model;
SetupHash();
model = LoadRenderModel( filename );
if(!model) {
common->Warning("GenerateCollisionMapForModel: failed to generate CM for %s\n", filename);
return;
}
model->name = filename;
name = filename;
name.SetFileExtension( CM_FILE_EXT );
common->Printf( "writing %s\n", name.c_str() );
fp = fileSystem->OpenFileWrite( name, "fs_devpath" );
if ( !fp ) {
common->Printf( "idCollisionModelManagerLocal::WriteCollisionModelForMapEntity: Error opening file %s\n", name.c_str() );
FreeModel( model );
return;
}
// write file id and version
fp->WriteFloatString( "%s \"%s\"\n\n", CM_FILEID, CM_FILEVERSION );
// write the map file crc
fp->WriteFloatString( "%u\n\n", 0 );
// write the collision model
WriteCollisionModel( fp, model );
fileSystem->CloseFile( fp );
FreeModel( model );
}
//学習します。
bool XLMachineLearningLibliear::Train()
{
int maxindex = 0;
for(std::vector<feature*>::const_iterator it = ProblemX.begin() ; it != ProblemX.end() ; ++it )
{
for(feature* nodes = *it; nodes->index != -1 ; ++nodes )
{
maxindex = max(nodes->index,maxindex);
}
}
struct problem prob;
prob.bias = -1; //バイアス？初期化するときの引数で与えるらしいが・・・
prob.l = ProblemY.size(); //行数
prob.n = maxindex; //一番でかい素性番号
prob.y = &ProblemY[0];
prob.x = (::feature_node**) ((feature*) &ProblemX[0]);
struct parameter param;
param.solver_type = L2R_L2LOSS_SVC_DUAL;
param.C = 1;
param.nr_weight = 0;
param.weight_label = NULL;
param.weight = NULL;
{
if(param.solver_type == L2R_LR || param.solver_type == L2R_L2LOSS_SVC)
param.eps = 0.01;
else if(param.solver_type == L2R_L2LOSS_SVC_DUAL || param.solver_type == L2R_L1LOSS_SVC_DUAL || param.solver_type == MCSVM_CS || param.solver_type == L2R_LR_DUAL)
param.eps = 0.1;
else if(param.solver_type == L1R_L2LOSS_SVC || param.solver_type == L1R_LR)
param.eps = 0.01;
}
FreeModel();
this->Model = train(&prob,¶m);
return this->Model != NULL;
}
void
cleanup (obj_model_t objfile)
{
FreeModel (&objfile);
}
bool XLMachineLearningLibliear::LoadModel(const std::string& filename)
{
FreeModel();
this->Model = load_model(filename.c_str());
return true;
}
int main(int argc, char *argv[]) {
char train_file_name[256];
char test_file_name[256];
char output_file_name[256];
char model_file_name[256];
struct Problem *train, *test;
struct Model *model;
int num_correct = 0, num_empty = 0, num_multi = 0, num_incl = 0;
double avg_conf = 0, avg_cred = 0;
const char *error_message;
ParseCommandLine(argc, argv, train_file_name, test_file_name, output_file_name, model_file_name);
error_message = CheckParameter(¶m);
if (error_message != NULL) {
std::cerr << error_message << std::endl;
exit(EXIT_FAILURE);
}
train = ReadProblem(train_file_name);
test = ReadProblem(test_file_name);
std::ofstream output_file(output_file_name);
if (!output_file.is_open()) {
std::cerr << "Unable to open output file: " << output_file_name << std::endl;
exit(EXIT_FAILURE);
}
std::chrono::time_point<std::chrono::steady_clock> start_time = std::chrono::high_resolution_clock::now();
if (param.load_model == 1) {
model = LoadModel(model_file_name);
if (model == NULL) {
exit(EXIT_FAILURE);
}
} else {
model = TrainCP(train, ¶m);
}
if (param.save_model == 1) {
if (SaveModel(model_file_name, model) != 0) {
std::cerr << "Unable to save model file" << std::endl;
}
}
for (int i = 0; i < test->num_ex; ++i) {
double conf, cred;
std::vector<int> predict_label;
predict_label = PredictCP(train, model, test->x[i], conf, cred);
avg_conf += conf;
avg_cred += cred;
output_file << std::resetiosflags(std::ios::fixed) << test->y[i] << ' ' << predict_label[0] << ' '
<< std::setiosflags(std::ios::fixed) << conf << ' ' << cred;
if (predict_label[0] == test->y[i]) {
++num_correct;
}
if (predict_label.size() == 1) {
++num_empty;
output_file << " Empty\n";
} else {
output_file << " set:";
for (size_t j = 1; j < predict_label.size(); ++j) {
output_file << ' ' << predict_label[j];
if (predict_label[j] == test->y[i]) {
++num_incl;
}
}
if (predict_label.size() > 2) {
++num_multi;
output_file << " Multi\n";
} else {
output_file << " Single\n";
}
}
std::vector<int>().swap(predict_label);
}
avg_conf /= test->num_ex;
avg_cred /= test->num_ex;
std::chrono::time_point<std::chrono::steady_clock> end_time = std::chrono::high_resolution_clock::now();
std::cout << "Simple Accuracy: " << 100.0*num_correct/test->num_ex << '%'
<< " (" << num_correct << '/' << test->num_ex << ") "
<< "Mean Confidence: " << std::fixed << std::setprecision(4) << 100*avg_conf << "%, "
<< "Mean Credibility: " << 100*avg_cred << "%\n";
std::cout << "Accuracy: " << 100.0*num_incl/test->num_ex << '%'
<< " (" << num_incl << '/' << test->num_ex << ") "
<< "Multi Prediction: " << std::fixed << std::setprecision(4) << 100.0*num_multi/test->num_ex << "%, "
<< "Empty Prediction: " << 100.0*num_empty/test->num_ex << "%\n";
output_file.close();
std::cout << "Time cost: " << std::chrono::duration_cast<std::chrono::milliseconds>(end_time - start_time).count()/1000.0 << " s\n";
FreeProblem(train);
FreeProblem(test);
FreeModel(model);
FreeParam(¶m);
return 0;
}
bool StudioModel::PostLoadModel( char *modelname )
{
// preload textures
if (m_pstudiohdr->numtextures == 0)
{
char texturename[256];
strcpy( texturename, modelname );
strcpy( &texturename[strlen(texturename) - 4], "T.mdl" );
m_ptexturehdr = LoadModel( texturename );
if (!m_ptexturehdr)
{
FreeModel ();
return false;
}
m_owntexmodel = true;
}
else
{
m_ptexturehdr = m_pstudiohdr;
m_owntexmodel = false;
}
// preload animations
if (m_pstudiohdr->numseqgroups > 1)
{
for (int i = 1; i < m_pstudiohdr->numseqgroups; i++)
{
char seqgroupname[256];
strcpy( seqgroupname, modelname );
sprintf( &seqgroupname[strlen(seqgroupname) - 4], "%02d.mdl", i );
m_panimhdr[i] = LoadModel( seqgroupname );
if (!m_panimhdr[i])
{
FreeModel ();
return false;
}
}
}
SetSequence (0);
SetController (0, 0.0f);
SetController (1, 0.0f);
SetController (2, 0.0f);
SetController (3, 0.0f);
SetMouth (0.0f);
int n;
for (n = 0; n < m_pstudiohdr->numbodyparts; n++)
SetBodygroup (n, 0);
SetSkin (0);
/*
vec3_t mins, maxs;
ExtractBbox (mins, maxs);
if (mins[2] < 5.0f)
m_origin[2] = -mins[2];
*/
return true;
}
int rechenraum::compute(const char *)
{
coDoPolygons *poly;
int i;
char name[256];
// fprintf(stderr, "rechenraum::compute(const char *) entering... \n");
#ifdef USE_STARTFILE
char buf[256];
Covise::getname(buf, startFile->getValue());
// fprintf(stderr, "rechenraum::param = ReadGeometry(%s) ...", buf);
#endif
if (model != NULL)
FreeModel(model);
model = AllocModel();
#ifdef USE_STARTFILE
ReadStartfile(buf, model);
#else
GetParamsFromControlPanel(model);
#endif
if (!model)
{
sendError("Please select a parameter file first!!");
return FAIL;
}
//// Cover plugin information object is created here
createFeedbackObjects();
/////////////////////////////
// create geometry for COVISE
if ((ci = CreateGeometry4Covise(model)))
{
// fprintf(stderr, "rechenraum::compute(const char *): Geometry created\n");
poly = new coDoPolygons(surface->getObjName(),
ci->p->nump,
ci->p->x, ci->p->y, ci->p->z,
ci->vx->num, ci->vx->list,
ci->pol->num, ci->pol->list);
poly->addAttribute("MATERIAL", "metal metal.30");
poly->addAttribute("vertexOrder", "1");
surface->setCurrentObject(poly);
}
else
fprintf(stderr, "Error in CreateGeometry4Covise (%s, %d)\n", __FILE__, __LINE__);
//////////////// This creates the volume grid ////////////////////
////////////////////////
// if button is pushed --> create computation grid
if (p_makeGrid->getValue())
{
int size[2];
if (p_lockmakeGrid->getValue() == 0)
p_makeGrid->setValue(0); // push off button
if (model == NULL)
{
sendError("Cannot create grid because model is NULL!");
return (1);
}
model->spacing = p_gridSpacing->getValue();
model->BCFile = p_BCFile->getValue();
if ((rg = CreateRechGrid(model)) == NULL)
{
fprintf(stderr, "Error in CreateRechGrid!\n");
return -1;
}
rg->bc_inval = 100;
rg->bc_outval = 200;
// fprintf(stderr, "rechenraum: Grid created\n");
coDoUnstructuredGrid *unsGrd = new coDoUnstructuredGrid(grid->getObjName(), // name of USG object
rg->e->nume, // number of elements
8 * rg->e->nume, // number of connectivities
rg->p->nump, // number of coordinates
1); // does type list exist?
int *elem, *conn, *type;
float *xc, *yc, *zc;
unsGrd->getAddresses(&elem, &conn, &xc, &yc, &zc);
unsGrd->getTypeList(&type);
// printf("nelem = %d\n", rg->e->nume);
// printf("nconn = %d\n", 8*rg->e->nume);
// printf("nccord = %d\n", rg->p->nump);
int **GgridConn = rg->e->e;
for (i = 0; i < rg->e->nume; i++)
{
*elem = 8 * i;
elem++;
*conn = (*GgridConn)[0];
conn++;
*conn = (*GgridConn)[1];
conn++;
*conn = (*GgridConn)[2];
conn++;
*conn = (*GgridConn)[3];
conn++;
*conn = (*GgridConn)[4];
conn++;
*conn = (*GgridConn)[5];
conn++;
*conn = (*GgridConn)[6];
conn++;
*conn = (*GgridConn)[7];
conn++;
*type = TYPE_HEXAGON;
type++;
GgridConn++;
}
// copy geometry coordinates to unsgrd
memcpy(xc, rg->p->x, rg->p->nump * sizeof(float));
memcpy(yc, rg->p->y, rg->p->nump * sizeof(float));
memcpy(zc, rg->p->z, rg->p->nump * sizeof(float));
// no blades
// no periodic mesh
// no rotating mesh
// ...
unsGrd->addAttribute("number_of_blades", "0");
unsGrd->addAttribute("periodic", "0");
unsGrd->addAttribute("rotating", "0");
unsGrd->addAttribute("revolutions", "0");
unsGrd->addAttribute("walltext", "");
unsGrd->addAttribute("periotext", "");
// set out port
grid->setCurrentObject(unsGrd);
// boundary condition lists
// 1. Cells at walls
poly = new coDoPolygons(bcwall->getObjName(),
rg->p->nump,
rg->p->x, rg->p->y, rg->p->z,
rg->bcwall->num, rg->bcwall->list,
rg->bcwallpol->num, rg->bcwallpol->list);
//poly->addAttribute("MATERIAL","metal metal.30");
poly->addAttribute("vertexOrder", "1");
bcwall->setCurrentObject(poly);
// 2. Cells at outlet
poly = new coDoPolygons(bcout->getObjName(),
rg->p->nump,
rg->p->x, rg->p->y, rg->p->z,
rg->bcout->num, rg->bcout->list,
rg->bcoutpol->num, rg->bcoutpol->list);
//poly->addAttribute("MATERIAL","metal metal.30");
poly->addAttribute("vertexOrder", "1");
bcout->setCurrentObject(poly);
// 3. Cells at inlet
poly = new coDoPolygons(bcin->getObjName(),
rg->p->nump,
rg->p->x, rg->p->y, rg->p->z,
rg->bcin->num, rg->bcin->list,
rg->bcinpol->num, rg->bcinpol->list);
//poly->addAttribute("MATERIAL","metal metal.30");
poly->addAttribute("vertexOrder", "1");
bcin->setCurrentObject(poly);
/*
std::vector<int> checkbcs_vl;
std::vector<int> checkbcs_pl;
for (i=0;i<rg->bcinpol->num;i++)
{
if (rg->bcin_type[i]==107)
{
fprintf(stderr,"%d: %d %d %d %d %d\n",i,rg->bcin->list[4*i+0],rg->bcin->list[4*i+1],rg->bcin->list[4*i+2],rg->bcin->list[4*i+3],rg->bcin_type[i]);
checkbcs_pl.push_back(checkbcs_vl.size());
checkbcs_vl.push_back(rg->bcin->list[4*i+0]);
checkbcs_vl.push_back(rg->bcin->list[4*i+1]);
checkbcs_vl.push_back(rg->bcin->list[4*i+2]);
checkbcs_vl.push_back(rg->bcin->list[4*i+3]);
}
}
poly = new coDoPolygons(bccheck->getObjName(),
rg->p->nump,
rg->p->x, rg->p->y, rg->p->z,
checkbcs_vl.size(), &checkbcs_vl[0],
checkbcs_pl.size(), &checkbcs_pl[0]);
bccheck->setCurrentObject(poly);
*/
// we had several additional info, we should send to the
// Domaindecomposition:
// 0. number of columns per info
// 1. type of node
// 2. type of element
// 3. list of nodes with bc (a node may appear more than one time)
// 4. corresponding type to 3.
// 5. wall
// 6. balance
// 7. pressure
// 8. NULL
coDistributedObject *partObj[10];
int *data;
float *bPtr;
const char *basename = boco->getObjName();
// 0. number of columns per info
sprintf(name, "%s_colinfo", basename);
size[0] = 6;
size[1] = 0;
coDoIntArr *colInfo = new coDoIntArr(name, 1, size);
data = colInfo->getAddress();
data[0] = RG_COL_NODE; // (=2)
data[1] = RG_COL_ELEM; // (=2)
data[2] = RG_COL_DIRICLET; // (=2)
data[3] = RG_COL_WALL; // (=6)
data[4] = RG_COL_BALANCE; // (=6)
data[5] = RG_COL_PRESS; // (=6)
partObj[0] = colInfo;
// 1. type of node
sprintf(name, "%s_nodeinfo", basename);
size[0] = RG_COL_NODE;
size[1] = rg->p->nump;
coDoIntArr *nodeInfo = new coDoIntArr(name, 2, size);
data = nodeInfo->getAddress();
for (i = 0; i < rg->p->nump; i++)
{
*data++ = i + 1; // may be, that we later do it really correct
*data++ = 0; // same comment ;-)
}
partObj[1] = nodeInfo;
// 2. type of element
sprintf(name, "%s_eleminfo", basename);
size[0] = 2;
size[1] = rg->e->nume * RG_COL_ELEM; // uwe: hier wird 4*nume allociert aber nur 2*nume mit Werten gefuellt
coDoIntArr *elemInfo = new coDoIntArr(name, 2, size);
data = elemInfo->getAddress();
for (i = 0; i < rg->e->nume; i++)
{
*data++ = i + 1; // may be, that we later do it really corect
*data++ = 0; // same comment ;-)
}
partObj[2] = elemInfo;
// 3. list of nodes with bc (a node may appear more than one time)
// and its types
sprintf(name, "%s_diricletNodes", basename);
int num_diriclet = rg->bcin_nodes.size();
size[0] = RG_COL_DIRICLET;
size[1] = 5 * (num_diriclet);
coDoIntArr *diricletNodes = new coDoIntArr(name, 2, size);
data = diricletNodes->getAddress();
// 4. corresponding value to 3.
sprintf(name, "%s_diricletValue", basename);
coDoFloat *diricletValues = new coDoFloat(name, 5 * num_diriclet);
diricletValues->getAddress(&bPtr);
for (i = 0; i < rg->bcin_nodes.size(); i++)
{
*data++ = rg->bcin_nodes[i] + 1; // node-number
*data++ = 1; // type of node
*bPtr++ = rg->bcin_velos[5 * i + 0]; // u
*data++ = rg->bcin_nodes[i] + 1; // node-number
*data++ = 2; // type of node
*bPtr++ = rg->bcin_velos[5 * i + 1]; // v
*data++ = rg->bcin_nodes[i] + 1; // node-number
*data++ = 3; // type of node
*bPtr++ = rg->bcin_velos[5 * i + 2]; // w
*data++ = rg->bcin_nodes[i] + 1; // node-number
*data++ = 4; // type of node
*bPtr++ = rg->bcin_velos[5 * i + 4]; // epsilon
*data++ = rg->bcin_nodes[i] + 1; // node-number
*data++ = 5; // type of node
*bPtr++ = rg->bcin_velos[5 * i + 3]; // k
//*data++ = rg->bcin_nodes->list[i]+1; // node-number
//*data++ = 6; // type of node
//*bPtr++ = 0.0; // temperature = 0.
}
partObj[3] = diricletNodes;
partObj[4] = diricletValues;
// 5. wall
sprintf(name, "%s_wallValue", basename);
coDoFloat *wallValues = new coDoFloat(name, rg->bcwallvol->num);
wallValues->getAddress(&bPtr);
size[0] = RG_COL_WALL;
size[1] = rg->bcwallpol->num;
sprintf(name, "%s_wall", basename);
coDoIntArr *faces = new coDoIntArr(name, 2, size);
data = faces->getAddress();
for (i = 0; i < rg->bcwallpol->num; i++) // Achtung bcwall->pol->num != bcwall->vol->num
{
*data++ = rg->bcwall->list[4 * i + 0] + 1;
*data++ = rg->bcwall->list[4 * i + 1] + 1;
*data++ = rg->bcwall->list[4 * i + 2] + 1;
*data++ = rg->bcwall->list[4 * i + 3] + 1;
*data++ = rg->bcwallvol->list[i] + 1;
*data++ = 55; // wall: moving | standing. here: always standing!
*data++ = 0;
}
partObj[5] = faces;
// 6. balance
sprintf(name, "%s_balance", basename);
size[0] = RG_COL_BALANCE;
size[1] = rg->bcinvol.size() + rg->bcoutvol->num;
coDoIntArr *balance = new coDoIntArr(name, 2, size);
data = balance->getAddress();
for (i = 0; i < rg->bcinvol.size(); i++)
{
/*
if (rg->bcin_type[i]==107)
{
fprintf(stderr,"balance107 %d: %d %d %d %d %d\n",i,rg->bcin->list[4*i+0],rg->bcin->list[4*i+1],rg->bcin->list[4*i+2],rg->bcin->list[4*i+3],rg->bcin_type[i]);
}
*/
*data++ = rg->bcin->list[4 * i + 0] + 1;
*data++ = rg->bcin->list[4 * i + 1] + 1;
*data++ = rg->bcin->list[4 * i + 2] + 1;
*data++ = rg->bcin->list[4 * i + 3] + 1;
*data++ = rg->bcinvol[i] + 1;
//*data++ = rg->bc_inval;
*data++ = rg->bcin_type[i];
*data++ = 0;
}
for (i = 0; i < rg->bcoutvol->num; i++)
{
*data++ = rg->bcout->list[4 * i + 0] + 1;
*data++ = rg->bcout->list[4 * i + 1] + 1;
*data++ = rg->bcout->list[4 * i + 2] + 1;
*data++ = rg->bcout->list[4 * i + 3] + 1;
*data++ = rg->bcoutvol->list[i] + 1;
//*data++ = rg->bc_outval;
*data++ = rg->bcout_type[i];
*data++ = 0;
}
partObj[6] = balance;
// 7. pressure bc: outlet elements
sprintf(name, "%s_pressElems", basename);
size[0] = 6;
size[1] = 0;
coDoIntArr *pressElems = new coDoIntArr(name, 2, size);
data = pressElems->getAddress();
// 8. pressure bc: value for outlet elements
sprintf(name, "%s_pressVal", basename);
coDoFloat *pressValues
= new coDoFloat(name, 0);
pressValues->getAddress(&bPtr);
partObj[7] = pressElems;
partObj[8] = NULL;
coDoSet *set = new coDoSet((char *)basename, (coDistributedObject **)partObj);
boco->setCurrentObject(set);
float *xinp = new float[rg->bcin_nodes.size()];
float *yinp = new float[rg->bcin_nodes.size()];
float *zinp = new float[rg->bcin_nodes.size()];
for (i = 0; i < rg->bcin_nodes.size(); i++)
{
xinp[i] = rg->p->x[rg->bcin_nodes[i]];
yinp[i] = rg->p->y[rg->bcin_nodes[i]];
zinp[i] = rg->p->z[rg->bcin_nodes[i]];
}
coDoPoints *in_points;
in_points = new coDoPoints(inpoints->getObjName(), rg->bcin_nodes.size(), xinp, yinp, zinp);
inpoints->setCurrentObject(in_points);
coDoFloat *in_types;
in_types = new coDoFloat(intypes->getObjName(), rg->bcin_type2.size(), &rg->bcin_type2[0]);
intypes->setCurrentObject(in_types);
/*
float *xairp = new float[rg->bcair_nodes->num];
float *yairp = new float[rg->bcair_nodes->num];
float *zairp = new float[rg->bcair_nodes->num];
for (i=0;i<rg->bcair_nodes->num;i++)
{
xairp[i]=rg->p->x[rg->bcair_nodes->list[i]];
yairp[i]=rg->p->y[rg->bcair_nodes->list[i]];
zairp[i]=rg->p->z[rg->bcair_nodes->list[i]];
}
coDoPoints *air_points;
air_points = new coDoPoints(airpoints->getObjName(), rg->bcair_nodes->num, xairp, yairp, zairp);
airpoints->setCurrentObject(air_points);
float *xvenp = new float[rg->bcven_nodes->num];
float *yvenp = new float[rg->bcven_nodes->num];
float *zvenp = new float[rg->bcven_nodes->num];
for (i=0;i<rg->bcven_nodes->num;i++)
{
xvenp[i]=rg->p->x[rg->bcven_nodes->list[i]];
yvenp[i]=rg->p->y[rg->bcven_nodes->list[i]];
zvenp[i]=rg->p->z[rg->bcven_nodes->list[i]];
}
coDoPoints *ven_points;
ven_points = new coDoPoints(venpoints->getObjName(), rg->bcven_nodes->num, xvenp, yvenp, zvenp);
venpoints->setCurrentObject(ven_points);
*/
const char *geofile = p_geofile->getValue();
const char *rbfile = p_rbfile->getValue();
if (p_createGeoRbFile->getValue())
{
CreateGeoRbFile(rg, geofile, rbfile);
}
}
///////////////////////// Free everything ////////////////////////////////
return SUCCESS;
}
ISimpleSubtractorImpl::~ISimpleSubtractorImpl()
{
FreeModel();
}
void
cleanup ()
{
FreeModel (&objfile);
}
