int Polygon::NumberOfParallelSides() const { //returns number of parallel sides
int count = 0;
std::vector<Vector> sides;
for (unsigned int i=0; i<points.size() ; i++) { //create vector of sides (Vectors)
if (i==points.size()-1) {
sides.push_back(Vector(points[i],points[0]));
}
else {
sides.push_back(Vector(points[i],points[i+1]));
}
}
for (unsigned int i=0;i<points.size();i++) { //check other sides with parallel function
for (unsigned int n=i+1;n<points.size();n++) { //initialize at i+1 to avoid repeats
if (n==points.size()) {
if (Parallel(sides[i],sides[0])) {
count++;
}
}
else {
if (Parallel(sides[i],sides[n])) {
count++;
}
}
}
}
return count;
}
int main()
{
pf("\n S-eries Circuit\n P-arallel Circuit");
pf("\n\n Choose a circuit : ");
c=getche();
system("cls");
switch (c){
case 's' : case 'S':
pf("\t Series Circuit");
Value();
system("cls");
Series();
break;
case 'p' :case 'P' :
pf(" \t Parallel Circuit");
Value();
system("cls");
Parallel();
break;
default :
pf("\t %c is invalid !\n",c);
main();
break;
}
}
BOOL CPlane::Coplanar(CPlane* psOther)
{
if (Parallel(psOther))
{
if (On(psOther->mpsPosition))
{
return TRUE;
}
}
return FALSE;
}
double Dist2(const Line2d & g, const Line2d & h )
{
double dd = 0.0, d1,d2,d3,d4;
Point2d cp = CrossPoint(g,h);
if ( Parallel(g,h) || !IsOnLine(g,cp) || !IsOnLine(h,cp) )
{
d1 = Dist2(g.P1(),h.P1());
d2 = Dist2(g.P1(),h.P2());
d3 = Dist2(g.P2(),h.P1());
d4 = Dist2(g.P2(),h.P2());
if (d1<d2) d2 = d1;
if (d3<d4) d4 = d3;
dd = ( d2 < d4 ) ? d2 : d4;
}
return dd;
}
int main(){
Mecanismo P = Mecanismo(2);
cube I1__; I1__.zeros(3,3,2);
I1__.slice(0) << 0 << 0 << 0 << endr
<< 0 << 107.307e-6 + 146.869e-6 << 0 << endr
<< 0 << 0 << 107.307e-6 + 146.869e-6 << endr;
I1__.slice(1) << 0 << 0 << 0 << endr
<< 0 << 438.0e-6 << 0 << endr
<< 0 << 0 << 438.0e-6 << endr;
cube I2__; I2__.zeros(3,3,2);
I2__.slice(0) << 0 << 0 << 0 << endr
<< 0 << 107.307e-6 + 188.738e-6 << 0 << endr
<< 0 << 0 << 107.307e-6 + 188.738e-6 << endr;
I2__.slice(1) << 0 << 0 << 0 << endr
<< 0 << 301.679e-6 << 0 << endr
<< 0 << 0 << 301.679e-6 << endr;
Serial RR1 = Serial(2, {0.12, 0.16}, {0.06, 0.078},{0.062, 0.124}, I1__ , {0, 0, 9.8}, &fDH_RR);
Serial RR2 = Serial(2, {0.12, 0.16}, {0.06, 0.058},{0.062, 0.097}, I2__ , {0, 0, 9.8}, &fDH_RR);
Serial **RR_ = new Serial* [2];
RR_[0] = &RR1;
RR_[1] = &RR2;
//Matrizes que descrevem a arquitetura do mecanismo
double l0 = 0.05;
mat D_ = join_vert((mat)eye(2,2),2);
mat E_ = join_diag( Roty(0)(span(0,1),span(0,2)), Roty(PI)(span(0,1),span(0,2)) );
mat F_ = zeros(4,4);
vec f_ = {l0,0,-l0,0};
Parallel Robot = Parallel(2, &P, RR_, 2, {2,4}, D_, E_, F_, f_);
Reference RefObj = Reference(0.12, {0.08, 0.16}, {-0.08, 0.4});
//Plotar área de trabalho
uint nx = 96.0;
uint ny = 56.0;
double lx = 0.24;
double ly = 0.28;
double xi = -lx;
double xf = lx;
double yi = 0.0;
double yf = ly;
double dx = (xf-xi)/(nx-1);
double dy = (yf-yi)/(ny-1);
double dl = 0.5*(dx+dy);
Mat<int> M; M.zeros(nx,ny);
field<mat> fZ_(nx,ny);
field<mat> fMh_(nx,ny);
field<vec> fgh_(nx,ny);
field<vec> fa1_(nx,ny);
field<vec> fa2_(nx,ny);
field<vec> fa12_(nx,ny);
for(uint i=0; i<nx; i++){
for(uint j=0; j<ny; j++){
fZ_(i,j).zeros(2,2);
fMh_(i,j).zeros(2,2);
fgh_(i,j).zeros(2);
fa1_(i,j).zeros(2);
fa2_(i,j).zeros(2);
fa12_(i,j).zeros(2);
}
}
vec v1_ = {1,0};
vec v2_ = {0,1};
vec v12_ = {1,1};
double r = 0.07;
double x0 = 0.0;
double y0 = 0.17;
uint rows = nx;
uint cols = ny;
vec q0_ = {0.823167, 1.81774, 0.823167, 1.81774};
GNR2 gnr2 = GNR2("RK6", &Robot, 1e-6, 30);
//gnr2.Doit(q0_, {0.05,0.08});
//cout << gnr2.convergiu << endl;
//cout << gnr2.x_ << endl;
//cout << gnr2.res_ << endl;
//cout << gnr2.n << endl;
double x;
double y;
mat A2_;
for(uint i=0; i<rows; i++){
for(uint j=0; j<cols; j++){
x = xi + i*dx;
y = yi + j*dy;
gnr2.Doit(q0_, {x, y});
if(gnr2.convergiu){
q0_ = gnr2.x_;
A2_ = join_horiz(Robot.Ah_, join_horiz(Robot.Ao_.col(1), Robot.Ao_.col(3)) );
if(abs(det(Robot.Ao_)) < 1.6*1e-6 || abs(det(A2_)) < 1e-11 ) M(i,j) = 2;
else{
M(i,j) = 1;
Robot.Doit(Robot.q0_, join_vert(v1_, -solve(Robot.Ao_, Robot.Ah_*v1_)) );
fZ_(i,j) = Robot.Z_;
fMh_(i,j) = Robot.dy->Mh_;
fgh_(i,j) = Robot.dy->gh_;
fa1_(i,j) = Robot.dy->vh_;
Robot.Doit(Robot.q0_, Robot.C_*v2_);
fa2_(i,j) = Robot.dy->vh_;
Robot.Doit(Robot.q0_, Robot.C_*v12_);
fa12_(i,j) = Robot.dy->vh_ - fa1_(i,j) - fa2_(i,j);
}
}
gnr2.convergiu = false;
if( ((x - x0)*(x - x0) + (y - y0)*(y - y0) <= (r+dl)*(r+dl) ) && ((x - x0)*(x - x0) + (y - y0)*(y - y0) >= (r-dl)*(r-dl) ) && (M(i,j) != 2) )
M(i,j) = 3;
}
}
for(uint i=0; i<rows; i++){
for(uint j=0; j<cols; j++){
cout << M(i,j) << ";" ;
if(j==cols-1) cout << endl;
}
}
fZ_.save("fZ_field");
fMh_.save("fMh_field");
fgh_.save("fgh_field");
fa1_.save("fa1_field");
fa2_.save("fa2_field");
fa12_.save("fa12_field");
return 0;
}
const Conserved SinkFlux::calcHydroFlux
(const Tessellation& tess,
const vector<Vector2D>& point_velocities,
const vector<ComputationalCell>& cells,
const EquationOfState& eos,
const size_t i) const
{
const Edge& edge = tess.GetEdge(static_cast<int>(i));
const std::pair<bool,bool> flags
(edge.neighbors.first>=0 && edge.neighbors.first<tess.GetPointNo(),
edge.neighbors.second>=0 && edge.neighbors.second<tess.GetPointNo());
assert(flags.first || flags.second);
if(!flags.first){
const size_t right_index =
static_cast<size_t>(edge.neighbors.second);
const ComputationalCell& right_cell = cells[right_index];
if(right_cell.stickers.find("dummy")->second)
return Conserved();
const Vector2D p = Parallel(edge);
const Primitive right = convert_to_primitive(right_cell,eos);
// const Primitive left = reflect(right,p);
const Primitive left = right;
const Vector2D n = remove_parallel_component
(tess.GetMeshPoint(edge.neighbors.second) -
edge.vertices.first, p);
return rotate_solve_rotate_back
(rs_, left, right, 0, n, p);
}
if(!flags.second){
const size_t left_index =
static_cast<size_t>(edge.neighbors.first);
const ComputationalCell& left_cell = cells[left_index];
if(left_cell.stickers.find("dummy")->second)
return Conserved();
const Primitive left = convert_to_primitive(left_cell, eos);
const Vector2D p = Parallel(edge);
// const Primitive right = reflect(left,p);
const Primitive right = left;
const Vector2D n = remove_parallel_component
(edge.vertices.second -
tess.GetMeshPoint(edge.neighbors.first), p);
return rotate_solve_rotate_back
(rs_, left, right, 0, n, p);
}
const size_t left_index =
static_cast<size_t>(edge.neighbors.first);
const size_t right_index =
static_cast<size_t>(edge.neighbors.second);
const ComputationalCell& left_cell = cells[left_index];
const ComputationalCell& right_cell = cells[right_index];
if(left_cell.stickers.find("dummy")->second &&
right_cell.stickers.find("dummy")->second)
return Conserved();
const Vector2D p = Parallel(edge);
const Vector2D n =
tess.GetMeshPoint(edge.neighbors.second) -
tess.GetMeshPoint(edge.neighbors.first);
const double velocity = Projection
(tess.CalcFaceVelocity
(point_velocities[left_index],
point_velocities[right_index],
tess.GetCellCM(edge.neighbors.first),
tess.GetCellCM(edge.neighbors.second),
calc_centroid(edge)),n);
if(left_cell.stickers.find("dummy")->second){
const Primitive right =
convert_to_primitive(right_cell, eos);
ComputationalCell ghost;
ghost.density = right.Density/100;
ghost.pressure = right.Pressure/100;
ghost.velocity = Vector2D(0,0);
const Primitive left = convert_to_primitive(ghost,eos);
/*
ScalarProd(n,right.Velocity) < 0 ? right :
reflect(right,p);
*/
return rotate_solve_rotate_back
(rs_,left,right,velocity,n,p);
}
if(right_cell.stickers.find("dummy")->second){
const Primitive left =
convert_to_primitive(left_cell, eos);
ComputationalCell ghost;
ghost.density = left.Density/100;
ghost.pressure = left.Pressure/100;
ghost.velocity = Vector2D(0,0);
const Primitive right = convert_to_primitive(ghost,eos);
/*
ScalarProd(n,left.Velocity)>0 ?
left : reflect(left,p);
*/
return rotate_solve_rotate_back
(rs_,left,right,velocity,n,p);
}
const Primitive left =
convert_to_primitive(left_cell, eos);
const Primitive right =
convert_to_primitive(right_cell, eos);
return rotate_solve_rotate_back
(rs_,left,right,velocity,n,p);
}
int main( int argc, char *argv[] )
{
FILE *output, *input; // File pointers for the data that will be read in and written out.
double programRunTime; // The amount of time a this program took to complete execution.
int processCount; // The total number of processes we have including PI_Main.
int workerCount; // The max number of workers this program run can utilize.
// Setup our program, calculate how many workers we have.
processCount = PI_Configure( &argc, &argv );
workerCount = processCount - 1;
PI_StartTime();
if(argc != 2){ // If after setting up our program, we don't have a string for a file argument, abort this run.
return ExitFailure(", Error: No input file specified.", __FILE__, __LINE__);
}
// Create the workers based off worker count, and the channels/bundles between the workers and PI_Main.
SetupWorkers(workerCount);
//**********//
PI_StartAll();
//**********//
// File opening
output = fopen("pal.out", "a");
input = fopen(argv[1], "r");
// File error checking.
if(output==NULL){
return ExitFailure("Could not open output file 'pal.out' for appending in current directory.", __FILE__, __LINE__);
}
if(input==NULL){
return ExitFailure("Could not open input file for reading, from path in argv[1].", __FILE__, __LINE__);
}
else{
printf(">> Input file is: '%s'\n", argv[1]);
}
// Run serial or parallel algorithm.
if(workerCount == 0){
Serial(input, output);
}
else{
Parallel(input, output, workerCount);
}
// Clean up our program run.
fclose(output);
fclose(input);
free(toWorker);
free(Worker);
free(result);
printf(">> Exiting... <<\n");
programRunTime = PI_EndTime();
printf("\n\n>>< PROGRAM EXECUTION TIME: (%.2f)s ><<\n\n\n", programRunTime);
PI_StopMain(0);
return EXIT_SUCCESS;
}
