int main()
{
Board p;
SingleCandidate s_c(&p);
SinglePosition s_p(&p);
CandidateLines c_l(&p);
NakedPairs n_p(&p);
int level = 1;
getchar();
int changd = 0;
while(1){
again:
p.display();
getchar();
if(s_c.perform_op()){
changd = 1;
goto again;
}
if(s_p.perform_op()){
level = max(level, 2);
changd =1;
goto again;
}
if(c_l.perform_op()){
level = max(level, 3);
changd=1;
goto again;
}
if(n_p.perform_op()){
level = max(level, 4);
changd=1;
goto again;
}
break;
}
if(!changd)
level = 5;
/*while(1)
{
char g=getchar();
if(g!='\n')
p.display(g-'0');
}*/
//s.perform_op();
//p.display();
printf("Board Level:%d\n", level);
return 0;
}
int main()
{
int i;
i = 1;
while (i <= 100)
{
s_p(i);
i++;
}
return (0);
}
void MixedGradientPressureWeakPeriodic :: computeTangents(FloatMatrix &Ed, FloatArray &Ep, FloatArray &Cd, double &Cp, TimeStep *tStep)
{
//double size = this->domainSize();
// Fetch some information from the engineering model
EngngModel *rve = this->giveDomain()->giveEngngModel();
///@todo Get this from engineering model
std :: unique_ptr< SparseLinearSystemNM > solver(
classFactory.createSparseLinSolver( ST_Petsc, this->domain, this->domain->giveEngngModel() ) ); // = rve->giveLinearSolver();
SparseMtrxType stype = solver->giveRecommendedMatrix(true);
EModelDefaultEquationNumbering fnum;
Set *set = this->giveDomain()->giveSet(this->set);
const IntArray &boundaries = set->giveBoundaryList();
double rve_size = this->domainSize();
// Set up and assemble tangent FE-matrix which will make up the sensitivity analysis for the macroscopic material tangent.
std :: unique_ptr< SparseMtrx > Kff( classFactory.createSparseMtrx(stype) );
if ( !Kff ) {
OOFEM_ERROR("Couldn't create sparse matrix of type %d\n", stype);
}
Kff->buildInternalStructure(rve, this->domain->giveNumber(), fnum);
rve->assemble(*Kff, tStep,TangentStiffnessMatrix, fnum, fnum, this->domain);
// Setup up indices and locations
int neq = Kff->giveNumberOfRows();
// Indices and such of internal dofs
int nsd = this->devGradient.giveNumberOfColumns();
int nd = nsd * ( 1 + nsd ) / 2;
IntArray t_loc, e_loc;
// Fetch the positions;
this->tractionsdman->giveLocationArray( t_id, t_loc, fnum );
this->voldman->giveLocationArray( v_id, e_loc, fnum );
// Matrices and arrays for sensitivities
FloatMatrix ddev_pert(neq, nd);
FloatArray p_pert(neq);
// Solutions for the pertubations:
FloatMatrix s_d(neq, nd);
FloatArray s_p(neq);
// Unit pertubations for d_dev
for ( int i = 1; i <= nd; ++i ) {
FloatMatrix ddev_tmp;
FloatArray tmp(neq), fe, fetot, ddevVoigt(nd);
ddevVoigt.at(i) = 1.0;
this->constructFullMatrixForm(ddev_tmp, ddevVoigt);
for ( int k = 1; k <= boundaries.giveSize() / 2; ++k ) {
Element *e = this->giveDomain()->giveElement( boundaries.at(k * 2 - 1) );
int boundary = boundaries.at(k * 2);
this->integrateTractionDev(fe, e, boundary, ddev_tmp);
fetot.subtract(fe);
}
tmp.assemble(fetot, t_loc);
ddev_pert.setColumn(tmp, i);
}
// Unit pertubation for p
p_pert.zero();
p_pert.at( e_loc.at(1) ) = - 1.0 * rve_size;
// Solve all sensitivities
solver->solve(*Kff, ddev_pert, s_d);
solver->solve(*Kff, p_pert, s_p);
// Extract the tractions from the sensitivity solutions s_d and s_p:
FloatArray tractions_p( t_loc.giveSize() );
FloatMatrix tractions_d(t_loc.giveSize(), nd);
tractions_p.beSubArrayOf(s_p, t_loc);
for ( int i = 1; i <= nd; ++i ) {
for ( int k = 1; k <= t_loc.giveSize(); ++k ) {
tractions_d.at(k, i) = s_d.at(t_loc.at(k), i);
}
}
// The de/dp tangent:
Cp = - s_p.at( e_loc.at(1) );
// The de/dd tangent:
Cd.resize(nd);
if ( nsd == 3 ) {
Cd.at(1) = s_d.at(e_loc.at(1), 1);
Cd.at(2) = s_d.at(e_loc.at(1), 2);
Cd.at(3) = s_d.at(e_loc.at(1), 3);
Cd.at(4) = s_d.at(e_loc.at(1), 4);
Cd.at(5) = s_d.at(e_loc.at(1), 5);
Cd.at(6) = s_d.at(e_loc.at(1), 6);
} else if ( nsd == 2 ) {
Cd.at(1) = s_d.at(e_loc.at(1), 1);
Cd.at(2) = s_d.at(e_loc.at(1), 2);
Cd.at(3) = s_d.at(e_loc.at(1), 3);
}
// The ds/de tangent:
Ep = Cd; // This is much simpler, but it's "only" correct if there is a potential (i.e. symmetric problems). This could be generalized if needed.
// The ds/dd tangent:
Ed.resize(nd, nd);
for ( int dpos = 1; dpos <= nd; ++dpos ) {
FloatArray tractions, sigmaDev;
tractions.beColumnOf(tractions_d, dpos);
this->computeStress(sigmaDev, tractions, rve_size);
Ed.setColumn(sigmaDev, dpos);
}
}
