/*! Get values of the specified elements from a global vector @param v_type - Indicator for vector: 0: x; 1: rhs @param ni - number of elements to get @param ix - indices where to get them from (in global 1d numbering) */ void PETScLinearSolver::GetVecValues(const int v_type, PetscInt ni,const PetscInt ix[], PetscScalar y[]) const { if(v_type == 0) VecGetValues(x, ni, ix, y); else VecGetValues(b, ni, ix, y); }
static PetscErrorCode FormJacobian1_block(SNES snes,Vec x,Mat *jac,Mat *B,MatStructure *flag,void *dummy) { Vec *xx, x1,x2; PetscScalar xx_0, xx_1; PetscInt index,nb; PetscScalar A_00, A_01, A_10, A_11; Mat j11, j12, j21, j22; Mat **mats; PetscErrorCode ierr; PetscFunctionBegin; /* get blocks for solution */ ierr = VecNestGetSubVecs( x, &nb, &xx ); CHKERRQ(ierr); x1 = xx[0]; x2 = xx[1]; /* get solution values */ index = 0; ierr = VecGetValues( x1,1, &index, &xx_0 ); CHKERRQ(ierr); ierr = VecGetValues( x2,1, &index, &xx_1 ); CHKERRQ(ierr); /* get block matrices */ ierr = MatNestGetSubMats(*jac,PETSC_NULL,PETSC_NULL,&mats); CHKERRQ(ierr); j11 = mats[0][0]; j12 = mats[0][1]; j21 = mats[1][0]; j22 = mats[1][1]; /* compute jacobian entries */ A_00 = 2.0*xx_0 + xx_1; A_01 = xx_0; A_10 = xx_1; A_11 = xx_0 + 2.0*xx_1; /* set jacobian values */ ierr = MatSetValue( j11, 0,0, A_00, INSERT_VALUES); CHKERRQ(ierr); ierr = MatSetValue( j12, 0,0, A_01, INSERT_VALUES); CHKERRQ(ierr); ierr = MatSetValue( j21, 0,0, A_10, INSERT_VALUES); CHKERRQ(ierr); ierr = MatSetValue( j22, 0,0, A_11, INSERT_VALUES); CHKERRQ(ierr); *flag = SAME_NONZERO_PATTERN; /* Assemble sub matrix */ ierr = MatAssemblyBegin(*jac,MAT_FINAL_ASSEMBLY); CHKERRQ(ierr); ierr = MatAssemblyEnd(*jac,MAT_FINAL_ASSEMBLY); CHKERRQ(ierr); PetscFunctionReturn(0); }
void linearSystemPETSc<fullMatrix<double> >::getFromSolution(int row, fullMatrix<double> &val) const { int blockSize; _try(MatGetBlockSize(_a, &blockSize)); for (int i = 0; i < blockSize; i++) { int ii = row*blockSize +i; #ifdef PETSC_USE_COMPLEX PetscScalar s; VecGetValues ( _x, 1, &ii, &s); val(i,0) = s.real(); #else VecGetValues ( _x, 1, &ii, &val(i,0)); #endif } }
inline PetscErrorCode ScatIEMatMult(Mat mat,Vec xx,Vec yy) { PetscInt n,s,t; PetscScalar tmp,v; PetscInt xstart,xend; PetscFunctionBegin; VecGetOwnershipRange(xx,&xstart,&xend); VecGetSize(yy,&n); VecZeroEntries(yy); for(s = 0; s <n ; s++) { tmp = 0; for(t = xstart; t < xend; t++) { VecGetValues(xx,1,&t,&v); tmp += ScatIE.CoefMatFast(s,t)*v; } VecSetValues(yy,1,&s,&tmp,ADD_VALUES); } VecAssemblyBegin(yy); VecAssemblyEnd(yy); PetscFunctionReturn(0); }
double Integrate(Vec U, int *pt, unsigned int i, myCSField sf) { if (i < sf->d){ double g = 0; // Trapezoidal rule: \int_0^1 f(x) = (h/2) * \sum_{i=0}^{m} (f(x_i)+f(x_{i+1})) // In the special case where f(0) = f(1) = f(x_0) = f(x_{m+1}) = 0 // \int_0^1 f(x) = 0.5*f(x_1) + { \sum_{i=1}^{m-1} 0.5*(f(x_i)+f(x_{i+1})) } + 0.5*f(x_m) double h_2 = (dx(i, sf)/2.); // u(x_0) = 0 pt[i] = 1; g += Integrate(U, pt, i+1, sf) * h_2; for (pt[i]=1;pt[i]<sf->mesh[i];pt[i]++) { g += Integrate(U, pt, i+1, sf) * h_2; pt[i] += 1; g += Integrate(U, pt, i+1, sf) * h_2; pt[i] -= 1; } pt[i] = sf->mesh[i]; g += Integrate(U, pt, i+1, sf) * h_2; // u(x_{m+1}) = 0 return g; } int r = linIdx_Sys(sf->d, sf->mesh, pt,0,0); double x[sf->d]; double Ux; getPoint(pt, x, sf); VecGetValues(U,1,&r,&Ux); return QoIAtPoint(x, Ux, sf); }
PetscErrorCode RetrieveVecPoints(Vec x, int Npt, int *Pos, double *ptValues) { PetscErrorCode ierr; Vec T; VecScatter scatter; IS from, to; ierr = VecCreateSeq(PETSC_COMM_SELF, Npt, &T);CHKERRQ(ierr); ierr = ISCreateGeneral(PETSC_COMM_SELF,Npt, Pos,PETSC_COPY_VALUES, &from);CHKERRQ(ierr); ierr = ISCreateStride(PETSC_COMM_SELF,Npt,0,1, &to);CHKERRQ(ierr); ierr = VecScatterCreate(x,from,T,to,&scatter);CHKERRQ(ierr); ierr = VecScatterBegin(scatter,x,T,INSERT_VALUES,SCATTER_FORWARD);CHKERRQ(ierr); ierr = VecScatterEnd(scatter,x,T,INSERT_VALUES,SCATTER_FORWARD);CHKERRQ(ierr); int ix[Npt]; int i; for(i=0; i<Npt; i++) ix[i]=i; ierr = VecGetValues(T,Npt,ix,ptValues); ierr = ISDestroy(&from);CHKERRQ(ierr); ierr = ISDestroy(&to);CHKERRQ(ierr); ierr = VecScatterDestroy(&scatter);CHKERRQ(ierr); ierr = VecDestroy(&T);CHKERRQ(ierr); PetscFunctionReturn(0); }
void operator| (PUP::er& p, Vec& v) { PetscInt sz; if (!p.isUnpacking()) { VecGetSize(v, &sz); } p | sz; if(p.isUnpacking()) { VecCreateSeq(PETSC_COMM_WORLD, sz, &v); VecSetFromOptions(v); VecGetSize(v, &sz); for (int i = 0; i < sz; i++) { PetscScalar d; p | d; VecSetValue(v, i, d, INSERT_VALUES); } VecAssemblyBegin(v); VecAssemblyEnd(v); } else { for (int i = 0; i < sz; i++) { PetscScalar d; VecGetValues(v, 1, &i, &d); p | d; } } }
double SparseVector::operator ()(int i) { double value; VecGetValues(vec_, 1, &i, &value); return value; }
static PetscErrorCode FormFunction1_block(SNES snes,Vec x,Vec f,void *dummy) { Vec *xx, *ff, x1,x2, f1,f2; PetscScalar ff_0, ff_1; PetscScalar xx_0, xx_1; PetscInt index,nb; PetscErrorCode ierr; PetscFunctionBegin; /* get blocks for function */ ierr = VecNestGetSubVecs( f, &nb, &ff ); CHKERRQ(ierr); f1 = ff[0]; f2 = ff[1]; /* get blocks for solution */ ierr = VecNestGetSubVecs( x, &nb, &xx ); CHKERRQ(ierr); x1 = xx[0]; x2 = xx[1]; /* get solution values */ index = 0; ierr = VecGetValues( x1,1, &index, &xx_0 ); CHKERRQ(ierr); ierr = VecGetValues( x2,1, &index, &xx_1 ); CHKERRQ(ierr); /* Compute function */ ff_0 = xx_0*xx_0 + xx_0*xx_1 - 3.0; ff_1 = xx_0*xx_1 + xx_1*xx_1 - 6.0; /* set function values */ ierr = VecSetValue( f1, index, ff_0, INSERT_VALUES ); CHKERRQ(ierr); ierr = VecSetValue( f2, index, ff_1, INSERT_VALUES ); CHKERRQ(ierr); ierr = VecAssemblyBegin(f); CHKERRQ(ierr); ierr = VecAssemblyEnd(f); CHKERRQ(ierr); PetscFunctionReturn(0); }
double PetscVector<double>::get(unsigned int idx) const { double y = 0; PetscScalar py; VecGetValues(vec, 1, (PetscInt*)&idx, &py); y = py.real(); return y; }
PetscErrorCode DiffIE(Vec originalVec, Vec reducedVec, Vec Distance, Vec nParticlePerCube) { // Find the distance between 2 solutions originalVec and reducedVec PetscInt s,t; PetscInt n,xstart,xend; PetscScalar tmp,v,diff; Vec vec; VecScatter scat; IS is; PetscFunctionBegin; VecGetOwnershipRange(originalVec,&xstart,&xend); VecGetSize(reducedVec,&n); VecCreate(PETSC_COMM_SELF,&vec); VecSetSizes(vec,PETSC_DECIDE,n); VecSetFromOptions(vec); ISCreateStride(PETSC_COMM_WORLD,n,0,1,&is); VecScatterCreate(reducedVec,PETSC_NULL,vec,is,&scat); //VecScatterCreateToAll(reducedVec,&scat,&vec); VecScatterBegin(scat,reducedVec,vec,INSERT_VALUES,SCATTER_FORWARD); VecScatterEnd(scat,reducedVec,vec,INSERT_VALUES,SCATTER_FORWARD); for(s=xstart;s<xend;s++) { t = ScatIE.FindCube(s); VecGetValues(vec,1,&t,&tmp); VecGetValues(originalVec,1,&s,&v); diff = cabs(v - tmp); VecSetValues(Distance,1,&t,&diff,ADD_VALUES); tmp = 1; VecSetValues(nParticlePerCube,1,&t,&tmp,ADD_VALUES); } VecDestroy(&vec); VecScatterDestroy(&scat); ISDestroy(&is); PetscFunctionReturn(0); }
/*! Solve for x in Ax=b */ void HeatSolverBTCS::solve(std::vector<double>& x) { PetscInt i; PetscScalar s; KSPSolve(ksp, rhs, temp); KSPGetConvergedReason(ksp, &reason); for (i = 0; i < nx*ny; i++) { VecGetValues(temp, 1, &i, &s); x[i] = s; } }
PetscErrorCode SolveInit(FEMInf fem, int L, PetscScalar *e0, Vec *x) { PetscErrorCode ierr; Mat H, S; ierr = CalcMat(fem, L, &H, &S); CHKERRQ(ierr); EPS eps; ierr = PrintTimeStamp(fem->comm, "EPS", NULL); CHKERRQ(ierr); ierr = EPSCreate(fem->comm, &eps); CHKERRQ(ierr); ierr = EPSSetTarget(eps, -0.6); CHKERRQ(ierr); ierr = EPSSetWhichEigenpairs(eps, EPS_TARGET_MAGNITUDE); CHKERRQ(ierr); ierr = EPSSetOperators(eps, H, S); CHKERRQ(ierr); if(S == NULL) { ierr = EPSSetProblemType(eps, EPS_NHEP); CHKERRQ(ierr); } else { ierr = EPSSetProblemType(eps, EPS_GNHEP); CHKERRQ(ierr); } Vec x0[1]; MatCreateVecs(H, &x0[0], NULL); int num; FEMInfGetSize(fem, &num); for(int i = 0; i < num; i++) { VecSetValue(x0[0], i, 0.5, INSERT_VALUES); } VecAssemblyBegin(x0[0]); VecAssemblyEnd(x0[0]); EPSSetInitialSpace(eps, 1, x0); ierr = EPSSetFromOptions(eps); CHKERRQ(ierr); ierr = EPSSolve(eps); CHKERRQ(ierr); PetscInt nconv; EPSGetConverged(eps, &nconv); if(nconv == 0) SETERRQ(fem->comm, 1, "Failed to digonalize in init state\n"); Vec x_ans; MatCreateVecs(H, &x_ans, NULL); EPSGetEigenpair(eps, 0, e0, NULL, x_ans, NULL); EPSDestroy(&eps); PetscScalar v[1]; PetscInt idx[1] = {1}; VecGetValues(x_ans, 1, idx, v); PetscScalar scale_factor = v[0] / cabs(v[0]); VecScale( x_ans, 1.0/scale_factor); PetscScalar norm0; Vec Sx; MatCreateVecs(S, &Sx, NULL); MatMult(S, x_ans, Sx); VecDot(x_ans, Sx, &norm0); VecScale(x_ans, 1.0/sqrt(norm0)); *x = x_ans; return 0; }
Vector<Scalar>* PetscVector<Scalar>::change_sign() { PetscScalar* y = malloc_with_check(this->size, this); int *idx = malloc_with_check(this->size, this); for (unsigned int i = 0; i < this->size; i++) idx[i] = i; VecGetValues(vec, this->size, idx, y); for (unsigned int i = 0; i < this->size; i++) y[i] *= -1.; VecSetValues(vec, this->size, idx, y, INSERT_VALUES); free_with_check(y); free_with_check(idx); return this; }
void linearSystemPETSc<scalar>::getFromSolution(int row, scalar &val) const { #if defined(PETSC_USE_COMPLEX) PetscScalar *tmp; _try(VecGetArray(_x, &tmp)); PetscScalar s = tmp[row]; _try(VecRestoreArray(_x, &tmp)); val = s.real(); #else _try(VecGetValues(_x, 1, &row, &val)); #endif }
void linearSystemPETSc<scalar>::getFromRightHandSide(int row, scalar &val) const { #if defined(PETSC_USE_COMPLEX) PetscScalar *tmp; _try(VecGetArray(_b, &tmp)); PetscScalar s = tmp[row]; _try(VecRestoreArray(_b, &tmp)); // FIXME specialize this routine val = s.real(); #else _try(VecGetValues(_b, 1, &row, &val)); #endif }
/** * Copies a PETSc vector into an array of doubles. They must be the same size * * @param vec the PETSc vector * @param array a pointer to the double array */ PetscErrorCode _pvec_to_array(Vec *vec, double *array) { PetscErrorCode ierr; PetscInt size; ierr = VecGetSize(*vec, &size); CHKERRQ(ierr); // Make array of indices int indices[size]; for (int i = 0; i < size; i++) { indices[i] = i; } // Get values from PETSc ierr = VecGetValues(*vec, size, indices, array); CHKERRQ(ierr); return 0; }
bool multiply(const std::vector<double>& input, std::vector<double>& output ) const { for (int i = 0; i < n; ++i) { VecSet(temp_input,input[i]); } MatMult(A, temp_input, temp_output) ; for (int i = 0; i < n; ++i) { PetscInt tempi=i; PetscScalar tempv; VecGetValues(temp_output, 1,&tempi,&tempv); output[i] = tempv; } return true; }
std::complex<double> PetscVector<std::complex<double> >::get(unsigned int idx) const { std::complex<double> y = 0; VecGetValues(vec, 1, (PetscInt*)&idx, &y); return y; }
PetscInt main(PetscInt argc,char **args) { ptrdiff_t N0=256,N1=256,N2=256,N3=2,dim[4]; fftw_plan bplan,fplan; fftw_complex *out; double *in1,*in2; ptrdiff_t alloc_local,local_n0,local_0_start; ptrdiff_t local_n1,local_1_start; PetscInt i,j,indx,n1; PetscInt size,rank,n,N,*in,N_factor,NM; PetscScalar *data_fin,value1,one=1.57,zero=0.0; PetscScalar a,*x_arr,*y_arr,*z_arr,enorm; Vec fin,fout,fout1,ini,final; PetscRandom rnd; PetscErrorCode ierr; VecScatter vecscat,vecscat1; IS indx1,indx2; PetscInt *indx3,k,l,*indx4; PetscInt low,tempindx,tempindx1; ierr = PetscInitialize(&argc,&args,(char*)0,help);if (ierr) return ierr; #if defined(PETSC_USE_COMPLEX) SETERRQ(PETSC_COMM_WORLD,PETSC_ERR_SUP, "This example requires real numbers. Your current scalar type is complex"); #endif ierr = MPI_Comm_size(PETSC_COMM_WORLD, &size);CHKERRQ(ierr); ierr = MPI_Comm_rank(PETSC_COMM_WORLD, &rank);CHKERRQ(ierr); PetscRandomCreate(PETSC_COMM_WORLD,&rnd); alloc_local = fftw_mpi_local_size_3d_transposed(N0,N1,N2/2+1,PETSC_COMM_WORLD,&local_n0,&local_0_start,&local_n1,&local_1_start); /* printf("The value alloc_local is %ld from process %d\n",alloc_local,rank); */ printf("The value local_n0 is %ld from process %d\n",local_n0,rank); /* printf("The value local_0_start is %ld from process %d\n",local_0_start,rank);*/ /* printf("The value local_n1 is %ld from process %d\n",local_n1,rank); */ /* printf("The value local_1_start is %ld from process %d\n",local_1_start,rank);*/ /* Allocate space for input and output arrays */ in1=(double*)fftw_malloc(sizeof(double)*alloc_local*2); in2=(double*)fftw_malloc(sizeof(double)*alloc_local*2); out=(fftw_complex*)fftw_malloc(sizeof(fftw_complex)*alloc_local); N=2*N0*N1*(N2/2+1);N_factor=N0*N1*N2; n=2*local_n0*N1*(N2/2+1);n1=local_n1*N0*2*N1; /* printf("The value N is %d from process %d\n",N,rank); */ /* printf("The value n is %d from process %d\n",n,rank); */ /* printf("The value n1 is %d from process %d\n",n1,rank); */ /* Creating data vector and accompanying array with VeccreateMPIWithArray */ ierr = VecCreateMPIWithArray(PETSC_COMM_WORLD,1,n,N,(PetscScalar*)in1,&fin);CHKERRQ(ierr); ierr = VecCreateMPIWithArray(PETSC_COMM_WORLD,1,n,N,(PetscScalar*)out,&fout);CHKERRQ(ierr); ierr = VecCreateMPIWithArray(PETSC_COMM_WORLD,1,n,N,(PetscScalar*)in2,&fout1);CHKERRQ(ierr); /* VecGetSize(fin,&size); */ /* printf("The size is %d\n",size); */ VecSet(fin,one); VecSet(fout,zero); VecSet(fout1,zero); VecAssemblyBegin(fin); VecAssemblyEnd(fin); /* VecView(fin,PETSC_VIEWER_STDOUT_WORLD); */ VecGetArray(fin,&x_arr); VecGetArray(fout1,&z_arr); VecGetArray(fout,&y_arr); fplan=fftw_mpi_plan_dft_r2c_3d(N0,N1,N2,(double*)x_arr,(fftw_complex*)y_arr,PETSC_COMM_WORLD,FFTW_ESTIMATE); bplan=fftw_mpi_plan_dft_c2r_3d(N0,N1,N2,(fftw_complex*)y_arr,(double*)z_arr,PETSC_COMM_WORLD,FFTW_ESTIMATE); fftw_execute(fplan); fftw_execute(bplan); VecRestoreArray(fin,&x_arr); VecRestoreArray(fout1,&z_arr); VecRestoreArray(fout,&y_arr); /* a = 1.0/(PetscReal)N_factor; */ /* ierr = VecScale(fout1,a);CHKERRQ(ierr); */ VecCreate(PETSC_COMM_WORLD,&ini); VecCreate(PETSC_COMM_WORLD,&final); VecSetSizes(ini,local_n0*N1*N2,N_factor); VecSetSizes(final,local_n0*N1*N2,N_factor); /* VecSetSizes(ini,PETSC_DECIDE,N_factor); */ /* VecSetSizes(final,PETSC_DECIDE,N_factor); */ VecSetFromOptions(ini); VecSetFromOptions(final); if (N2%2==0) NM=N2+2; else NM=N2+1; ierr = VecGetOwnershipRange(fin,&low,NULL); printf("The local index is %d from %d\n",low,rank); ierr = PetscMalloc1(local_n0*N1*N2,&indx3); ierr = PetscMalloc1(local_n0*N1*N2,&indx4); for (i=0; i<local_n0; i++) { for (j=0;j<N1;j++) { for (k=0;k<N2;k++) { tempindx = i*N1*N2 + j*N2 + k; tempindx1 = i*N1*NM + j*NM + k; indx3[tempindx]=local_0_start*N1*N2+tempindx; indx4[tempindx]=low+tempindx1; } /* printf("index3 %d from proc %d is \n",indx3[tempindx],rank); */ /* printf("index4 %d from proc %d is \n",indx4[tempindx],rank); */ } } VecGetValues(fin,local_n0*N1*N2,indx4,x_arr); VecSetValues(ini,local_n0*N1*N2,indx3,x_arr,INSERT_VALUES); VecAssemblyBegin(ini); VecAssemblyEnd(ini); VecGetValues(fout1,local_n0*N1*N2,indx4,y_arr); VecSetValues(final,local_n0*N1*N2,indx3,y_arr,INSERT_VALUES); VecAssemblyBegin(final); VecAssemblyEnd(final); printf("The local index value is %ld from %d",local_n0*N1*N2,rank); /* for (i=0;i<N0;i++) { for (j=0;j<N1;j++) { indx=i*N1*NM+j*NM; ISCreateStride(PETSC_COMM_WORLD,N2,indx,1,&indx1); indx=i*N1*N2+j*N2; ISCreateStride(PETSC_COMM_WORLD,N2,indx,1,&indx2); VecScatterCreate(fin,indx1,ini,indx2,&vecscat); VecScatterBegin(vecscat,fin,ini,INSERT_VALUES,SCATTER_FORWARD); VecScatterEnd(vecscat,fin,ini,INSERT_VALUES,SCATTER_FORWARD); VecScatterCreate(fout1,indx1,final,indx2,&vecscat1); VecScatterBegin(vecscat1,fout1,final,INSERT_VALUES,SCATTER_FORWARD); VecScatterEnd(vecscat1,fout1,final,INSERT_VALUES,SCATTER_FORWARD); } } */ a = 1.0/(PetscReal)N_factor; ierr = VecScale(fout1,a);CHKERRQ(ierr); ierr = VecScale(final,a);CHKERRQ(ierr); VecAssemblyBegin(ini); VecAssemblyEnd(ini); VecAssemblyBegin(final); VecAssemblyEnd(final); /* VecView(final,PETSC_VIEWER_STDOUT_WORLD); */ ierr = VecAXPY(final,-1.0,ini);CHKERRQ(ierr); ierr = VecNorm(final,NORM_1,&enorm);CHKERRQ(ierr); ierr = PetscPrintf(PETSC_COMM_WORLD," Error norm of |x - z| = %e\n",enorm);CHKERRQ(ierr); fftw_destroy_plan(fplan); fftw_destroy_plan(bplan); fftw_free(in1); ierr = VecDestroy(&fin);CHKERRQ(ierr); fftw_free(out); ierr = VecDestroy(&fout);CHKERRQ(ierr); fftw_free(in2); ierr = VecDestroy(&fout1);CHKERRQ(ierr); ierr = PetscFinalize(); return ierr; }
int main(int argc, char** args){ PetscErrorCode err; PetscViewer fd = NULL; Mat invL1 = NULL, invU1 = NULL, invL2 = NULL, invU2 = NULL, H12 = NULL, H21 = NULL; Vec order = NULL, r = NULL; //, or = NULL; //dimension: n: n1 + n2 Vec seeds = NULL; // Vec r1 = NULL, q1 = NULL, t1_1 = NULL, t1_2 = NULL, t1_3 = NULL, t1_4 = NULL, t1_5 = NULL; // dimension: n1 // Vec r2 = NULL, q2 = NULL, q_tilda = NULL, t2_1 = NULL, t2_2 = NULL, t2_3 = NULL; // dimension: n2 PetscRandom rand; PetscLogDouble tic, toc, total_time, time; PetscInt n, i; PetscMPIInt rank, size; PetscInt seed; PetscScalar c, val; PetscInt QN = 100; // Initialize PETSC and MPI err = PetscInitialize(&argc, &args, (char*) 0, help); CHKERRQ(err); err = MPI_Comm_size(PETSC_COMM_WORLD, &size); CHKERRQ(err); err = MPI_Comm_rank(PETSC_COMM_WORLD, &rank); CHKERRQ(err); err = PetscPrintf(PETSC_COMM_WORLD, "mpi size: %d\n", size); CHKERRQ(err); // Read matrices and an ordering vector err = PetscPrintf(PETSC_COMM_WORLD, "Read inputs (invL1, invU1, invL2, invU2, H12, H21, order)\n"); CHKERRQ(err); err = loadMat("./data/invL1.dat", &invL1, PETSC_COMM_WORLD, MATMPIAIJ, &fd); CHKERRQ(err); err = checkMat("invL1", invL1); CHKERRQ(err); err = loadMat("./data/invU1.dat", &invU1, PETSC_COMM_WORLD, MATMPIAIJ, &fd); CHKERRQ(err); err = checkMat("invU1", invU1); CHKERRQ(err); err = loadMat("./data/invL2.dat", &invL2, PETSC_COMM_WORLD, MATMPIAIJ, &fd); CHKERRQ(err); err = checkMat("invL2", invL2); CHKERRQ(err); err = loadMat("./data/invU2.dat", &invU2, PETSC_COMM_WORLD, MATMPIAIJ, &fd); CHKERRQ(err); err = checkMat("invU2", invU2); CHKERRQ(err); err = loadMat("./data/H12.dat", &H12, PETSC_COMM_WORLD, MATMPIAIJ, &fd); CHKERRQ(err); err = checkMat("H12", H12); CHKERRQ(err); err = loadMat("./data/H21.dat", &H21, PETSC_COMM_WORLD, MATMPIAIJ, &fd); CHKERRQ(err); err = checkMat("H21", H21); CHKERRQ(err); err = loadVec("./data/order.dat", &order, PETSC_COMM_SELF, &fd); CHKERRQ(err); //all processes must have this vector for ordering the result vector. err = checkVec("order", order); CHKERRQ(err); // shift -1 for zero-based index err = VecShift(order, -1); CHKERRQ(err); err = VecGetSize(order, &n); CHKERRQ(err); seed = 5; c = 0.05; err = PetscTime(&tic); CHKERRQ(err); //err = BearQueryMat(seed, c, invL1, invU1, invL2, invU2, H12, H21, order); CHKERRQ(err); //err = PetscTime(&toc); CHKERRQ(err); //time = toc - tic; //err = PetscPrintf(PETSC_COMM_WORLD, "running time: %f sec\n", time); CHKERRQ(err); ///* 100 times querying err = VecCreateSeq(PETSC_COMM_SELF, QN, &seeds); CHKERRQ(err); err = VecSetFromOptions(seeds); CHKERRQ(err); err = PetscRandomCreate(PETSC_COMM_WORLD, &rand); CHKERRQ(err); err = PetscRandomSetSeed(rand, 100); CHKERRQ(err); err = PetscRandomSetInterval(rand, (PetscScalar) 0, (PetscScalar) n); CHKERRQ(err); err = PetscRandomSetFromOptions(rand); CHKERRQ(err); err = VecSetRandom(seeds, rand); CHKERRQ(err); err = PetscRandomDestroy(&rand); CHKERRQ(err); seed = 5; //seed is give by user on one-based index c = 0.05; i = 0; err = VecDuplicate(order, &r); CHKERRQ(err); for(i = 0; i < QN; i++){ err = VecGetValues(seeds, 1, &i, &val); seed = (PetscInt) val; //err = PetscPrintf(PETSC_COMM_SELF, "rank: %d, seed: %d\n", rank, seed); err = PetscTime(&tic); CHKERRQ(err); err = BearQuery(seed, c, invL1, invU1, invL2, invU2, H12, H21, order, r); CHKERRQ(err); err = PetscTime(&toc); CHKERRQ(err); time = toc - tic; err = PetscPrintf(PETSC_COMM_WORLD, "running time: %f sec\n", time); CHKERRQ(err); total_time += time; } err = PetscPrintf(PETSC_COMM_WORLD, "average running time: %f sec\n", total_time/QN); CHKERRQ(err); err = VecDestroy(&r); /* err = MatGetSize(H12, &n1, &n2); CHKERRQ(err); n = n1 + n2; err = PetscPrintf(PETSC_COMM_WORLD, "n1: %d, n2: %d\n", n1, n2); CHKERRQ(err); err = VecCreateMPI(PETSC_COMM_WORLD, PETSC_DECIDE, n, &r); CHKERRQ(err); err = VecCreateMPI(PETSC_COMM_WORLD, PETSC_DECIDE, n1, &q1); CHKERRQ(err); err = VecCreateMPI(PETSC_COMM_WORLD, PETSC_DECIDE, n2, &q2); CHKERRQ(err); err = VecSet(q1, 0); CHKERRQ(err); err = VecSet(q2, 0); CHKERRQ(err); seed = seed - 1; // shift -1 for zero-based index err = VecGetValues(order, 1, &seed, &val); CHKERRQ(err); oseed = (PetscInt) val; err = PetscPrintf(PETSC_COMM_WORLD, "Given seed: %d, Reorered seed: %d (0 ~ n-1)\n", seed, oseed); CHKERRQ(err); if(oseed < n1){ err = VecSetValues(q1, 1, &oseed, &one, INSERT_VALUES); CHKERRQ(err); }else{ oseed = oseed - n1; err = VecSetValues(q2, 1, &oseed, &one, INSERT_VALUES); CHKERRQ(err); //err = printVecSum(q2); } err = VecAssemblyBegin(q1); CHKERRQ(err); err = VecAssemblyBegin(q2); CHKERRQ(err); err = VecAssemblyEnd(q1); CHKERRQ(err); err = VecAssemblyEnd(q2); CHKERRQ(err); err = VecDuplicate(q1, &r1); CHKERRQ(err); err = VecDuplicate(q1, &t1_1); CHKERRQ(err); err = VecDuplicate(q1, &t1_2); CHKERRQ(err); err = VecDuplicate(q1, &t1_3); CHKERRQ(err); err = VecDuplicate(q1, &t1_4); CHKERRQ(err); err = VecDuplicate(q1, &t1_5); CHKERRQ(err); err = VecDuplicate(q2, &r2); CHKERRQ(err); err = VecDuplicate(q2, &q_tilda); CHKERRQ(err); err = VecDuplicate(q2, &t2_1); CHKERRQ(err); err = VecDuplicate(q2, &t2_2); CHKERRQ(err); err = VecDuplicate(q2, &t2_3); CHKERRQ(err); // Start matrix-vec multiplications err = MatMult(invL1, q1, t1_1); CHKERRQ(err); err = MatMult(invU1, t1_1, t1_2); CHKERRQ(err); err = MatMult(H21, t1_2, t2_1); CHKERRQ(err); err = VecAXPBYPCZ(q_tilda, 1.0, -1.0, 0.0, q2, t2_1); CHKERRQ(err); err = MatMult(invL2, q_tilda, t2_2); CHKERRQ(err); err = MatMult(invU2, t2_2, r2); CHKERRQ(err); err = MatMult(H12, r2, t1_3); CHKERRQ(err); err = VecAXPBYPCZ(t1_4, 1.0, -1.0, 0.0, q1, t1_3); CHKERRQ(err); err = MatMult(invL1, t1_4, t1_5); CHKERRQ(err); err = MatMult(invU1, t1_5, r1); CHKERRQ(err); //err = printVecSum(r1); //err = VecView(r2, PETSC_VIEWER_STDOUT_WORLD); // Concatenate r1 and r2 err = VecMerge(r1, r2, r); CHKERRQ(err); err = VecScale(r, c); CHKERRQ(err); //err = VecView(r, PETSC_VIEWER_STDOUT_WORLD); err = VecDuplicate(r, &or); CHKERRQ(err); err = VecReorder(r, order, or); CHKERRQ(err); //err = VecView(or, PETSC_VIEWER_STDOUT_WORLD);*/ // Destory matrices and vectors err = MatDestroy(&invL1); CHKERRQ(err); err = MatDestroy(&invU1); CHKERRQ(err); err = MatDestroy(&invL2); CHKERRQ(err); err = MatDestroy(&invU2); CHKERRQ(err); err = MatDestroy(&H12); CHKERRQ(err); err = MatDestroy(&H21); CHKERRQ(err); err = VecDestroy(&order); CHKERRQ(err); err = VecDestroy(&r); CHKERRQ(err); err = VecDestroy(&seeds); CHKERRQ(err); //err = VecDestroy(&or); CHKERRQ(err); /* err = VecDestroy(&r1); CHKERRQ(err); err = VecDestroy(&q1); CHKERRQ(err); err = VecDestroy(&t1_1); CHKERRQ(err); err = VecDestroy(&t1_2); CHKERRQ(err); err = VecDestroy(&t1_3); CHKERRQ(err); err = VecDestroy(&t1_4); CHKERRQ(err); err = VecDestroy(&t1_5); CHKERRQ(err); err = VecDestroy(&r2); CHKERRQ(err); err = VecDestroy(&q2); CHKERRQ(err); err = VecDestroy(&q_tilda); CHKERRQ(err); err = VecDestroy(&t2_1); CHKERRQ(err); err = VecDestroy(&t2_2); CHKERRQ(err); err = VecDestroy(&t2_3); CHKERRQ(err);*/ // Finalize err = PetscFinalize(); CHKERRQ(err); return 0; }
PetscErrorCode cHamiltonianMatrix::measurement(){ double *ALLdepart = new double[Nt]; double *ALLentropy = new double[Nt]; gsl_matrix* density1 = gsl_matrix_alloc(L,Nt);//background fermion density gsl_matrix* density2 = gsl_matrix_alloc(L,Nt);//background fermion density gsl_vector* corr12 = gsl_vector_alloc(Nt);//correlation betwen fermion up and down. // The density correlation is in fact proportional to the interacting energy. double var_rank; PetscScalar var_tmp, var_tmp2; gsl_complex var_tmp_gsl; Vec vectort; VecScatter ctx; ofstream output; VecScatterCreateToZero(WFt[0],&ctx,&vectort); if(rank==0) cout << size << endl; gsl_matrix_complex* RDM = gsl_matrix_complex_alloc(dim2,dim2); gsl_vector *eval_RDM = gsl_vector_alloc(dim2); gsl_eigen_herm_workspace* w_RDM = gsl_eigen_herm_alloc(dim2); for (int itime = 0; itime < Nt; ++itime) { if (rank==0&&itime%10==0) cout << "this is time " << itime << endl; // % ## departure ## var_rank = 0.0; for (int ivar = rstart; ivar < rend; ++ivar) { ierr = VecGetValues(WFt[itime],1,&ivar,&var_tmp);CHKERRQ(ierr); var_rank += pow(gsl_vector_get(rr,ivar)*PetscAbsComplex(var_tmp),2); } MPI_Reduce(&var_rank, &(ALLdepart[itime]), 1, MPI_DOUBLE, MPI_SUM, 0, PETSC_COMM_WORLD); ALLdepart[itime] = sqrt(ALLdepart[itime]); // % ## entropy ## VecScatterBegin(ctx,WFt[itime],vectort,INSERT_VALUES,SCATTER_FORWARD); VecScatterEnd(ctx,WFt[itime],vectort,INSERT_VALUES,SCATTER_FORWARD); if(rank==0) { int ivar;double eigen_RDM; gsl_matrix_complex_set_zero(RDM); for (int row2 = 0; row2 < dim2; ++row2) { for (int col2 = row2; col2 < dim2; ++col2) { var_tmp_gsl.dat[0] = 0.0; var_tmp_gsl.dat[1] = 0.0; for (int jjj = 0; jjj < dim; ++jjj) { ivar = row2*dim+jjj; ierr = VecGetValues(vectort,1,&ivar,&var_tmp);CHKERRQ(ierr); ivar = col2*dim+jjj; ierr = VecGetValues(vectort,1,&ivar,&var_tmp2);CHKERRQ(ierr); var_tmp_gsl.dat[0] += PetscRealPart(var_tmp*PetscConj(var_tmp2)); var_tmp_gsl.dat[1] += PetscImaginaryPart(var_tmp*PetscConj(var_tmp2)); } gsl_matrix_complex_set(RDM,row2,col2,var_tmp_gsl); if (col2 != row2) { gsl_matrix_complex_set(RDM,col2,row2,gsl_matrix_complex_get(RDM,row2,col2)); } } } gsl_eigen_herm(RDM,eval_RDM,w_RDM); ALLentropy[itime] = 0; for (ivar = 0; ivar < dim2; ++ivar) { eigen_RDM = gsl_vector_get(eval_RDM, ivar); // cout << eigen_RDM << endl; ALLentropy[itime] += -eigen_RDM*log(eigen_RDM); } } // % ## density distribution of impurity fermion if(rank==0) { int ivar; for (int row2 = 0; row2 < dim2; ++row2) { for (int jpar = 0; jpar < N2; ++jpar) { double density_tmp=0; for (int jjj = 0; jjj < dim; ++jjj) { ivar = row2*dim+jjj; ierr = VecGetValues(vectort,1,&ivar,&var_tmp);CHKERRQ(ierr); density_tmp +=pow(PetscAbsComplex(var_tmp),2); } /*if (itime==0) { if (rank==0) cout << "density_tmp=" << density_tmp << endl; }*/ gsl_matrix_set(density2,gsl_matrix_get(basis2,jpar,row2)-1,itime,gsl_matrix_get(density2,gsl_matrix_get(basis2,jpar,row2)-1,itime)+density_tmp); } } } /*if (rank==0) { cout << "density of impurity:" << endl; for (int jpar =0; jpar < L; ++jpar) { cout << gsl_matrix_get(density2,jpar,itime) << "\t"; } cout << endl; }*/ // % ## density distribution of majority fermions if(rank==0) { int ivar; for (int jjj = 0; jjj < dim; ++jjj) { for (int jpar = 0; jpar < N; ++jpar) { double density_tmp=0; for (int row2 = 0; row2 < dim2; ++row2) { ivar = row2*dim+jjj; ierr = VecGetValues(vectort,1,&ivar,&var_tmp);CHKERRQ(ierr); density_tmp +=pow(PetscAbsComplex(var_tmp),2); } gsl_matrix_set(density1,gsl_matrix_get(basis1,jpar,jjj)-1,itime,gsl_matrix_get(density1,gsl_matrix_get(basis1,jpar,jjj)-1,itime)+density_tmp); } } } // correlation between impurity and majority fermion if(rank==0) { int ivar; double corr_tmp=0; for (int jimp=0; jimp<dim2; ++jimp) { for (int jmaj=0; jmaj<dim; ++jmaj) { for (int jpar=0; jpar<N; ++jpar) { if (gsl_matrix_get(basis1,jpar,jmaj)==jimp+1){ ivar = jimp*dim+jmaj; ierr = VecGetValues(vectort,1,&ivar,&var_tmp);CHKERRQ(ierr); corr_tmp+=pow(PetscAbsComplex(var_tmp),2); } } } } gsl_vector_set(corr12,itime,corr_tmp); }// end of correlation } if (rank == 0) { char filename[50]; sprintf(filename,"measurement.data"); output.open(filename); output.is_open(); output.precision(16); for (int itime = 0; itime < Nt; ++itime) { if (itime==0) { // cout << "time t[1] " << '\t' << "departure[2] " << '\t' << "entropy[3]" << '\t' << "density of majority [L]" <<'\t' << "density of impurity [L]" << endl; } output << dt*itime-3 << '\t' << ALLdepart[itime] << '\t' << ALLentropy[itime] << '\t'; for (int jpar = 0; jpar < L; ++jpar) { output << gsl_matrix_get(density1,jpar,itime) << '\t'; } for (int jpar = 0; jpar < L; ++jpar) { output << gsl_matrix_get(density2,jpar,itime) << '\t'; } output << gsl_vector_get(corr12,itime) << '\t'; output << endl; } output.close(); } // CopyFile(source,destination,FALSE); delete[] ALLdepart; VecScatterDestroy(&ctx); VecDestroy(&vectort); gsl_matrix_complex_free(RDM); gsl_vector_free(eval_RDM); gsl_eigen_herm_free(w_RDM); gsl_matrix_free(density1); gsl_matrix_free(density2); gsl_vector_free(corr12); // CopyFile(source,destination,FALSE); return ierr; }
PetscErrorCode BearQuery(PetscInt s, PetscScalar c, Mat invL1, Mat invU1, Mat invL2, Mat invU2, Mat H12, Mat H21, Vec order, Vec or){ PetscErrorCode err; PetscInt n1, n2, n; PetscInt oseed; PetscScalar val, one = 1.0; Vec r = NULL; Vec r1 = NULL, q1 = NULL, t1_1 = NULL, t1_2 = NULL, t1_3 = NULL, t1_4 = NULL, t1_5 = NULL; // dimension: n1 Vec r2 = NULL, q2 = NULL, q_tilda = NULL, t2_1 = NULL, t2_2 = NULL, t2_3 = NULL; // dimension: n2 err = MatGetSize(H12, &n1, &n2); CHKERRQ(err); n = n1 + n2; // err = PetscPrintf(PETSC_COMM_WORLD, "n1: %d, n2: %d\n", n1, n2); CHKERRQ(err); err = VecCreateMPI(PETSC_COMM_WORLD, PETSC_DECIDE, n, &r); CHKERRQ(err); err = VecCreateMPI(PETSC_COMM_WORLD, PETSC_DECIDE, n1, &q1); CHKERRQ(err); err = VecCreateMPI(PETSC_COMM_WORLD, PETSC_DECIDE, n2, &q2); CHKERRQ(err); err = VecSet(q1, 0); CHKERRQ(err); err = VecSet(q2, 0); CHKERRQ(err); s = s - 1; // shift -1 for zero-based index err = VecGetValues(order, 1, &s, &val); CHKERRQ(err); oseed = (PetscInt) val; // err = PetscPrintf(PETSC_COMM_WORLD, "Given seed: %d, Reorered seed: %d (0 ~ n-1)\n", s, oseed); CHKERRQ(err); if(oseed < n1){ err = VecSetValues(q1, 1, &oseed, &one, INSERT_VALUES); CHKERRQ(err); }else{ oseed = oseed - n1; err = VecSetValues(q2, 1, &oseed, &one, INSERT_VALUES); CHKERRQ(err); //err = printVecSum(q2); } err = VecAssemblyBegin(q1); CHKERRQ(err); err = VecAssemblyBegin(q2); CHKERRQ(err); err = VecAssemblyEnd(q1); CHKERRQ(err); err = VecAssemblyEnd(q2); CHKERRQ(err); err = VecDuplicate(q1, &r1); CHKERRQ(err); err = VecDuplicate(q1, &t1_1); CHKERRQ(err); err = VecDuplicate(q1, &t1_2); CHKERRQ(err); err = VecDuplicate(q1, &t1_3); CHKERRQ(err); err = VecDuplicate(q1, &t1_4); CHKERRQ(err); err = VecDuplicate(q1, &t1_5); CHKERRQ(err); err = VecDuplicate(q2, &r2); CHKERRQ(err); err = VecDuplicate(q2, &q_tilda); CHKERRQ(err); err = VecDuplicate(q2, &t2_1); CHKERRQ(err); err = VecDuplicate(q2, &t2_2); CHKERRQ(err); err = VecDuplicate(q2, &t2_3); CHKERRQ(err); // Start matrix-vec multiplications err = MatMult(invL1, q1, t1_1); CHKERRQ(err); err = MatMult(invU1, t1_1, t1_2); CHKERRQ(err); err = MatMult(H21, t1_2, t2_1); CHKERRQ(err); err = VecAXPBYPCZ(q_tilda, 1.0, -1.0, 0.0, q2, t2_1); CHKERRQ(err); err = MatMult(invL2, q_tilda, t2_2); CHKERRQ(err); err = MatMult(invU2, t2_2, r2); CHKERRQ(err); err = MatMult(H12, r2, t1_3); CHKERRQ(err); err = VecAXPBYPCZ(t1_4, 1.0, -1.0, 0.0, q1, t1_3); CHKERRQ(err); err = MatMult(invL1, t1_4, t1_5); CHKERRQ(err); err = MatMult(invU1, t1_5, r1); CHKERRQ(err); //err = printVecSum(r1); //err = VecView(r2, PETSC_VIEWER_STDOUT_WORLD); // Concatenate r1 and r2 err = VecMerge(r1, r2, r); CHKERRQ(err); err = VecScale(r, c); CHKERRQ(err); //err = VecView(r, PETSC_VIEWER_STDOUT_WORLD); //err = VecDuplicate(r, &or); CHKERRQ(err); err = VecReorder(r, order, or); CHKERRQ(err); //err = VecView(or, PETSC_VIEWER_STDOUT_WORLD); err = VecDestroy(&r); CHKERRQ(err); err = VecDestroy(&r1); CHKERRQ(err); err = VecDestroy(&q1); CHKERRQ(err); err = VecDestroy(&t1_1); CHKERRQ(err); err = VecDestroy(&t1_2); CHKERRQ(err); err = VecDestroy(&t1_3); CHKERRQ(err); err = VecDestroy(&t1_4); CHKERRQ(err); err = VecDestroy(&t1_5); CHKERRQ(err); err = VecDestroy(&r2); CHKERRQ(err); err = VecDestroy(&q2); CHKERRQ(err); err = VecDestroy(&q_tilda); CHKERRQ(err); err = VecDestroy(&t2_1); CHKERRQ(err); err = VecDestroy(&t2_2); CHKERRQ(err); err = VecDestroy(&t2_3); CHKERRQ(err); return err; }
PetscErrorCode BearQueryMat(PetscInt s, PetscScalar c, Mat invL1, Mat invU1, Mat invL2, Mat invU2, Mat H12, Mat H21, Vec order){ PetscErrorCode err; PetscInt n1, n2, n, M, N; PetscInt oseed; PetscScalar val, one = 1.0; PetscMPIInt size; PetscLogDouble tic, toc; Mat r = NULL; Mat r1 = NULL, q1 = NULL, t1_1 = NULL, t1_2 = NULL, t1_3 = NULL, t1_4 = NULL, t1_5 = NULL; // dimension: n1 Mat r2 = NULL, q2 = NULL, q_tilda = NULL, t2_1 = NULL, t2_2 = NULL, t2_3 = NULL; // dimension: n2_idx Vec vr=NULL, vr1=NULL, vr2=NULL; PetscInt col = 0; err = MPI_Comm_size(PETSC_COMM_WORLD, &size); CHKERRQ(err); err = MatGetSize(H12, &n1, &n2); CHKERRQ(err); n = n1 + n2; err = PetscPrintf(PETSC_COMM_WORLD, "n1: %d, n2: %d\n", n1, n2); CHKERRQ(err); err = MatCreateAIJ(PETSC_COMM_WORLD, PETSC_DECIDE, 1, n, size, 1, NULL, 1, NULL, &r); CHKERRQ(err); err = MatCreateAIJ(PETSC_COMM_WORLD, PETSC_DECIDE, 1, n1, size, 1, NULL, 1, NULL, &q1); CHKERRQ(err); err = MatCreateAIJ(PETSC_COMM_WORLD, PETSC_DECIDE, 1, n2, size, 1, NULL, 1, NULL, &q2); CHKERRQ(err); // err = MatCreate(PETSC_COMM_WORLD, &q2); CHKERRQ(err); // err = MatSetSizes(q2, PETSC_DECIDE, PETSC_DECIDE, n2, 1); CHKERRQ(err); // err = MatSetType(q2, MATAIJ); CHKERRQ(err); // err = MatSetUp(q2); s = s - 1; // shift -1 for zero-based index err = VecGetValues(order, 1, &s, &val); CHKERRQ(err); oseed = (PetscInt) val; // err = PetscPrintf(PETSC_COMM_WORLD, "Given seed: %d, Reorered seed: %d (0 ~ n-1)\n", s, oseed); CHKERRQ(err); if(oseed < n1){ //err = MatSetValues(q1, 1, &oseed, 1, &col, &one, INSERT_VALUES); CHKERRQ(err); err = MatSetValue(q1, oseed, col, one, INSERT_VALUES); CHKERRQ(err); }else{ oseed = oseed - n1; //err = MatSetValues(q2, 1, &oseed, 1, &col, &one, INSERT_VALUES); CHKERRQ(err); err = MatSetValue(q2, oseed, col, one, INSERT_VALUES); CHKERRQ(err); //err = printVecSum(q2); } err = MatAssemblyBegin(q1, MAT_FINAL_ASSEMBLY); CHKERRQ(err); err = MatAssemblyEnd(q1, MAT_FINAL_ASSEMBLY); CHKERRQ(err); err = MatAssemblyBegin(q2, MAT_FINAL_ASSEMBLY); CHKERRQ(err); err = MatAssemblyEnd(q2, MAT_FINAL_ASSEMBLY); CHKERRQ(err); err = printMatInfo("q1", q1); err = printMatInfo("q2", q2); //err = MatView(q1, PETSC_VIEWER_STDOUT_WORLD); //err = MatView(q2, PETSC_VIEWER_STDOUT_WORLD); err = MatDuplicate(q1, MAT_DO_NOT_COPY_VALUES, &r1); CHKERRQ(err); err = MatDuplicate(q1, MAT_DO_NOT_COPY_VALUES, &t1_1); CHKERRQ(err); err = MatDuplicate(q1, MAT_DO_NOT_COPY_VALUES, &t1_2); CHKERRQ(err); err = MatDuplicate(q1, MAT_DO_NOT_COPY_VALUES, &t1_3); CHKERRQ(err); err = MatDuplicate(q1, MAT_DO_NOT_COPY_VALUES, &t1_4); CHKERRQ(err); err = MatDuplicate(q1, MAT_DO_NOT_COPY_VALUES, &t1_5); CHKERRQ(err); err = MatDuplicate(q2, MAT_DO_NOT_COPY_VALUES, &r2); CHKERRQ(err); err = MatDuplicate(q2, MAT_DO_NOT_COPY_VALUES, &q_tilda); CHKERRQ(err); err = MatDuplicate(q2, MAT_DO_NOT_COPY_VALUES, &t2_1); CHKERRQ(err); err = MatDuplicate(q2, MAT_DO_NOT_COPY_VALUES, &t2_2); CHKERRQ(err); err = MatDuplicate(q2, MAT_DO_NOT_COPY_VALUES, &t2_3); CHKERRQ(err); err = MatMatMult(invL1, q1, MAT_INITIAL_MATRIX, PETSC_DEFAULT, &t1_1); CHKERRQ(err); err = MatMatMult(invU1, t1_1, MAT_INITIAL_MATRIX, PETSC_DEFAULT, &t1_2); CHKERRQ(err); err = MatMatMult(H21, t1_2, MAT_INITIAL_MATRIX, PETSC_DEFAULT, &t2_1); CHKERRQ(err); err = MatScale(t2_1, -1.0); CHKERRQ(err); err = MatAXPY(t2_1, 1.0, q2, DIFFERENT_NONZERO_PATTERN); CHKERRQ(err); //MatView(t1_1, PETSC_VIEWER_STDOUT_WORLD); err = PetscTime(&tic); err = MatMatMult(invL2, t2_1, MAT_INITIAL_MATRIX, PETSC_DEFAULT, &t2_2); CHKERRQ(err); err = MatMatMult(invU2, t2_2, MAT_INITIAL_MATRIX, PETSC_DEFAULT, &r2); CHKERRQ(err); err = PetscTime(&toc); err = PetscPrintf(PETSC_COMM_WORLD, "running time: %f sec\n", toc-tic); CHKERRQ(err); err = MatMatMult(H12, r2, MAT_INITIAL_MATRIX, PETSC_DEFAULT, &t1_3); CHKERRQ(err); err = MatScale(t1_3, -1.0); CHKERRQ(err); err = MatAXPY(t1_3, 1.0, q1, DIFFERENT_NONZERO_PATTERN); CHKERRQ(err); err = MatMatMult(invL1, t1_3, MAT_INITIAL_MATRIX, PETSC_DEFAULT, &t1_5); CHKERRQ(err); err = MatMatMult(invU1, t1_5, MAT_INITIAL_MATRIX, PETSC_DEFAULT, &r1); CHKERRQ(err); //MatView(r1, PETSC_VIEWER_STDOUT_WORLD); MatGetSize(r1, &M, &N); PetscPrintf(PETSC_COMM_WORLD, "%d %d\n", M, N); err = VecCreateMPI(PETSC_COMM_WORLD, PETSC_DECIDE, n1, &vr1); err = MatGetColumnVector(r1, vr1, 0); err = VecCreateMPI(PETSC_COMM_WORLD, PETSC_DECIDE, n2, &vr2); err = MatGetColumnVector(r2, vr2, 0); err = printMatInfo("r2", r2); /* // Start matrix-vec multiplications err = MatMult(invU2, t2_2, r2); CHKERRQ(err); err = MatMult(H12, r2, t1_3); CHKERRQ(err); err = VecAXPBYPCZ(t1_4, 1.0, -1.0, 0.0, q1, t1_3); CHKERRQ(err); err = MatMult(invL1, t1_4, t1_5); CHKERRQ(err); err = MatMult(invU1, t1_5, r1); CHKERRQ(err); //err = printVecSum(r1); //err = VecView(r2, PETSC_VIEWER_STDOUT_WORLD); // Concatenate r1 and r2 err = VecMerge(r1, r2, r); CHKERRQ(err); err = VecScale(r, c); CHKERRQ(err); //err = VecView(r, PETSC_VIEWER_STDOUT_WORLD); //err = VecDuplicate(r, &or); CHKERRQ(err); err = VecReorder(r, order, or); CHKERRQ(err); //err = VecView(or, PETSC_VIEWER_STDOUT_WORLD); */ err = MatDestroy(&r); CHKERRQ(err); err = MatDestroy(&r1); CHKERRQ(err); err = MatDestroy(&q1); CHKERRQ(err); err = MatDestroy(&t1_1); CHKERRQ(err); err = MatDestroy(&t1_2); CHKERRQ(err); err = MatDestroy(&t1_3); CHKERRQ(err); err = MatDestroy(&t1_4); CHKERRQ(err); err = MatDestroy(&t1_5); CHKERRQ(err); err = MatDestroy(&r2); CHKERRQ(err); err = MatDestroy(&q2); CHKERRQ(err); err = MatDestroy(&q_tilda); CHKERRQ(err); err = MatDestroy(&t2_1); CHKERRQ(err); err = MatDestroy(&t2_2); CHKERRQ(err); err = MatDestroy(&t2_3); CHKERRQ(err); return err; }
int SparseGp_logLikeGrad (SparseGp *gp, HyperParam hp, int lengthInd, double *logLikeGrad) { PetscErrorCode ierr; (void) ierr; /* compute t' inv(K) (dKdt inv(K) t) */ /* 1. solve inv(K) t */ PetscInt N = gp->trainLabels->size; Vec invKt; ierr = petsc_util_createVec (&invKt, gp->nlocal, N); SparseGp_solve (gp, gp->_trainLabels, &invKt); /* 2. multiply dKdt by invKt */ Vec dKdtInvKt; ierr = petsc_util_createVec (&dKdtInvKt, gp->nlocal, N); SparseGp_KGradient (gp, hp, lengthInd); MatMult (gp->_KGradient, invKt, dKdtInvKt); /* 3. solve invK (vector from step 2.) */ Vec invKDkdtInvKt; ierr = petsc_util_createVec (&invKDkdtInvKt, gp->nlocal, N); SparseGp_solve (gp, dKdtInvKt, &invKDkdtInvKt); /* 4. compute inner product */ double dotProd; VecDot (gp->_trainLabels, invKDkdtInvKt, &dotProd); /* compute trace (invK dKdt) */ /* 1. for each column in dKdt, solve */ double myTrace = 0; Vec col, solution; petsc_util_createVec (&col, gp->nlocal, N); petsc_util_createVec (&solution, gp->nlocal, N); for (int i=0; i<N; i++) { /* IOU_ROOT_PRINT ("%d --- %d\n", i, N); */ int row = i; ierr = MatGetColumnVector (gp->_KGradient, col, row); /* IOU_ROOT_PRINT ("solving...\n"); */ SparseGp_solve (gp, col, &solution); /* IOU_ROOT_PRINT ("solved\n"); */ if (row < gp->rend && row >= gp->rstart) { double ii; VecGetValues (solution, 1, &row, &ii); myTrace += ii; } } /* gather all trace terms */ int numProcs; MPI_Comm_size (PETSC_COMM_WORLD, &numProcs); double diag[numProcs]; int ret = MPI_Allgather (&myTrace, 1, MPI_DOUBLE, diag, 1, MPI_DOUBLE, PETSC_COMM_WORLD); (void) ret; double trace = 0; for (int i=0; i<numProcs; i++) trace += diag[i]; /* IOU_ROOT_PRINT ("Cleaning up...\n"); */ /* clean up */ VecDestroy (&invKt); VecDestroy (&dKdtInvKt); VecDestroy (&invKDkdtInvKt); VecDestroy (&col); VecDestroy (&solution); /* IOU_ROOT_PRINT ("Done cleaning up...\n"); */ *logLikeGrad = 0.5*dotProd + 0.5*trace; return EXIT_SUCCESS; }
int main(int argc,char **args) { const ptrdiff_t N0=2056,N1=2056; fftw_plan bplan,fplan; fftw_complex *out; double *in1,*in2; ptrdiff_t alloc_local,local_n0,local_0_start; ptrdiff_t local_n1,local_1_start; PetscInt i,j; PetscMPIInt size,rank; int n,N,N_factor,NM; PetscScalar one=2.0,zero=0.5; PetscScalar two=4.0,three=8.0,four=16.0; PetscScalar a,*x_arr,*y_arr,*z_arr; PetscReal enorm; Vec fin,fout,fout1; Vec ini,final; PetscRandom rnd; PetscErrorCode ierr; PetscInt *indx3,tempindx,low,*indx4,tempindx1; ierr = PetscInitialize(&argc,&args,(char*)0,help);if (ierr) return ierr; ierr = MPI_Comm_size(PETSC_COMM_WORLD, &size);CHKERRQ(ierr); ierr = MPI_Comm_rank(PETSC_COMM_WORLD, &rank);CHKERRQ(ierr); ierr = PetscRandomCreate(PETSC_COMM_WORLD,&rnd);CHKERRQ(ierr); alloc_local = fftw_mpi_local_size_2d_transposed(N0,N1/2+1,PETSC_COMM_WORLD,&local_n0,&local_0_start,&local_n1,&local_1_start); #if defined(DEBUGGING) printf("The value alloc_local is %ld from process %d\n",alloc_local,rank); printf("The value local_n0 is %ld from process %d\n",local_n0,rank); printf("The value local_0_start is %ld from process %d\n",local_0_start,rank); /* printf("The value local_n1 is %ld from process %d\n",local_n1,rank); */ /* printf("The value local_1_start is %ld from process %d\n",local_1_start,rank); */ /* printf("The value local_n0 is %ld from process %d\n",local_n0,rank); */ #endif /* Allocate space for input and output arrays */ in1=(double*)fftw_malloc(sizeof(double)*alloc_local*2); in2=(double*)fftw_malloc(sizeof(double)*alloc_local*2); out=(fftw_complex*)fftw_malloc(sizeof(fftw_complex)*alloc_local); N = 2*N0*(N1/2+1); N_factor = N0*N1; n = 2*local_n0*(N1/2+1); /* printf("The value N is %d from process %d\n",N,rank); */ /* printf("The value n is %d from process %d\n",n,rank); */ /* printf("The value n1 is %d from process %d\n",n1,rank);*/ /* Creating data vector and accompanying array with VeccreateMPIWithArray */ ierr = VecCreateMPIWithArray(PETSC_COMM_WORLD,1,n,N,(PetscScalar*)in1,&fin);CHKERRQ(ierr); ierr = VecCreateMPIWithArray(PETSC_COMM_WORLD,1,n,N,(PetscScalar*)out,&fout);CHKERRQ(ierr); ierr = VecCreateMPIWithArray(PETSC_COMM_WORLD,1,n,N,(PetscScalar*)in2,&fout1);CHKERRQ(ierr); /* Set the vector with random data */ ierr = VecSet(fin,zero);CHKERRQ(ierr); /* for (i=0;i<N0*N1;i++) */ /* { */ /* VecSetValues(fin,1,&i,&one,INSERT_VALUES); */ /* } */ /* VecSet(fin,one); */ i =0; ierr = VecSetValues(fin,1,&i,&one,INSERT_VALUES);CHKERRQ(ierr); i =1; ierr = VecSetValues(fin,1,&i,&two,INSERT_VALUES);CHKERRQ(ierr); i =4; ierr = VecSetValues(fin,1,&i,&three,INSERT_VALUES);CHKERRQ(ierr); i =5; ierr = VecSetValues(fin,1,&i,&four,INSERT_VALUES);CHKERRQ(ierr); ierr = VecAssemblyBegin(fin);CHKERRQ(ierr); ierr = VecAssemblyEnd(fin);CHKERRQ(ierr); ierr = VecSet(fout,zero);CHKERRQ(ierr); ierr = VecSet(fout1,zero);CHKERRQ(ierr); /* Get the meaningful portion of array */ ierr = VecGetArray(fin,&x_arr);CHKERRQ(ierr); ierr = VecGetArray(fout1,&z_arr);CHKERRQ(ierr); ierr = VecGetArray(fout,&y_arr);CHKERRQ(ierr); fplan=fftw_mpi_plan_dft_r2c_2d(N0,N1,(double*)x_arr,(fftw_complex*)y_arr,PETSC_COMM_WORLD,FFTW_ESTIMATE); bplan=fftw_mpi_plan_dft_c2r_2d(N0,N1,(fftw_complex*)y_arr,(double*)z_arr,PETSC_COMM_WORLD,FFTW_ESTIMATE); fftw_execute(fplan); fftw_execute(bplan); ierr = VecRestoreArray(fin,&x_arr); ierr = VecRestoreArray(fout1,&z_arr); ierr = VecRestoreArray(fout,&y_arr); /* VecView(fin,PETSC_VIEWER_STDOUT_WORLD); */ ierr = VecCreate(PETSC_COMM_WORLD,&ini);CHKERRQ(ierr); ierr = VecCreate(PETSC_COMM_WORLD,&final);CHKERRQ(ierr); ierr = VecSetSizes(ini,local_n0*N1,N0*N1);CHKERRQ(ierr); ierr = VecSetSizes(final,local_n0*N1,N0*N1);CHKERRQ(ierr); ierr = VecSetFromOptions(ini);CHKERRQ(ierr); ierr = VecSetFromOptions(final);CHKERRQ(ierr); if (N1%2==0) { NM = N1+2; } else { NM = N1+1; } /*printf("The Value of NM is %d",NM); */ ierr = VecGetOwnershipRange(fin,&low,NULL); /*printf("The local index is %d from %d\n",low,rank); */ ierr = PetscMalloc1(local_n0*N1,&indx3); ierr = PetscMalloc1(local_n0*N1,&indx4); for (i=0;i<local_n0;i++) { for (j=0;j<N1;j++) { tempindx = i*N1 + j; tempindx1 = i*NM + j; indx3[tempindx]=local_0_start*N1+tempindx; indx4[tempindx]=low+tempindx1; /* printf("index3 %d from proc %d is \n",indx3[tempindx],rank); */ /* printf("index4 %d from proc %d is \n",indx4[tempindx],rank); */ } } ierr = PetscMalloc2(local_n0*N1,&x_arr,local_n0*N1,&y_arr);CHKERRQ(ierr); /* arr must be allocated for VecGetValues() */ ierr = VecGetValues(fin,local_n0*N1,indx4,(PetscScalar*)x_arr);CHKERRQ(ierr); ierr = VecSetValues(ini,local_n0*N1,indx3,x_arr,INSERT_VALUES);CHKERRQ(ierr); ierr = VecAssemblyBegin(ini);CHKERRQ(ierr); ierr = VecAssemblyEnd(ini);CHKERRQ(ierr); ierr = VecGetValues(fout1,local_n0*N1,indx4,y_arr); ierr = VecSetValues(final,local_n0*N1,indx3,y_arr,INSERT_VALUES); ierr = VecAssemblyBegin(final); ierr = VecAssemblyEnd(final); ierr = PetscFree2(x_arr,y_arr);CHKERRQ(ierr); /* VecScatter vecscat; IS indx1,indx2; for (i=0;i<N0;i++) { indx = i*NM; ISCreateStride(PETSC_COMM_WORLD,N1,indx,1,&indx1); indx = i*N1; ISCreateStride(PETSC_COMM_WORLD,N1,indx,1,&indx2); VecScatterCreate(fin,indx1,ini,indx2,&vecscat); VecScatterBegin(vecscat,fin,ini,INSERT_VALUES,SCATTER_FORWARD); VecScatterEnd(vecscat,fin,ini,INSERT_VALUES,SCATTER_FORWARD); VecScatterBegin(vecscat,fout1,final,INSERT_VALUES,SCATTER_FORWARD); VecScatterEnd(vecscat,fout1,final,INSERT_VALUES,SCATTER_FORWARD); } */ a = 1.0/(PetscReal)N_factor; ierr = VecScale(fout1,a);CHKERRQ(ierr); ierr = VecScale(final,a);CHKERRQ(ierr); /* VecView(ini,PETSC_VIEWER_STDOUT_WORLD); */ /* VecView(final,PETSC_VIEWER_STDOUT_WORLD); */ ierr = VecAXPY(final,-1.0,ini);CHKERRQ(ierr); ierr = VecNorm(final,NORM_1,&enorm);CHKERRQ(ierr); if (enorm > 1.e-10) { ierr = PetscPrintf(PETSC_COMM_WORLD," Error norm of |x - z| = %e\n",enorm);CHKERRQ(ierr); } /* Execute fftw with function fftw_execute and destory it after execution */ fftw_destroy_plan(fplan); fftw_destroy_plan(bplan); fftw_free(in1); ierr = VecDestroy(&fin);CHKERRQ(ierr); fftw_free(out); ierr = VecDestroy(&fout);CHKERRQ(ierr); fftw_free(in2); ierr = VecDestroy(&fout1);CHKERRQ(ierr); ierr = VecDestroy(&ini);CHKERRQ(ierr); ierr = VecDestroy(&final);CHKERRQ(ierr); ierr = PetscRandomDestroy(&rnd);CHKERRQ(ierr); ierr = PetscFree(indx3);CHKERRQ(ierr); ierr = PetscFree(indx4);CHKERRQ(ierr); ierr = PetscFinalize(); return ierr; }
PetscErrorCode PCGAMGProlongator_Classical_Direct(PC pc, const Mat A, const Mat G, PetscCoarsenData *agg_lists,Mat *P) { PetscErrorCode ierr; MPI_Comm comm; PetscReal *Amax_pos,*Amax_neg; Mat lA,gA; /* on and off diagonal matrices */ PetscInt fn; /* fine local blocked sizes */ PetscInt cn; /* coarse local blocked sizes */ PetscInt gn; /* size of the off-diagonal fine vector */ PetscInt fs,fe; /* fine (row) ownership range*/ PetscInt cs,ce; /* coarse (column) ownership range */ PetscInt i,j; /* indices! */ PetscBool iscoarse; /* flag for determining if a node is coarse */ PetscInt *lcid,*gcid; /* on and off-processor coarse unknown IDs */ PetscInt *lsparse,*gsparse; /* on and off-processor sparsity patterns for prolongator */ PetscScalar pij; const PetscScalar *rval; const PetscInt *rcol; PetscScalar g_pos,g_neg,a_pos,a_neg,diag,invdiag,alpha,beta; Vec F; /* vec of coarse size */ Vec C; /* vec of fine size */ Vec gF; /* vec of off-diagonal fine size */ MatType mtype; PetscInt c_indx; PetscScalar c_scalar; PetscInt ncols,col; PetscInt row_f,row_c; PetscInt cmax=0,idx; PetscScalar *pvals; PetscInt *pcols; PC_MG *mg = (PC_MG*)pc->data; PC_GAMG *gamg = (PC_GAMG*)mg->innerctx; PetscFunctionBegin; comm = ((PetscObject)pc)->comm; ierr = MatGetOwnershipRange(A,&fs,&fe); CHKERRQ(ierr); fn = (fe - fs); ierr = MatGetVecs(A,&F,NULL);CHKERRQ(ierr); /* get the number of local unknowns and the indices of the local unknowns */ ierr = PetscMalloc(sizeof(PetscInt)*fn,&lsparse);CHKERRQ(ierr); ierr = PetscMalloc(sizeof(PetscInt)*fn,&gsparse);CHKERRQ(ierr); ierr = PetscMalloc(sizeof(PetscInt)*fn,&lcid);CHKERRQ(ierr); ierr = PetscMalloc(sizeof(PetscReal)*fn,&Amax_pos);CHKERRQ(ierr); ierr = PetscMalloc(sizeof(PetscReal)*fn,&Amax_neg);CHKERRQ(ierr); /* count the number of coarse unknowns */ cn = 0; for (i=0;i<fn;i++) { /* filter out singletons */ ierr = PetscCDEmptyAt(agg_lists,i,&iscoarse); CHKERRQ(ierr); lcid[i] = -1; if (!iscoarse) { cn++; } } /* create the coarse vector */ ierr = VecCreateMPI(comm,cn,PETSC_DECIDE,&C);CHKERRQ(ierr); ierr = VecGetOwnershipRange(C,&cs,&ce);CHKERRQ(ierr); /* construct a global vector indicating the global indices of the coarse unknowns */ cn = 0; for (i=0;i<fn;i++) { ierr = PetscCDEmptyAt(agg_lists,i,&iscoarse); CHKERRQ(ierr); if (!iscoarse) { lcid[i] = cs+cn; cn++; } else { lcid[i] = -1; } *((PetscInt *)&c_scalar) = lcid[i]; c_indx = fs+i; ierr = VecSetValues(F,1,&c_indx,&c_scalar,INSERT_VALUES);CHKERRQ(ierr); } ierr = VecAssemblyBegin(F);CHKERRQ(ierr); ierr = VecAssemblyEnd(F);CHKERRQ(ierr); /* determine the biggest off-diagonal entries in each row */ for (i=fs;i<fe;i++) { Amax_pos[i-fs] = 0.; Amax_neg[i-fs] = 0.; ierr = MatGetRow(A,i,&ncols,&rcol,&rval);CHKERRQ(ierr); for(j=0;j<ncols;j++){ if ((PetscRealPart(-rval[j]) > Amax_neg[i-fs]) && i != rcol[j]) Amax_neg[i-fs] = PetscAbsScalar(rval[j]); if ((PetscRealPart(rval[j]) > Amax_pos[i-fs]) && i != rcol[j]) Amax_pos[i-fs] = PetscAbsScalar(rval[j]); } if (ncols > cmax) cmax = ncols; ierr = MatRestoreRow(A,i,&ncols,&rcol,&rval);CHKERRQ(ierr); } ierr = PetscMalloc(sizeof(PetscInt)*cmax,&pcols);CHKERRQ(ierr); ierr = PetscMalloc(sizeof(PetscScalar)*cmax,&pvals);CHKERRQ(ierr); /* split the operator into two */ ierr = PCGAMGClassicalGraphSplitting_Private(A,&lA,&gA);CHKERRQ(ierr); /* scatter to the ghost vector */ ierr = PCGAMGClassicalCreateGhostVector_Private(A,&gF,NULL);CHKERRQ(ierr); ierr = PCGAMGClassicalGhost_Private(A,F,gF);CHKERRQ(ierr); if (gA) { ierr = VecGetSize(gF,&gn);CHKERRQ(ierr); ierr = PetscMalloc(sizeof(PetscInt)*gn,&gcid);CHKERRQ(ierr); for (i=0;i<gn;i++) { ierr = VecGetValues(gF,1,&i,&c_scalar);CHKERRQ(ierr); gcid[i] = *((PetscInt *)&c_scalar); } } ierr = VecDestroy(&F);CHKERRQ(ierr); ierr = VecDestroy(&gF);CHKERRQ(ierr); ierr = VecDestroy(&C);CHKERRQ(ierr); /* count the on and off processor sparsity patterns for the prolongator */ for (i=0;i<fn;i++) { /* on */ lsparse[i] = 0; gsparse[i] = 0; if (lcid[i] >= 0) { lsparse[i] = 1; gsparse[i] = 0; } else { ierr = MatGetRow(lA,i,&ncols,&rcol,&rval);CHKERRQ(ierr); for (j = 0;j < ncols;j++) { col = rcol[j]; if (lcid[col] >= 0 && (PetscRealPart(rval[j]) > gamg->threshold*Amax_pos[i] || PetscRealPart(-rval[j]) > gamg->threshold*Amax_neg[i])) { lsparse[i] += 1; } } ierr = MatRestoreRow(lA,i,&ncols,&rcol,&rval);CHKERRQ(ierr); /* off */ if (gA) { ierr = MatGetRow(gA,i,&ncols,&rcol,&rval);CHKERRQ(ierr); for (j = 0; j < ncols; j++) { col = rcol[j]; if (gcid[col] >= 0 && (PetscRealPart(rval[j]) > gamg->threshold*Amax_pos[i] || PetscRealPart(-rval[j]) > gamg->threshold*Amax_neg[i])) { gsparse[i] += 1; } } ierr = MatRestoreRow(gA,i,&ncols,&rcol,&rval);CHKERRQ(ierr); } } } /* preallocate and create the prolongator */ ierr = MatCreate(comm,P); CHKERRQ(ierr); ierr = MatGetType(G,&mtype);CHKERRQ(ierr); ierr = MatSetType(*P,mtype);CHKERRQ(ierr); ierr = MatSetSizes(*P,fn,cn,PETSC_DETERMINE,PETSC_DETERMINE);CHKERRQ(ierr); ierr = MatMPIAIJSetPreallocation(*P,0,lsparse,0,gsparse);CHKERRQ(ierr); ierr = MatSeqAIJSetPreallocation(*P,0,lsparse);CHKERRQ(ierr); /* loop over local fine nodes -- get the diagonal, the sum of positive and negative strong and weak weights, and set up the row */ for (i = 0;i < fn;i++) { /* determine on or off */ row_f = i + fs; row_c = lcid[i]; if (row_c >= 0) { pij = 1.; ierr = MatSetValues(*P,1,&row_f,1,&row_c,&pij,INSERT_VALUES);CHKERRQ(ierr); } else { g_pos = 0.; g_neg = 0.; a_pos = 0.; a_neg = 0.; diag = 0.; /* local connections */ ierr = MatGetRow(lA,i,&ncols,&rcol,&rval);CHKERRQ(ierr); for (j = 0; j < ncols; j++) { col = rcol[j]; if (lcid[col] >= 0 && (PetscRealPart(rval[j]) > gamg->threshold*Amax_pos[i] || PetscRealPart(-rval[j]) > gamg->threshold*Amax_neg[i])) { if (PetscRealPart(rval[j]) > 0.) { g_pos += rval[j]; } else { g_neg += rval[j]; } } if (col != i) { if (PetscRealPart(rval[j]) > 0.) { a_pos += rval[j]; } else { a_neg += rval[j]; } } else { diag = rval[j]; } } ierr = MatRestoreRow(lA,i,&ncols,&rcol,&rval);CHKERRQ(ierr); /* ghosted connections */ if (gA) { ierr = MatGetRow(gA,i,&ncols,&rcol,&rval);CHKERRQ(ierr); for (j = 0; j < ncols; j++) { col = rcol[j]; if (gcid[col] >= 0 && (PetscRealPart(rval[j]) > gamg->threshold*Amax_pos[i] || PetscRealPart(-rval[j]) > gamg->threshold*Amax_neg[i])) { if (PetscRealPart(rval[j]) > 0.) { g_pos += rval[j]; } else { g_neg += rval[j]; } } if (PetscRealPart(rval[j]) > 0.) { a_pos += rval[j]; } else { a_neg += rval[j]; } } ierr = MatRestoreRow(gA,i,&ncols,&rcol,&rval);CHKERRQ(ierr); } if (g_neg == 0.) { alpha = 0.; } else { alpha = -a_neg/g_neg; } if (g_pos == 0.) { diag += a_pos; beta = 0.; } else { beta = -a_pos/g_pos; } if (diag == 0.) { invdiag = 0.; } else invdiag = 1. / diag; /* on */ ierr = MatGetRow(lA,i,&ncols,&rcol,&rval);CHKERRQ(ierr); idx = 0; for (j = 0;j < ncols;j++) { col = rcol[j]; if (lcid[col] >= 0 && (PetscRealPart(rval[j]) > gamg->threshold*Amax_pos[i] || PetscRealPart(-rval[j]) > gamg->threshold*Amax_neg[i])) { row_f = i + fs; row_c = lcid[col]; /* set the values for on-processor ones */ if (PetscRealPart(rval[j]) < 0.) { pij = rval[j]*alpha*invdiag; } else { pij = rval[j]*beta*invdiag; } if (PetscAbsScalar(pij) != 0.) { pvals[idx] = pij; pcols[idx] = row_c; idx++; } } } ierr = MatRestoreRow(lA,i,&ncols,&rcol,&rval);CHKERRQ(ierr); /* off */ if (gA) { ierr = MatGetRow(gA,i,&ncols,&rcol,&rval);CHKERRQ(ierr); for (j = 0; j < ncols; j++) { col = rcol[j]; if (gcid[col] >= 0 && (PetscRealPart(rval[j]) > gamg->threshold*Amax_pos[i] || PetscRealPart(-rval[j]) > gamg->threshold*Amax_neg[i])) { row_f = i + fs; row_c = gcid[col]; /* set the values for on-processor ones */ if (PetscRealPart(rval[j]) < 0.) { pij = rval[j]*alpha*invdiag; } else { pij = rval[j]*beta*invdiag; } if (PetscAbsScalar(pij) != 0.) { pvals[idx] = pij; pcols[idx] = row_c; idx++; } } } ierr = MatRestoreRow(gA,i,&ncols,&rcol,&rval);CHKERRQ(ierr); } ierr = MatSetValues(*P,1,&row_f,idx,pcols,pvals,INSERT_VALUES);CHKERRQ(ierr); } } ierr = MatAssemblyBegin(*P, MAT_FINAL_ASSEMBLY);CHKERRQ(ierr); ierr = MatAssemblyEnd(*P, MAT_FINAL_ASSEMBLY);CHKERRQ(ierr); ierr = PetscFree(lsparse);CHKERRQ(ierr); ierr = PetscFree(gsparse);CHKERRQ(ierr); ierr = PetscFree(pcols);CHKERRQ(ierr); ierr = PetscFree(pvals);CHKERRQ(ierr); ierr = PetscFree(Amax_pos);CHKERRQ(ierr); ierr = PetscFree(Amax_neg);CHKERRQ(ierr); ierr = PetscFree(lcid);CHKERRQ(ierr); if (gA) {ierr = PetscFree(gcid);CHKERRQ(ierr);} PetscFunctionReturn(0); }