template <typename PointInT, typename PointNT, typename PointOutT> void pcl::GSS3DEstimation<PointInT, PointNT, PointOutT>::computeFeature (PointCloudOut &output) { calculateGeometricScaleSpace (); computeDerivatives (); extractEdges (); }
void GridCell::computeCorrector (long stepNum) { // Values of neighboring cells. us = "u stencil", vs = "v stencil" etc. stencil us, vs, hs, hts; // Call the giveStencil function with corrector setting 'c'. giveStencil(us, vs, hs, hts, 'c'); // Struct to store the corrector derivatives. oneSidedDifferences correctorStep; // Compute corrector in a cyclic manner, alternating the directions of // the x and y differences between forward and backward in a cycle of four. // The directions are always exactly the opposite as in the predictor computation. // This allows for second order accuracy in time and space. switch (stepNum % 4) { case 0: correctorStep = computeDerivatives(us, vs, hs, hts, 'b', 'b'); break; case 1: correctorStep = computeDerivatives(us, vs, hs, hts, 'b', 'f'); break; case 2: correctorStep = computeDerivatives(us, vs, hs, hts, 'f', 'f'); break; case 3: correctorStep = computeDerivatives(us, vs, hs, hts, 'f', 'b'); break; } double duCorrector = correctorStep.du; double dvCorrector = correctorStep.dv; double dhCorrector = correctorStep.dh; // Compute the new values. u = u + 0.5 * (duCorrector + duPredictor) * dt; v = v + 0.5 * (dvCorrector + dvPredictor) * dt; h = h + 0.5 * (dhCorrector + dhPredictor) * dt; if (u < 0) // Clamp slightly such that u is never negative. { u = 0; } htot = h + hsurf; }
// PUBLIC TIME MARCHING METHODS *********************************** void GridCell::computePredictor (long stepNum) { // Values of neighboring cells. us = "u stencil", vs = "v stencil" etc. stencil us, vs, hs, hts; // Call the giveStencil function with predictor setting 'p'. giveStencil(us, vs, hs, hts, 'p'); // Struct to store the predictor derivatives. oneSidedDifferences predictorStep; // Compute predictor in a cyclic manner, alternating the directions of // the x and y differences between forward and backward in a cycle of four. switch (stepNum % 4) { case 0: // Now, both derivatives are approximated using forward differences. predictorStep = computeDerivatives(us, vs, hs, hts, 'f', 'f'); break; case 1: // Now, use forward difference for x and backward for y. predictorStep = computeDerivatives(us, vs, hs, hts, 'f', 'b'); break; case 2: // Backward differences for both. predictorStep = computeDerivatives(us, vs, hs, hts, 'b', 'b'); break; case 3: // Backward for x and forward for y. predictorStep = computeDerivatives(us, vs, hs, hts, 'b', 'f'); break; } // Store the predictor derivatives. duPredictor = predictorStep.du; dvPredictor = predictorStep.dv; dhPredictor = predictorStep.dh; // Compute predictor values. uPredictor = u + duPredictor * dt; vPredictor = v + dvPredictor * dt; hPredictor = h + dhPredictor * dt; htotPredictor = hsurf + hPredictor; }
Fields::Fields(Hamiltonian &ham, ExtrinsicCurvature kij) : k(kij) { // Get data from the Hamiltonian. mass = ham.getBareMass(); sigma = ham.getSingularAngularPart(); regPower = ham.getSingularPower(); u = ham.getRemainder(); // Set up the basis. int* ranks = ham.getRanks(); basis.setRanks(ranks[0], ranks[1]); basis.setMaximumRadius(ham.getMaximumRadius()); computeDerivatives(); delete[] ranks; }
template<typename PointSource, typename PointTarget> void pcl::NormalDistributionsTransform<PointSource, PointTarget>::computeTransformation (PointCloudSource &output, const Eigen::Matrix4f &guess) { nr_iterations_ = 0; converged_ = false; double gauss_c1, gauss_c2, gauss_d3; // Initializes the guassian fitting parameters (eq. 6.8) [Magnusson 2009] gauss_c1 = 10 * (1 - outlier_ratio_); gauss_c2 = outlier_ratio_ / pow (resolution_, 3); gauss_d3 = -log (gauss_c2); gauss_d1_ = -log ( gauss_c1 + gauss_c2 ) - gauss_d3; gauss_d2_ = -2 * log ((-log ( gauss_c1 * exp ( -0.5 ) + gauss_c2 ) - gauss_d3) / gauss_d1_); if (guess != Eigen::Matrix4f::Identity ()) { // Initialise final transformation to the guessed one final_transformation_ = guess; // Apply guessed transformation prior to search for neighbours transformPointCloud (output, output, guess); } // Initialize Point Gradient and Hessian point_gradient_.setZero (); point_gradient_.block<3, 3>(0, 0).setIdentity (); point_hessian_.setZero (); Eigen::Transform<float, 3, Eigen::Affine, Eigen::ColMajor> eig_transformation; eig_transformation.matrix () = final_transformation_; // Convert initial guess matrix to 6 element transformation vector Eigen::Matrix<double, 6, 1> p, delta_p, score_gradient; Eigen::Vector3f init_translation = eig_transformation.translation (); Eigen::Vector3f init_rotation = eig_transformation.rotation ().eulerAngles (0, 1, 2); p << init_translation (0), init_translation (1), init_translation (2), init_rotation (0), init_rotation (1), init_rotation (2); Eigen::Matrix<double, 6, 6> hessian; double score = 0; double delta_p_norm; // Calculate derivates of initial transform vector, subsequent derivative calculations are done in the step length determination. score = computeDerivatives (score_gradient, hessian, output, p); while (!converged_) { // Store previous transformation previous_transformation_ = transformation_; // Solve for decent direction using newton method, line 23 in Algorithm 2 [Magnusson 2009] Eigen::JacobiSVD<Eigen::Matrix<double, 6, 6> > sv (hessian, Eigen::ComputeFullU | Eigen::ComputeFullV); // Negative for maximization as opposed to minimization delta_p = sv.solve (-score_gradient); //Calculate step length with guarnteed sufficient decrease [More, Thuente 1994] delta_p_norm = delta_p.norm (); if (delta_p_norm == 0 || delta_p_norm != delta_p_norm) { trans_probability_ = score / static_cast<double> (input_->points.size ()); converged_ = delta_p_norm == delta_p_norm; return; } delta_p.normalize (); delta_p_norm = computeStepLengthMT (p, delta_p, delta_p_norm, step_size_, transformation_epsilon_ / 2, score, score_gradient, hessian, output); delta_p *= delta_p_norm; transformation_ = (Eigen::Translation<float, 3> (static_cast<float> (delta_p (0)), static_cast<float> (delta_p (1)), static_cast<float> (delta_p (2))) * Eigen::AngleAxis<float> (static_cast<float> (delta_p (3)), Eigen::Vector3f::UnitX ()) * Eigen::AngleAxis<float> (static_cast<float> (delta_p (4)), Eigen::Vector3f::UnitY ()) * Eigen::AngleAxis<float> (static_cast<float> (delta_p (5)), Eigen::Vector3f::UnitZ ())).matrix (); p = p + delta_p; // Update Visualizer (untested) if (update_visualizer_ != 0) update_visualizer_ (output, std::vector<int>(), *target_, std::vector<int>() ); if (nr_iterations_ > max_iterations_ || (nr_iterations_ && (std::fabs (delta_p_norm) < transformation_epsilon_))) { converged_ = true; } nr_iterations_++; } // Store transformation probability. The realtive differences within each scan registration are accurate // but the normalization constants need to be modified for it to be globally accurate trans_probability_ = score / static_cast<double> (input_->points.size ()); }
template<typename PointSource, typename PointTarget> double pcl::NormalDistributionsTransform<PointSource, PointTarget>::computeStepLengthMT (const Eigen::Matrix<double, 6, 1> &x, Eigen::Matrix<double, 6, 1> &step_dir, double step_init, double step_max, double step_min, double &score, Eigen::Matrix<double, 6, 1> &score_gradient, Eigen::Matrix<double, 6, 6> &hessian, PointCloudSource &trans_cloud) { // Set the value of phi(0), Equation 1.3 [More, Thuente 1994] double phi_0 = -score; // Set the value of phi'(0), Equation 1.3 [More, Thuente 1994] double d_phi_0 = -(score_gradient.dot (step_dir)); Eigen::Matrix<double, 6, 1> x_t; if (d_phi_0 >= 0) { // Not a decent direction if (d_phi_0 == 0) return 0; else { // Reverse step direction and calculate optimal step. d_phi_0 *= -1; step_dir *= -1; } } // The Search Algorithm for T(mu) [More, Thuente 1994] int max_step_iterations = 10; int step_iterations = 0; // Sufficient decreace constant, Equation 1.1 [More, Thuete 1994] double mu = 1.e-4; // Curvature condition constant, Equation 1.2 [More, Thuete 1994] double nu = 0.9; // Initial endpoints of Interval I, double a_l = 0, a_u = 0; // Auxiliary function psi is used until I is determined ot be a closed interval, Equation 2.1 [More, Thuente 1994] double f_l = auxilaryFunction_PsiMT (a_l, phi_0, phi_0, d_phi_0, mu); double g_l = auxilaryFunction_dPsiMT (d_phi_0, d_phi_0, mu); double f_u = auxilaryFunction_PsiMT (a_u, phi_0, phi_0, d_phi_0, mu); double g_u = auxilaryFunction_dPsiMT (d_phi_0, d_phi_0, mu); // Check used to allow More-Thuente step length calculation to be skipped by making step_min == step_max bool interval_converged = (step_max - step_min) > 0, open_interval = true; double a_t = step_init; a_t = std::min (a_t, step_max); a_t = std::max (a_t, step_min); x_t = x + step_dir * a_t; final_transformation_ = (Eigen::Translation<float, 3>(static_cast<float> (x_t (0)), static_cast<float> (x_t (1)), static_cast<float> (x_t (2))) * Eigen::AngleAxis<float> (static_cast<float> (x_t (3)), Eigen::Vector3f::UnitX ()) * Eigen::AngleAxis<float> (static_cast<float> (x_t (4)), Eigen::Vector3f::UnitY ()) * Eigen::AngleAxis<float> (static_cast<float> (x_t (5)), Eigen::Vector3f::UnitZ ())).matrix (); // New transformed point cloud transformPointCloud (*input_, trans_cloud, final_transformation_); // Updates score, gradient and hessian. Hessian calculation is unessisary but testing showed that most step calculations use the // initial step suggestion and recalculation the reusable portions of the hessian would intail more computation time. score = computeDerivatives (score_gradient, hessian, trans_cloud, x_t, true); // Calculate phi(alpha_t) double phi_t = -score; // Calculate phi'(alpha_t) double d_phi_t = -(score_gradient.dot (step_dir)); // Calculate psi(alpha_t) double psi_t = auxilaryFunction_PsiMT (a_t, phi_t, phi_0, d_phi_0, mu); // Calculate psi'(alpha_t) double d_psi_t = auxilaryFunction_dPsiMT (d_phi_t, d_phi_0, mu); // Iterate until max number of iterations, interval convergance or a value satisfies the sufficient decrease, Equation 1.1, and curvature condition, Equation 1.2 [More, Thuente 1994] while (!interval_converged && step_iterations < max_step_iterations && !(psi_t <= 0 /*Sufficient Decrease*/ && d_phi_t <= -nu * d_phi_0 /*Curvature Condition*/)) { // Use auxilary function if interval I is not closed if (open_interval) { a_t = trialValueSelectionMT (a_l, f_l, g_l, a_u, f_u, g_u, a_t, psi_t, d_psi_t); } else { a_t = trialValueSelectionMT (a_l, f_l, g_l, a_u, f_u, g_u, a_t, phi_t, d_phi_t); } a_t = std::min (a_t, step_max); a_t = std::max (a_t, step_min); x_t = x + step_dir * a_t; final_transformation_ = (Eigen::Translation<float, 3> (static_cast<float> (x_t (0)), static_cast<float> (x_t (1)), static_cast<float> (x_t (2))) * Eigen::AngleAxis<float> (static_cast<float> (x_t (3)), Eigen::Vector3f::UnitX ()) * Eigen::AngleAxis<float> (static_cast<float> (x_t (4)), Eigen::Vector3f::UnitY ()) * Eigen::AngleAxis<float> (static_cast<float> (x_t (5)), Eigen::Vector3f::UnitZ ())).matrix (); // New transformed point cloud // Done on final cloud to prevent wasted computation transformPointCloud (*input_, trans_cloud, final_transformation_); // Updates score, gradient. Values stored to prevent wasted computation. score = computeDerivatives (score_gradient, hessian, trans_cloud, x_t, false); // Calculate phi(alpha_t+) phi_t = -score; // Calculate phi'(alpha_t+) d_phi_t = -(score_gradient.dot (step_dir)); // Calculate psi(alpha_t+) psi_t = auxilaryFunction_PsiMT (a_t, phi_t, phi_0, d_phi_0, mu); // Calculate psi'(alpha_t+) d_psi_t = auxilaryFunction_dPsiMT (d_phi_t, d_phi_0, mu); // Check if I is now a closed interval if (open_interval && (psi_t <= 0 && d_psi_t >= 0)) { open_interval = false; // Converts f_l and g_l from psi to phi f_l = f_l + phi_0 - mu * d_phi_0 * a_l; g_l = g_l + mu * d_phi_0; // Converts f_u and g_u from psi to phi f_u = f_u + phi_0 - mu * d_phi_0 * a_u; g_u = g_u + mu * d_phi_0; } if (open_interval) { // Update interval end points using Updating Algorithm [More, Thuente 1994] interval_converged = updateIntervalMT (a_l, f_l, g_l, a_u, f_u, g_u, a_t, psi_t, d_psi_t); } else { // Update interval end points using Modified Updating Algorithm [More, Thuente 1994] interval_converged = updateIntervalMT (a_l, f_l, g_l, a_u, f_u, g_u, a_t, phi_t, d_phi_t); } step_iterations++; } // If inner loop was run then hessian needs to be calculated. // Hessian is unnessisary for step length determination but gradients are required // so derivative and transform data is stored for the next iteration. if (step_iterations) computeHessian (hessian, trans_cloud, x_t); return (a_t); }
int main (int args, char* argv[]) { double length = LENGTH; //Axial length of vessel to simulate (in micrometers). double diameter= DIAMETER; double pi = 3.1415; //Steady state diameter of the simulated vessel (in micrometers). double hx_smc = HX_SMC; double hy_smc = HY_SMC; double hx_ec = HX_EC; double hy_ec = HY_EC; double new_length = (rint (length/hx_ec) ) * hx_ec; if (( (int)(new_length) % (int) (hx_smc) )!=0) hx_smc = new_length / (rint (new_length/hx_smc)) ; double new_circ= (rint (diameter * pi /hy_smc) ) * hy_smc; if (( (int)(new_circ) % (int) (hy_ec) )!=0) hy_ec = new_circ / (rint (new_circ/hy_ec)) ; grid.neq_smc = 26; grid.neq_ec = 4; grid.nodes_smc = (int) (length/hx_smc); grid.layers_smc = (int) (new_circ/hy_smc); grid.nodes_ec = (int) (length/hx_ec); grid.layers_ec = (int) (new_circ/hy_ec); grid.m = grid.nodes_smc*grid.layers_smc; grid.n = grid.nodes_ec *grid.layers_ec ; MPI_Init(&args, &argv); int tasks, myRank; MPI_Status status1,stat1,stat2,stat3,stat4; MPI_Request req1,req2,req3,req4; MPI_Comm_size(MPI_COMM_WORLD,&tasks); MPI_Comm_rank(MPI_COMM_WORLD,&myRank); FILE *errPT; char filename[10];int n; int kB=1024, MB= 1024*1024; sprintf(filename,"err.%d.txt",myRank); errPT = fopen(filename,"w+"); int n_smc,n_ec; if (myRank ==0) { printf("LENGTH = %2.5f\t\tDIAMETER(requested)= %2.5f\t\tDIAMETER(corrected)= %2.5f\t\tCIRCUMFERENCE = %2.5f\n\n",length,diameter,(new_circ/pi),new_circ); printf("SMC GRID INFO:\nNodes = %d\nLayers = %d\nHX = %f,HY = %f\nTotal cells = %d\n",grid.nodes_smc,grid.layers_smc,hx_smc,hy_smc,grid.m); printf("EC GRID INFO:\nNodes = %d\nLayers = %d\nHX = %f,HY = %f\nTotal cells = %d\n",grid.nodes_ec,grid.layers_ec,hx_ec,hy_ec,grid.n); //EC bit int r = grid.nodes_ec%tasks; if (r ==0) { n_ec = grid.nodes_ec/tasks; grid.n_ec= n_ec; for (int i=1;i<tasks;i++) MPI_Send(&n_ec,1,MPI_INT,i,000,MPI_COMM_WORLD); } else{ n_ec = (grid.nodes_ec - r )/tasks; grid.n_ec= n_ec; for (int i=1;i<tasks-1;i++) MPI_Send(&n_ec,1,MPI_INT,i,000,MPI_COMM_WORLD); n_ec=n_ec+r; MPI_Send(&n_ec,1,MPI_INT,(tasks-1),000,MPI_COMM_WORLD); } } else MPI_Recv(&grid.n_ec,1,MPI_INT,MASTER,000,MPI_COMM_WORLD,&status1); grid.n_smc = 13*grid.n_ec; //Each should perform this bit locally celltype1* smc_base; celltype2* ec_base; smc_base = (celltype1*) malloc((grid.layers_smc *grid.n_smc) * sizeof(celltype1)); if(smc_base==NULL){ fprintf(errPT,"Allocation failed for smc_base\n"); MPI_Abort(MPI_COMM_WORLD,100); } ec_base = (celltype2*) malloc((grid.layers_ec *grid.n_ec) * sizeof(celltype2)); if(ec_base==NULL){ fprintf(errPT,"Allocation failed for ec_base\n"); MPI_Abort(MPI_COMM_WORLD,100); } smc = (celltype1**) malloc(grid.layers_smc * sizeof(celltype1*)); if(smc==NULL){ fprintf(errPT,"Allocation failed for smc row dimension\n"); MPI_Abort(MPI_COMM_WORLD,100); } for (int i=0; i<grid.layers_smc; i++){ smc[i]= (celltype1*) malloc(grid.n_smc * sizeof(celltype1)); if(smc[i]==NULL){ fprintf(errPT,"Allocation failed for smc row # %d dimension\n",i); MPI_Abort(MPI_COMM_WORLD,100); } smc[i]= smc_base+(i*grid.n_smc); } ec = (celltype2**) malloc(grid.layers_ec * sizeof(celltype2*)); if(smc==NULL){ fprintf(errPT,"Allocation failed for smc row dimension\n"); MPI_Abort(MPI_COMM_WORLD,100); } for (int i=0; i<grid.layers_ec; i++){ ec[i]= (celltype2*) malloc(grid.n_ec * sizeof(celltype2)); if(ec[i]==NULL){ fprintf(errPT,"Allocation failed for ec row # %d dimension\n",i); MPI_Abort(MPI_COMM_WORLD,100); } ec[i]= ec_base+(i*grid.n_ec); } nn.sbuf_left = (double*)malloc( 3*(grid.layers_smc+grid.layers_ec) * sizeof(double)); if(nn.sbuf_left==NULL){ fprintf(errPT,"Allocation failed for nn.sbuf_left dimension\n"); MPI_Abort(MPI_COMM_WORLD,100); } nn.sbuf_right = (double*)malloc( 3*(grid.layers_smc+grid.layers_ec) * sizeof(double)); if(nn.sbuf_right==NULL){ fprintf(errPT,"Allocation failed for nn.sbuf_right dimension\n"); MPI_Abort(MPI_COMM_WORLD,100); } nn.rbuf_left = (double*)malloc( 3*(grid.layers_smc+grid.layers_ec) * sizeof(double)); if(nn.rbuf_left==NULL){ fprintf(errPT,"Allocation failed for nn.rbuf_left dimension\n"); MPI_Abort(MPI_COMM_WORLD,100); } nn.rbuf_right = (double*)malloc( 3*(grid.layers_smc+grid.layers_ec) * sizeof(double)); if(nn.rbuf_right==NULL){ fprintf(errPT,"Allocation failed for nn.rbuf_right dimension\n"); MPI_Abort(MPI_COMM_WORLD,100); } nn.left_smc_c = (double*)malloc( grid.layers_smc * sizeof(double)); if(nn.left_smc_c==NULL){ fprintf(errPT,"Allocation failed for nn.left_smc_c dimension\n"); MPI_Abort(MPI_COMM_WORLD,100); } nn.right_smc_c = (double*)malloc( grid.layers_smc * sizeof(double)); if(nn.right_smc_c==NULL){ fprintf(errPT,"Allocation failed for nn.right_smc_c dimension\n"); MPI_Abort(MPI_COMM_WORLD,100); } nn.left_ec_c = (double*)malloc( grid.layers_ec * sizeof(double)); if(nn.left_ec_c==NULL){ fprintf(errPT,"Allocation failed for nn.left_ec_c dimension\n"); MPI_Abort(MPI_COMM_WORLD,100); } nn.right_ec_c = (double*)malloc( grid.layers_ec * sizeof(double)); if(nn.right_ec_c==NULL){ fprintf(errPT,"Allocation failed for nn.right_ec_c dimension\n"); MPI_Abort(MPI_COMM_WORLD,100); } nn.left_smc_v = (double*)malloc( grid.layers_smc * sizeof(double)); if(nn.left_smc_v==NULL){ fprintf(errPT,"Allocation failed for nn.left_smc_v dimension\n"); MPI_Abort(MPI_COMM_WORLD,100); } nn.right_smc_v = (double*)malloc( grid.layers_smc * sizeof(double)); if(nn.right_smc_v==NULL){ fprintf(errPT,"Allocation failed for nn.right_smc_v dimension\n"); MPI_Abort(MPI_COMM_WORLD,100); } nn.left_ec_v = (double*)malloc( grid.layers_ec * sizeof(double)); if(nn.left_ec_v==NULL){ fprintf(errPT,"Allocation failed for nn.left_ec_v dimension\n"); MPI_Abort(MPI_COMM_WORLD,100); } nn.right_ec_v = (double*)malloc( grid.layers_ec * sizeof(double)); if(nn.right_ec_v==NULL){ fprintf(errPT,"Allocation failed for nn.right_ec_v dimension\n"); MPI_Abort(MPI_COMM_WORLD,100); } nn.left_smc_I = (double*)malloc( grid.layers_smc * sizeof(double)); if(nn.left_smc_I==NULL){ fprintf(errPT,"Allocation failed for nn.left_smc_I dimension\n"); MPI_Abort(MPI_COMM_WORLD,100); } nn.right_smc_I = (double*)malloc( grid.layers_smc * sizeof(double)); if(nn.right_smc_I==NULL){ fprintf(errPT,"Allocation failed for nn.right_smc_I dimension\n"); MPI_Abort(MPI_COMM_WORLD,100); } nn.left_ec_I = (double*)malloc( grid.layers_ec * sizeof(double)); if(nn.left_ec_I==NULL){ fprintf(errPT,"Allocation failed for nn.left_ec_I dimension\n"); MPI_Abort(MPI_COMM_WORLD,100); } nn.right_ec_I = (double*)malloc( grid.layers_ec * sizeof(double)); if(nn.right_ec_I==NULL){ fprintf(errPT,"Allocation failed for nn.right_ec_I dimension\n"); MPI_Abort(MPI_COMM_WORLD,100); } //Lodaing the information of rows and cols of each cell and allocating memory for various flux equations for(int i=0; i<grid.layers_smc; i++) { for (int j=0;j<grid.n_smc;j++) { smc[i][j].row = i; smc[i][j].col = j; /* smc[i][j].A = (double*) malloc(12*sizeof(double)); if(smc[i][j].A==NULL){ fprintf(errPT,"Allocation failed for smc[i][j].A dimension\n"); MPI_Abort(MPI_COMM_WORLD,100); } smc[i][j].B = (double*) malloc(3*sizeof(double)); if(smc[i][j].B==NULL){ fprintf(errPT,"Allocation failed for smc[i][j].B dimension\n"); MPI_Abort(MPI_COMM_WORLD,100); } smc[i][j].C = (double*) malloc(3*sizeof(double)); if(smc[i][j].C==NULL){ fprintf(errPT,"Allocation failed for smc[i][j].C dimension\n"); MPI_Abort(MPI_COMM_WORLD,100); }*/ } } for(int i=0; i<grid.layers_ec; i++) { for (int j=0;j<grid.n_ec;j++) { ec[i][j].row = i; ec[i][j].col = j; /* ec[i][j].A = (double*) malloc(12*sizeof(double)); if(ec[i][j].A==NULL){ fprintf(errPT,"Allocation failed for ec[i][j].A dimension\n"); MPI_Abort(MPI_COMM_WORLD,100); } ec[i][j].B = (double*) malloc(3*sizeof(double)); if(ec[i][j].B==NULL){ fprintf(errPT,"Allocation failed for ec[i][j].B dimension\n"); MPI_Abort(MPI_COMM_WORLD,100); } ec[i][j].C = (double*) malloc(3*sizeof(double)); if(ec[i][j].C==NULL){ fprintf(errPT,"Allocation failed for ec[i][j].C dimension\n"); MPI_Abort(MPI_COMM_WORLD,100); }*/ } } int total = (grid.neq_smc * grid.n_smc * grid.layers_smc) + (grid.neq_ec * grid.n_ec * grid.layers_ec); //Initialize and use the solver here RKSUITE rksuite; //Time variables double tfinal = TFINAL; double tnow = 0.0; double interval= INTERVAL; //File written every 1 second int file_write_per_unit_time=(int)(1/interval); //Error control variables double TOL = 1e-7; double thres[total]; for (int i= 0; i<total; i++) thres[i] = 1e-7; //Variables holding new and old values double* y = (double*) malloc (total * sizeof(double)); /***** INITIALIZATION SECTION ******/ int offset = 0; Initialize_tsoukias_smc(offset,y); offset = grid.n_smc*grid.layers_smc * grid.neq_smc; Initialize_koeingsberger_ec(offset, y); int i,j,k; for(i=0;i< grid.layers_smc; i++) { for (j=0;j<grid.n_smc;j++) { if (i>0) k=(i*grid.n_smc*grid.neq_smc); else if (i==0) k=0; smc[i][j].p = &y[k+(j*grid.neq_smc)+0]; } } offset = grid.n_smc*grid.layers_smc * grid.neq_smc; for(i=0;i< grid.layers_ec; i++) { for (j=0;j<grid.n_ec;j++) { if (i>0) k= offset+i*grid.n_ec*grid.neq_ec ; else if (i==0) k=offset+0; ec[i][j].q = &y[k+(j*grid.neq_ec)+0]; } } for(i=0;i< grid.layers_smc; i++) { for (j=0;j<grid.n_smc;j++) { smc[i][j].NE = 0.0; smc[i][j].NO = 0.0; smc[i][j].I_stim= 0.0; } } /***************************************************************/ double* yp= (double*) malloc (total * sizeof(double)); //Solver method int method = 2; //RK(4,5) //Statistics int totf,stpcst,acptstp; double waste,hnext; //Error Flag int cflag = 0, uflag =0; //Error extent monitor, to select best constant step of tolerances double* ymax = (double*) malloc(total * sizeof(double)); int state = couplingParms(CASE); if (myRank==0) printf("\n Step Size=%2.10lf\nUnit time in file write=%lf\n",interval,(double)file_write_per_unit_time*interval ); //Output file management FILE *time,*Task_info, *ci,*cj, *si,*sj, *vi,*vj, *Ii,*Ij, *cpv_i,*cpc_i,*cpi_i, *cpv_j,*cpc_j,*cpi_j; n=sprintf(filename,"t%d.txt",myRank); time = fopen(filename,"w+"); n=sprintf(filename,"Task_info%d.txt",myRank); Task_info= fopen(filename,"w+"); n=sprintf(filename,"smc_c%d.txt",myRank); ci = fopen(filename,"w+"); n=sprintf(filename,"ec_c%d.txt",myRank); cj = fopen(filename,"w+"); n=sprintf(filename,"ec_s%d.txt",myRank); sj = fopen(filename,"w+"); n=sprintf(filename,"smc_v%d.txt",myRank); vi = fopen(filename,"w+"); n=sprintf(filename,"ec_v%d.txt",myRank); vj = fopen(filename,"w+"); n=sprintf(filename,"smc_I%d.txt",myRank); Ii = fopen(filename,"w+"); n=sprintf(filename,"ec_I%d.txt",myRank); Ij = fopen(filename,"w+"); n=sprintf(filename,"cpv_i%d.txt",myRank); cpv_i = fopen(filename,"w+"); n=sprintf(filename,"cpc_i%d.txt",myRank); cpc_i = fopen(filename,"w+"); n=sprintf(filename,"cpi_i%d.txt",myRank); cpi_i = fopen(filename,"w+"); n=sprintf(filename,"cpc_j%d.txt",myRank); cpc_j = fopen(filename,"w+"); n=sprintf(filename,"cpv_j%d.txt",myRank); cpv_j = fopen(filename,"w+"); n=sprintf(filename,"cpi_j%d.txt",myRank); cpi_j = fopen(filename,"w+"); int count = 3*(grid.layers_smc+grid.layers_ec), buf_offset = 3*grid.layers_smc; int iteration=0; double Per_MPI_time_t1,Per_MPI_time_t2, Per_step_compute_time_t1,Per_step_compute_time_t2; double t1 = MPI_Wtime(); /********************************************************************/ for(int i=0; i<grid.layers_smc;i++) update_send_buffers_smc(myRank,tasks,i); for(int i=0; i<grid.layers_ec;i++) update_send_buffers_ec(myRank,tasks,i); my_boundary(myRank); update_async(myRank,tasks); retrive_recv_buffers_smc(myRank,tasks); retrive_recv_buffers_ec(myRank,tasks); /************************************************************************/ /*********************SOLVER SECTION*************************/ /************************************************************************/ tend = interval; rksuite.setup(total, tnow, y, tend, TOL, thres, method, "CT", false, 1e-5, false ); while (tnow <=10.00) { // the ct() function does not guarantee to advance all the // way to the stop time. Keep stepping until it does. do { computeDerivatives( tnow, y, yp ); rksuite.ct(computeDerivatives, tnow, y, yp, cflag ); if (cflag >= 5) { printf("RKSUITE error %d\n", cflag ); MPI_Abort(MPI_COMM_WORLD,1000); return false; break; } } while (tnow < tend); iteration++; /************************************************/ /* Communication Block */ /************************************************/ update_async(myRank,tasks); MPI_Barrier(MPI_COMM_WORLD); if (iteration==5){ fprintf(Task_info,"COUPLING COEFFICIENTS\n\n"); fprintf(Task_info,"g_hm_smc=\t%6.2lf\ng_hm_ec=\t%6.2lf\np_hm_smc=\t%6.2lf\np_hm_ec=\t%6.2lf\npIP_hm_smc=\t%6.2lf\npIP_hm_ec=\t%6.2lf\ng_ht_smc=\t%6.2lf\tg_ht_ec=\t%6.2lf\np_ht_smc=\t%6.2lf\tp_ht_ec=\t%6.2lf\npIP_ht_smc=\t%6.2lf\tpIP_ht_ec=\t%6.2lf\n", cpl_cef.g_hm_smc,cpl_cef.g_hm_ec,cpl_cef.p_hm_smc,cpl_cef.p_hm_ec,cpl_cef.pIP_hm_smc,cpl_cef.pIP_hm_ec,cpl_cef.g_ht_smc,cpl_cef.g_ht_ec,cpl_cef.p_ht_smc,cpl_cef.p_ht_ec, cpl_cef.pIP_ht_smc,cpl_cef.pIP_ht_ec); fprintf(Task_info,"\nSpatial Gradient info:\nMinimum JPLC\t=\t=%lf\nMaximum JPLC\t=\t=%lf\nGradient\t=\t=%lf\n" ,grid.min_jplc,grid.max_jplc,grid.gradient); fprintf(Task_info,"\nTotal Tasks=%d\tMyRank=%d\n\n",tasks,myRank); fprintf(Task_info,"LENGTH = %2.5f\nREQUESTED DIAMETER = %2.5f\nCORRECTED CIRCUMFERENCE = %2.5f\nTotal layers=%d\nTotal nodes=%d\n\n",length,diameter,new_circ,grid.layers_smc,grid.nodes_smc); fprintf(Task_info,"SMC GRID INFO:\nNodes = %d\nLayers = %d\nHX = %lf,HY = %lf\nTotal cells = %d\n\n",grid.n_smc,grid.layers_smc,hx_smc,hy_smc,grid.m); fprintf(Task_info,"EC GRID INFO:\nNodes = %d\nLayers = %d\nHX = %lf,HY = %lf\nTotal cells = %d\n\n",grid.n_ec,grid.layers_ec,hx_ec,hy_ec,grid.n); fprintf(Task_info,"JPLC (at t<100 seconds) in axial direction per EC\n"); for (int p=0; p<grid.n_ec; p++) fprintf(Task_info,"[%d]\t%lf\n",p,ec[0][p].JPLC); } if ((iteration==1)||(iteration % file_write_per_unit_time==0)) { fprintf(time,"%lf\n",tnow); for (int row=0; row<grid.layers_smc;row++) { for (int col=0; col<grid.n_smc; col++) { fprintf(ci,"%2.10lf",smc[row][col].p[smc_Ca_i]); fprintf(vi,"%2.10lf",smc[row][col].p[smc_V_m]); fprintf(Ii,"%2.10lf",smc[row][col].p[smc_IP3]); if (col<(grid.n_smc-1)){ fprintf(ci,"\t"); fprintf(vi,"\t"); fprintf(Ii,"\t"); } } if (row<(grid.layers_smc-1)){ fprintf(ci,"\t"); fprintf(vi,"\t"); fprintf(Ii,"\t"); } else if (row==(grid.layers_smc-1)){ fprintf(ci,"\n"); fprintf(vi,"\n"); fprintf(Ii,"\n"); } } for (int row=0; row<grid.layers_ec;row++) { for (int col=0; col<grid.n_ec; col++) { fprintf(cj,"%2.10lf\t",ec[row][col].q[ec_Ca]); fprintf(sj,"%2.10lf\t",ec[row][col].q[ec_SR]); fprintf(vj,"%2.10lf\t",ec[row][col].q[ec_Vm]); fprintf(Ij,"%2.10lf\t",ec[row][col].q[ec_IP3]); } if (row<(grid.layers_ec-1)){ fprintf(cj,"\t"); fprintf(sj,"\t"); fprintf(vj,"\t"); fprintf(Ij,"\t"); } else if (row==(grid.layers_ec-1)){ fprintf(cj,"\n"); fprintf(sj,"\n"); fprintf(vj,"\n"); fprintf(Ij,"\n"); } } fflush(time);fflush(Task_info);fflush(errPT); //fflush(MPI_stat); fflush(ci);fflush(cj); fflush(sj); fflush(vi);fflush(vj); fflush(Ii);fflush(Ij); fflush(cpv_i); fflush(cpc_i);fflush(cpi_i); fflush(cpv_j);fflush(cpc_j); fflush(cpi_j); } tend += interval; rksuite.reset(tend); } //end while() /****////////*******////////**************** /************************************************************************/ /*********************AFTER 10.00 seconds*************************/ /************************************************************************/ tend = tnow + interval; rksuite.setup(total, tnow, y, tend, TOL, thres, method, "CT", false, 1e-5, false ); while (tnow <=100.00) { // the ct() function does not guarantee to advance all the // way to the stop time. Keep stepping until it does. do { computeDerivatives( tnow, y, yp ); rksuite.ct(computeDerivatives, tnow, y, yp, cflag ); if (cflag >= 5) { printf("RKSUITE error %d\n", cflag ); MPI_Abort(MPI_COMM_WORLD,1000); return false; break; } } while (tnow < tend); iteration++; /************************************************/ /* Communication Block */ /************************************************/ update_async(myRank,tasks); MPI_Barrier(MPI_COMM_WORLD); if (iteration==5e3){ fprintf(Task_info,"JPLC (at 10<t<100 seconds) in axial direction per EC\n"); for (int p=0; p<grid.n_ec; p++) fprintf(Task_info,"[%d]\t%lf\n",p,ec[0][p].JPLC); } if (iteration % file_write_per_unit_time==0) { fprintf(time,"%lf\n",tnow); for (int row=0; row<grid.layers_smc;row++) { for (int col=0; col<grid.n_smc; col++) { fprintf(ci,"%2.10lf",smc[row][col].p[smc_Ca_i]); fprintf(vi,"%2.10lf",smc[row][col].p[smc_V_m]); fprintf(Ii,"%2.10lf",smc[row][col].p[smc_IP3]); if (col<(grid.n_smc-1)){ fprintf(ci,"\t"); fprintf(vi,"\t"); fprintf(Ii,"\t"); } } if (row<(grid.layers_smc-1)){ fprintf(ci,"\t"); fprintf(vi,"\t"); fprintf(Ii,"\t"); } else if (row==(grid.layers_smc-1)){ fprintf(ci,"\n"); fprintf(vi,"\n"); fprintf(Ii,"\n"); } } for (int row=0; row<grid.layers_ec;row++) { for (int col=0; col<grid.n_ec; col++) { fprintf(cj,"%2.10lf\t",ec[row][col].q[ec_Ca]); fprintf(sj,"%2.10lf\t",ec[row][col].q[ec_SR]); fprintf(vj,"%2.10lf\t",ec[row][col].q[ec_Vm]); fprintf(Ij,"%2.10lf\t",ec[row][col].q[ec_IP3]); } if (row<(grid.layers_ec-1)){ fprintf(cj,"\t"); fprintf(sj,"\t"); fprintf(vj,"\t"); fprintf(Ij,"\t"); } else if (row==(grid.layers_ec-1)){ fprintf(cj,"\n"); fprintf(sj,"\n"); fprintf(vj,"\n"); fprintf(Ij,"\n"); } } fflush(time);fflush(Task_info);fflush(errPT); //fflush(MPI_stat); fflush(ci);fflush(cj); fflush(sj); fflush(vi);fflush(vj); fflush(Ii);fflush(Ij); fflush(cpv_i); fflush(cpc_i);fflush(cpi_i); fflush(cpv_j);fflush(cpc_j); fflush(cpi_j); } tend += interval; rksuite.reset(tend); } //end while() /****////////*******////////**************** /************************************************************************/ /*** After 100 seconds ****/ /************************************************************************/ tend = tnow+interval; rksuite.setup(total, tnow, y, tend, TOL, thres, method, "CT", false, 1e-6, false ); while (tnow <=tfinal) { // the ct() function does not guarantee to advance all the // way to the stop time. Keep stepping until it does. do { computeDerivatives( tnow, y, yp ); rksuite.ct(computeDerivatives, tnow, y, yp, cflag ); if (cflag >= 5) { printf("RKSUITE error %d\n", cflag ); MPI_Abort(MPI_COMM_WORLD,1000); return false; break; } } while (tnow < tend); iteration++; /************************************************/ /* Communication Block */ /************************************************/ update_async(myRank,tasks); MPI_Barrier(MPI_COMM_WORLD); if (iteration==1e5) { fprintf(Task_info,"JPLC (at t>100 seconds) in axial direction per EC\n"); for (int p=0; p<grid.n_ec; p++) fprintf(Task_info,"[%d]\t%lf\n",p,ec[0][p].JPLC); } if (iteration % file_write_per_unit_time==0) { fprintf(time,"%lf\n",tnow); for (int row=0; row<grid.layers_smc;row++) { for (int col=0; col<grid.n_smc; col++) { fprintf(ci,"%2.10lf",smc[row][col].p[smc_Ca_i]); fprintf(vi,"%2.10lf",smc[row][col].p[smc_V_m]); fprintf(Ii,"%2.10lf",smc[row][col].p[smc_IP3]); if (col<(grid.n_smc-1)){ fprintf(ci,"\t"); fprintf(vi,"\t"); fprintf(Ii,"\t"); } } if (row<(grid.layers_smc-1)){ fprintf(ci,"\t"); fprintf(vi,"\t"); fprintf(Ii,"\t"); } else if (row==(grid.layers_smc-1)){ fprintf(ci,"\n"); fprintf(vi,"\n"); fprintf(Ii,"\n"); } } for (int row=0; row<grid.layers_ec;row++) { for (int col=0; col<grid.n_ec; col++) { fprintf(cj,"%2.10lf\t",ec[row][col].q[ec_Ca]); fprintf(sj,"%2.10lf\t",ec[row][col].q[ec_SR]); fprintf(vj,"%2.10lf\t",ec[row][col].q[ec_Vm]); fprintf(Ij,"%2.10lf\t",ec[row][col].q[ec_IP3]); } if (row<(grid.layers_ec-1)){ fprintf(cj,"\t"); fprintf(sj,"\t"); fprintf(vj,"\t"); fprintf(Ij,"\t"); } else if (row==(grid.layers_ec-1)){ fprintf(cj,"\n"); fprintf(sj,"\n"); fprintf(vj,"\n"); fprintf(Ij,"\n"); } } fflush(time);fflush(Task_info);fflush(errPT); //fflush(MPI_stat); fflush(ci);fflush(cj); fflush(sj); fflush(vi);fflush(vj); fflush(Ii);fflush(Ij); fflush(cpv_i); fflush(cpc_i);fflush(cpi_i); fflush(cpv_j);fflush(cpc_j); fflush(cpi_j); } tend += interval; rksuite.reset(tend); } //end while() /****////////*******////////**************** /************************************************************************/ double t2 = MPI_Wtime(); //printf("[%d] : Elapsed time = %lf\nMPI size=%d\ttfinal=%lf\tStep size=%lf\tcount=%d\n",myRank,(t2-t1),tasks,tfinal,interval,cnt2); fprintf(Task_info,"Elapsed time = %lf\ntfinal=%lf\nStep size=%lf\n",(t2-t1),tasks,tfinal,interval); MPI_Barrier(MPI_COMM_WORLD); if (myRank==0) printf("\nEND OF PROGRAM\n"); free(smc);free(smc_base); free(ec);free(ec_base); free(nn.sbuf_left); free(nn.sbuf_right); free(nn.rbuf_left); free(nn.rbuf_right); free(nn.left_smc_c); free(nn.right_smc_c); free(nn.left_ec_c); free(nn.right_ec_c); free(nn.left_smc_v); free(nn.right_smc_v); free(nn.left_ec_v); free(nn.right_ec_v); free(nn.left_smc_I); free(nn.right_smc_I); free(nn.left_ec_I); free(nn.right_ec_I); free(y); free(yp); free(ymax); fclose(time);fclose(Task_info); fclose(errPT); fclose(ci);fclose(cj); fclose(sj); fclose(vi);fclose(vj); fclose(Ii);fclose(Ij); fclose(cpv_i); fclose(cpc_i);fclose(cpi_i); fclose(cpv_j);fclose(cpc_j); fclose(cpi_j); MPI_Finalize(); }
void SentimentTraining::trainBatch(int startIndex, int endIndex) { float value = computeDerivatives(startIndex, endIndex); kernelUpdateParams(mModel.params_d, mModel.derivatives_d, mModel.adagradWts_d, mOptions.learningRate); }
/** * calcCLG_OF * * Main CLG-optical flow (CLG-OF) computation function. * * Parameters: * * image1 Pointer to the first image (the "previous" time frame). * image2 Pointer to the second image (the "current" time frame). * uOut Pointer to the horizontal component of the CLG-OF solution. * vOut Pointer to the vertical component of the CLG-OF solution. * nRows Number of image rows (same for the CLG-OF vector field). * nCols Number of image columns (same for the CLG-OF vector field). * iterations Number of iterations for iterative solution. * alpha Global smoothing coefficient of the CLG-OF. * rho Local spatio-temporal smoothing coefficient of the CLG-OF. * wFactor SOR relaxation factor, between 0 and 2. * verbose Display/hide messages to the stdout. * coupledMode Iteration type. 1->Pointwise-Coupled Gauss-Seidel, 0->SOR. * */ int calcCLG_OF(double* image1, double* image2, double* uOut, double* vOut, int nRows, int nCols, int iterations, double alpha, double rho, double wFactor, int verbose, int coupledMode) { if (verbose) { printf("calc_clg\n"); printf(" setting up variables\n"); } int i=0, j=0; // h, could be less than 1.0. double h = 1.0; // Matrix to vector. double **prevFrame, **currFrame; prevFrame = pMatrix(nRows, nCols); currFrame = pMatrix(nRows, nCols); for (i=0; i<nRows; i++) { for (j=0; j<nCols; j++) { prevFrame[i][j] = image1[j + i*nCols]; currFrame[i][j] = image2[j + i*nCols]; } } if (verbose) printf(" allocating memory for arrays\n"); double **u, **v; double **dfdx, **dfdxw; double **dfdy, **dfdyw; double **dfdt, **dfdtw; u = pMatrix(nRows, nCols); v = pMatrix(nRows, nCols); // Derivatives and their warped versions. dfdx = pMatrix(nRows, nCols); dfdy = pMatrix(nRows, nCols); dfdt = pMatrix(nRows, nCols); for (i=0; i<nRows; i++) { for (j=0; j<nCols; j++) { u[i][j] = 0.0; v[i][j] = 0.0; dfdt[i][j] = currFrame[i][j] - prevFrame[i][j]; } } if (verbose) printf(" allocating memory for derivatives matrices\n"); double **J[JROWS][JCOLS]; // Because of symmetry, only the upper part is allocated. int k, l; for (k=0; k<JROWS; k++) for (l=k; l<JCOLS; l++) J[k][l] = pMatrix(nRows, nCols); // Spatial derivatives obtention. computeDerivatives(prevFrame, currFrame, dfdx, dfdy, nRows, nCols, verbose); // Compute J tensor. computeJTensor(dfdx, dfdy, dfdt, J, nRows, nCols); if (verbose) printf(" local spatio temporal smoothing\n"); if (rho > 0) { k=0, l=0; for (k=0; k<JROWS; k++) for (l=k; l<JCOLS; l++) matrixSmooth(J[k][l], nRows, nCols, rho); } if (iterations == 0) iterations = (int) (nRows * nCols / 8.0); if (verbose) printf(" performing %i relax iterations\n", iterations); int count = 0; double error = 1000000; double convergenceError = 0.0; for (count=0; count<iterations && convergenceError*1.01 < error; count++) { if (count > 0) error = convergenceError; if (coupledMode == 1) { if (verbose && count % 50 == 0 && count > 0) printf(" iteration %d/%d (P-C Gauss-Seidel), error=%f\n", count, iterations, error); convergenceError = relaxPointwiseCoupledGaussSeidel(u, v, J, nRows, nCols, alpha); } else { if (verbose && count % 50 == 0 && count > 0) printf(" iteration %d/%d (SOR), error=%f\n", count, iterations, error); convergenceError = relaxSOR(u, v, J, nRows, nCols, alpha, wFactor); } } // Show debug information. if (verbose) printf(" filling output after %d iterations, error=%f\n", count, error); // Fill output variables. for (i=0; i<nRows; i++) { for (j=0; j<nCols; j++) { uOut[j + i*nCols] += u[i][j]; vOut[j + i*nCols] += v[i][j]; } } // Free memory. if (verbose) printf(" freeing memory\n"); freePmatrix(u, nRows); freePmatrix(v, nRows); for (k=0; k<JROWS; k++) for (l=k; l<JCOLS; l++) freePmatrix(J[k][l], nRows); freePmatrix(prevFrame, nRows); freePmatrix(currFrame, nRows); freePmatrix(dfdx, nRows); freePmatrix(dfdy, nRows); freePmatrix(dfdt, nRows); if (verbose) printf("calc_clg: done\n"); return 1; }