void DeviceObjectDpd_c::formatBytestream( ByteStreamBuffer_c& byteStream, const IsoAgLib::ProcData::ConnectionCapabilities_s& caps ) const {
formatHeader( byteStream );
byteStream.format( ddi() );
byteStream.format( properties( caps.hasPeerControl ) );
byteStream.format( method() );
byteStream.format( m_designator );
byteStream.format( m_dvpObjectId );
}
PClassifier TTreeSplitConstructor_Attribute::operator()(
PStringList &descriptions, PDiscDistribution &subsetSizes, float &quality, int &spentAttribute,
PExampleGenerator gen, const int &weightID,
PDomainContingency dcont, PDistribution apriorClass,
const vector<bool> &candidates,
PClassifier nodeClassifier
)
{ checkProperty(measure);
measure->checkClassTypeExc(gen->domain->classVar->varType);
bool cse = candidates.size()==0;
vector<bool>::const_iterator ci(candidates.begin()), ce(candidates.end());
if (!cse) {
if (noCandidates(candidates))
return returnNothing(descriptions, subsetSizes, quality, spentAttribute);
ci = candidates.begin();
}
int N = gen ? gen->numberOfExamples() : -1;
if (N<0)
N = dcont->classes->cases;
TSimpleRandomGenerator rgen(N);
int thisAttr = 0, bestAttr = -1, wins = 0;
quality = 0.0;
if (measure->needs == TMeasureAttribute::Contingency_Class) {
vector<bool> myCandidates;
if (cse) {
myCandidates.reserve(gen->domain->attributes->size());
PITERATE(TVarList, vi, gen->domain->attributes)
myCandidates.push_back((*vi)->varType == TValue::INTVAR);
}
else {
myCandidates.reserve(candidates.size());
TVarList::const_iterator vi(gen->domain->attributes->begin());
for(; ci != ce; ci++, vi++)
myCandidates.push_back(*ci && ((*vi)->varType == TValue::INTVAR));
}
if (!dcont || dcont->classIsOuter)
dcont = PDomainContingency(mlnew TDomainContingency(gen, weightID, myCandidates));
ci = myCandidates.begin();
ce = myCandidates.end();
TDomainContingency::iterator dci(dcont->begin()), dce(dcont->end());
for(; (ci != ce) && (dci!=dce); dci++, ci++, thisAttr++)
if (*ci && checkDistribution((const TDiscDistribution &)((*dci)->outerDistribution.getReference()), minSubset)) {
float thisMeas = measure->call(thisAttr, dcont, apriorClass);
if ( ((!wins || (thisMeas>quality)) && ((wins=1)==1))
|| ((thisMeas==quality) && rgen.randbool(++wins))) {
quality = thisMeas;
subsetSizes = (*dci)->outerDistribution;
bestAttr = thisAttr;
}
}
}
else if (measure->needs == TMeasureAttribute::DomainContingency) {
if (!dcont || dcont->classIsOuter)
dcont = PDomainContingency(mlnew TDomainContingency(gen, weightID));
TDomainContingency::iterator dci(dcont->begin()), dce(dcont->end());
for(; (cse || (ci!=ce)) && (dci!=dce); dci++, thisAttr++)
if ( (cse || *(ci++))
&& ((*dci)->outerVariable->varType==TValue::INTVAR)
&& checkDistribution((const TDiscDistribution &)((*dci)->outerDistribution.getReference()), minSubset)) {
float thisMeas = measure->call(thisAttr, dcont, apriorClass);
if ( ((!wins || (thisMeas>quality)) && ((wins=1)==1))
|| ((thisMeas==quality) && rgen.randbool(++wins))) {
quality = thisMeas;
subsetSizes = (*dci)->outerDistribution;
bestAttr = thisAttr;
}
}
}
else {
TDomainDistributions ddist(gen, weightID);
TDomainDistributions::iterator ddi(ddist.begin()), dde(ddist.end()-1);
for(; (cse || (ci!=ce)) && (ddi!=dde); ddi++, thisAttr++)
if (cse || *(ci++)) {
TDiscDistribution *discdist = (*ddi).AS(TDiscDistribution);
if (discdist && checkDistribution(*discdist, minSubset)) {
float thisMeas = measure->call(thisAttr, gen, apriorClass, weightID);
if ( ((!wins || (thisMeas>quality)) && ((wins=1)==1))
|| ((thisMeas==quality) && rgen.randbool(++wins))) {
quality = thisMeas;
subsetSizes = PDiscDistribution(*ddi); // not discdist - this would be double wrapping!
bestAttr = thisAttr;
}
}
}
}
if (!wins)
return returnNothing(descriptions, subsetSizes, quality, spentAttribute);
if (quality<worstAcceptable)
return returnNothing(descriptions, subsetSizes, spentAttribute);
PVariable attribute = gen->domain->attributes->at(bestAttr);
TEnumVariable *evar = attribute.AS(TEnumVariable);
if (evar)
descriptions = mlnew TStringList(evar->values.getReference());
else
descriptions = mlnew TStringList(subsetSizes->size(), "");
spentAttribute = bestAttr;
TClassifierFromVarFD *cfv = mlnew TClassifierFromVarFD(attribute, gen->domain, bestAttr, subsetSizes);
cfv->transformUnknowns = false;
return cfv;
}
/*
*************************************************************************
* Set up the initial guess and problem parameters *
* and solve the Stokes problem. We explicitly initialize and *
* deallocate the solver state in this example. *
*************************************************************************
*/
bool Stokes::FAC::solve()
{
if (!d_hierarchy) {
TBOX_ERROR(d_object_name
<< "Cannot solve using an uninitialized object.\n");
}
int ln;
/*
* Fill in the initial guess.
*/
for (ln = 0; ln <= d_hierarchy->getFinestLevelNumber(); ++ln) {
boost::shared_ptr<SAMRAI::hier::PatchLevel> level = d_hierarchy->getPatchLevel(ln);
SAMRAI::hier::PatchLevel::Iterator ip(level->begin());
SAMRAI::hier::PatchLevel::Iterator iend(level->end());
for ( ; ip!=iend; ++ip) {
boost::shared_ptr<SAMRAI::hier::Patch> patch = *ip;
boost::shared_ptr<SAMRAI::pdat::CellData<double> > p =
boost::dynamic_pointer_cast<SAMRAI::pdat::CellData<double> >
(patch->getPatchData(p_id));
boost::shared_ptr<SAMRAI::geom::CartesianPatchGeometry> geom =
boost::dynamic_pointer_cast<SAMRAI::geom::CartesianPatchGeometry>
(patch->getPatchGeometry());
if(p_initial.empty())
{
p->fill(0.0);
}
else
{
const int dim=d_dim.getValue();
const double *dx=geom->getDx();
std::vector<double> xyz(dim);
std::vector<double> dx_p(dim);
for(int d=0;d<dim;++d)
dx_p[d]=(p_initial_xyz_max[d]
- p_initial_xyz_min[d])/(p_initial_ijk[d]-1);
std::vector<int> di(dim);
di[0]=1;
for(int d=1;d<dim;++d)
di[d]=di[d-1]*p_initial_ijk[d-1];
SAMRAI::hier::Box pbox = p->getBox();
SAMRAI::pdat::CellIterator
cend(SAMRAI::pdat::CellGeometry::end(p->getGhostBox()));
for(SAMRAI::pdat::CellIterator
ci(SAMRAI::pdat::CellGeometry::begin(p->getGhostBox()));
ci!=cend; ++ci)
{
const SAMRAI::pdat::CellIndex &c(*ci);
std::vector<double> xyz(dim);
/* VLA's not allowed by clang */
double weight[3][2];
for(int d=0;d<dim;++d)
xyz[d]=geom->getXLower()[d]
+ dx[d]*(c[d]-pbox.lower()[d] + 0.5);
int ijk(0);
std::vector<int> ddi(dim);
for(int d=0;d<dim;++d)
{
int i=static_cast<int>(xyz[d]*(p_initial_ijk[d]-1)
/(p_initial_xyz_max[d]
- p_initial_xyz_min[d]));
i=std::max(0,std::min(p_initial_ijk[d]-1,i));
ijk+=i*di[d];
if(i==p_initial_ijk[d]-1)
{
weight[d][0]=1;
weight[d][1]=0;
ddi[d]=0;
}
else
{
weight[d][1]=
(xyz[d]-(i*dx_p[d] + p_initial_xyz_min[d]))/dx_p[d];
weight[d][0]=1-weight[d][1];
ddi[d]=di[d];
}
}
if(dim==2)
{
(*p)(c)=p_initial[ijk]*weight[0][0]*weight[1][0]
+ p_initial[ijk+ddi[0]]*weight[0][1]*weight[1][0]
+ p_initial[ijk+ddi[1]]*weight[0][0]*weight[1][1]
+ p_initial[ijk+ddi[0]+ddi[1]]*weight[0][1]*weight[1][1];
}
else
{
(*p)(c)=p_initial[ijk]*weight[0][0]*weight[1][0]*weight[2][0]
+ p_initial[ijk+ddi[0]]*weight[0][1]*weight[1][0]*weight[2][0]
+ p_initial[ijk+ddi[1]]*weight[0][0]*weight[1][1]*weight[2][0]
+ p_initial[ijk+ddi[0]+ddi[1]]*weight[0][1]*weight[1][1]*weight[2][0]
+ p_initial[ijk+ddi[2]]*weight[0][0]*weight[1][0]*weight[2][1]
+ p_initial[ijk+ddi[0]+ddi[2]]*weight[0][1]*weight[1][0]*weight[2][1]
+ p_initial[ijk+ddi[1]+ddi[2]]*weight[0][0]*weight[1][1]*weight[2][1]
+ p_initial[ijk+ddi[0]+ddi[1]+ddi[2]]*weight[0][1]*weight[1][1]*weight[2][1];
}
}
}
boost::shared_ptr<SAMRAI::pdat::SideData<double> > v =
boost::dynamic_pointer_cast<SAMRAI::pdat::SideData<double> >
(patch->getPatchData(v_id));
v->fill(0.0);
}
d_stokes_fac_solver.set_boundaries(p_id,v_id,level,false);
}
fix_viscosity();
d_stokes_fac_solver.initializeSolverState
(p_id,cell_viscosity_id,edge_viscosity_id,dp_id,p_rhs_id,v_id,v_rhs_id,
d_hierarchy,0,d_hierarchy->getFinestLevelNumber());
SAMRAI::tbox::plog << "solving..." << std::endl;
int solver_ret;
solver_ret = d_stokes_fac_solver.solveSystem(p_id,p_rhs_id,v_id,v_rhs_id);
double avg_factor, final_factor;
d_stokes_fac_solver.getConvergenceFactors(avg_factor, final_factor);
SAMRAI::tbox::plog << "\t" << (solver_ret ? "" : "NOT ") << "converged " << "\n"
<< " iterations: "
<< d_stokes_fac_solver.getNumberOfIterations() << "\n"
<< " residual: "<< d_stokes_fac_solver.getResidualNorm()
<< "\n"
<< " average convergence: "<< avg_factor << "\n"
<< " final convergence: "<< final_factor << "\n"
<< std::flush;
d_stokes_fac_solver.deallocateSolverState();
return solver_ret;
}
