PEXSI
 All Classes Namespaces Files Functions Variables Typedefs Pages
pselinv.hpp
Go to the documentation of this file.
1 /*
2  Copyright (c) 2012 The Regents of the University of California,
3  through Lawrence Berkeley National Laboratory.
4 
5  Authors: Lin Lin and Mathias Jacquelin
6 
7  This file is part of PEXSI. All rights reserved.
8 
9  Redistribution and use in source and binary forms, with or without
10  modification, are permitted provided that the following conditions are met:
11 
12  (1) Redistributions of source code must retain the above copyright notice, this
13  list of conditions and the following disclaimer.
14  (2) Redistributions in binary form must reproduce the above copyright notice,
15  this list of conditions and the following disclaimer in the documentation
16  and/or other materials provided with the distribution.
17  (3) Neither the name of the University of California, Lawrence Berkeley
18  National Laboratory, U.S. Dept. of Energy nor the names of its contributors may
19  be used to endorse or promote products derived from this software without
20  specific prior written permission.
21 
22  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
23  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
24  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
25  DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
26  ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
27  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
28  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
29  ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
30  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
31  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
32 
33  You are under no obligation whatsoever to provide any bug fixes, patches, or
34  upgrades to the features, functionality or performance of the source code
35  ("Enhancements") to anyone; however, if you choose to make your Enhancements
36  available either publicly, or directly to Lawrence Berkeley National
37  Laboratory, without imposing a separate written license agreement for such
38  Enhancements, then you hereby grant the following license: a non-exclusive,
39  royalty-free perpetual license to install, use, modify, prepare derivative
40  works, incorporate into other computer software, distribute, and sublicense
41  such enhancements or derivative works thereof, in binary and source code form.
42 */
46 #ifndef _PEXSI_PSELINV_HPP_
47 #define _PEXSI_PSELINV_HPP_
48 
49 // *********************************************************************
50 // Common utilities
51 // *********************************************************************
52 
53 #include "pexsi/environment.hpp"
54 #include "pexsi/NumVec.hpp"
55 #include "pexsi/NumMat.hpp"
56 #include "pexsi/sparse_matrix.hpp"
57 
59 #include "pexsi/mpi_interf.hpp"
60 #include "pexsi/utility.hpp"
61 #include "pexsi/blas.hpp"
62 #include "pexsi/lapack.hpp"
63 
64 #include "pexsi/TreeBcast.hpp"
65 
66 
67 #include <set>
68 
69 
70 #define IDX_TO_TAG(lidx,tag) (SELINV_TAG_COUNT*(lidx)+(tag))
71 #define IDX_TO_TAG2(sidx,lidx,tag) (SELINV_TAG_COUNT*(sidx)+(tag))
72 #define TAG_TO_IDX(tag,typetag) (((tag)-(typetag))/SELINV_TAG_COUNT)
73 
74 
75 //#define LIST_BARRIER
76 //#define ALL_BARRIER
77 
78 namespace PEXSI{
79 
80  enum MSGTYPE {LSIZE=0,LROWSIZE,USIZE,UCOLSIZE,LCONTENT,LROWCONTENT,UCONTENT,UCOLCONTENT,MSGCOUNT};
81 
82  struct ULComparator {
83  IntNumVec & lookup;
84  ULComparator(IntNumVec & v):lookup(v){}
85  bool operator() (int i,int j) { return ((lookup)(i)<(lookup)(j));}
86  };
87 
88 
89 
90  typedef std::vector<bool> bitMask;
91  typedef std::map<bitMask , std::vector<Int> > bitMaskSet;
92 
93 
94 
95 
96 
107 
108  // Member functions to setup the default value
110  };
111 
112 
113 
114 
115 
116  /**********************************************************************
117  * Basic PSelInv data structure
118  **********************************************************************/
119 
128  struct GridType{
129  // Data
130  MPI_Comm comm;
131  MPI_Comm rowComm;
132  MPI_Comm colComm;
133  Int mpirank;
134  Int mpisize;
135  Int numProcRow;
136  Int numProcCol;
137 
138  // Member function
139  GridType( MPI_Comm Bcomm, int nprow, int npcol );
140  ~GridType();
141  };
142 
166  IntNumVec perm;
167  IntNumVec permInv;
168  IntNumVec perm_r;
169  IntNumVec permInv_r;
170  IntNumVec superIdx;
171  IntNumVec superPtr;
172  IntNumVec etree;
173  };
174 
175 
180  template<typename T>
181  struct LBlock{
182  // Variables
184  Int blockIdx;
185 
187  Int numRow;
188 
190  Int numCol;
191 
194 
195 
198 
199  // Member functions;
200  LBlock() {
201  blockIdx = -1; numRow = 0; numCol =0;
202  nzval.Resize(0,0);
203  }
204  ~LBlock() {}
205  LBlock& operator = (const LBlock& LB) {
206  blockIdx = LB.blockIdx;
207  numRow = LB.numRow;
208  numCol = LB.numCol;
209  rows = LB.rows;
210  nzval = LB.nzval;
211  return *this;
212  }
213  friend std::ostream& operator<<(std::ostream& out, const LBlock& vec) // output
214  {
215  out << "(" << vec.blockIdx << ", " << vec.numRow << ", " << vec.numCol <<std::endl<< "rows " << vec.rows <<std::endl<< "nzval " <<std::endl<< vec.nzval << ")";
216  return out;
217  }
218 
219 
220  };
221 
232  template<typename T>
233  struct UBlock{
234  // Variables
236  Int blockIdx;
237 
239  Int numRow;
240 
242  Int numCol;
243 
246 
249 
250  // Member functions;
251  UBlock() {
252  blockIdx = -1; numRow = 0; numCol =0;
253  }
254  ~UBlock() {}
255  UBlock& operator = (const UBlock& UB) {
256  blockIdx = UB.blockIdx;
257  numRow = UB.numRow;
258  numCol = UB.numCol;
259  cols = UB.cols;
260  nzval = UB.nzval;
261  return *this;
262  }
263 
264  friend std::ostream& operator<<(std::ostream& out, const UBlock& vec) // output
265  {
266  out << "(" << vec.blockIdx << ", " << vec.numRow << ", " << vec.numCol <<std::endl<< "cols " << vec.cols <<std::endl<< "nzval " <<std::endl<< vec.nzval << ")";
267  return out;
268  }
269  };
270 
271  // *********************************************************************
272  // SuperLU style utility functions
273  //
274  // The SuperLU style macros are defined here as inline functions
275  // so that the code is more portable.
276  // *********************************************************************
277 
279  inline Int MYPROC( const GridType* g )
280  { return g->mpirank; }
281 
283  inline Int MYROW( const GridType* g )
284  { return g->mpirank / g->numProcCol; }
285 
287  inline Int MYCOL( const GridType* g )
288  { return g->mpirank % g->numProcCol; }
289 
292  inline Int PROW( Int bnum, const GridType* g )
293  { return bnum % g->numProcRow; }
294 
297  inline Int PCOL( Int bnum, const GridType* g )
298  { return bnum % g->numProcCol; }
299 
302  inline Int PNUM( Int i, Int j, const GridType* g )
303  { return (i%g->numProcRow) * g->numProcCol + j%g->numProcCol; }
304 
307  inline Int LBi( Int bnum, const GridType* g )
308  { return bnum / g->numProcRow; }
309 
312  inline Int LBj( Int bnum, const GridType* g)
313  { return bnum / g->numProcCol; }
314 
317  inline Int GBi( Int iLocal, const GridType* g )
318  { return iLocal * g->numProcRow + MYROW( g ); }
319 
322  inline Int GBj( Int jLocal, const GridType* g )
323  { return jLocal * g->numProcCol + MYCOL( g ); }
324 
327  inline Int CEILING( Int a, Int b )
328  { return (a%b) ? ( a/b + 1 ) : ( a/b ); }
329 
331  inline Int BlockIdx( Int i, const SuperNodeType *s )
332  { return s->superIdx[i]; }
333 
336  inline Int FirstBlockCol( Int bnum, const SuperNodeType *s )
337  { return s->superPtr[bnum]; }
338 
339 
343  inline Int FirstBlockRow( Int bnum, const SuperNodeType *s )
344  { return s->superPtr[bnum]; }
345 
346 
348  inline Int SuperSize( Int bnum, const SuperNodeType *s )
349  { return s->superPtr[bnum+1] - s->superPtr[bnum]; }
350 
352  inline Int NumSuper( const SuperNodeType *s )
353  { return s->superPtr.m() - 1; }
354 
357  inline Int NumCol( const SuperNodeType *s )
358  { return s->superIdx.m(); }
359 
360 
361  // *********************************************************************
362  // Serialize / Deserialize
363  // *********************************************************************
364 
365  // L part
366 
382  namespace LBlockMask{
383  enum {
384  BLOCKIDX,
385  NUMROW,
386  NUMCOL,
387  ROWS,
388  NZVAL,
389  TOTAL_NUMBER
390  };
391  }
392 
393 
394  template<typename T>
395  Int inline serialize(LBlock<T>& val, std::ostream& os, const std::vector<Int>& mask){
396  if(mask[LBlockMask::BLOCKIDX]==1) serialize(val.blockIdx, os, mask);
397  if(mask[LBlockMask::NUMROW ]==1) serialize(val.numRow, os, mask);
398  if(mask[LBlockMask::NUMCOL ]==1) serialize(val.numCol, os, mask);
399  if(mask[LBlockMask::ROWS ]==1) serialize(val.rows, os, mask);
400  if(mask[LBlockMask::NZVAL ]==1) serialize(val.nzval, os, mask);
401  return 0;
402  }
403 
404  template<typename T>
405  Int inline deserialize(LBlock<T>& val, std::istream& is, const std::vector<Int>& mask){
406  if(mask[LBlockMask::BLOCKIDX]==1) deserialize(val.blockIdx, is, mask);
407  if(mask[LBlockMask::NUMROW ]==1) deserialize(val.numRow, is, mask);
408  if(mask[LBlockMask::NUMCOL ]==1) deserialize(val.numCol, is, mask);
409  if(mask[LBlockMask::ROWS ]==1) deserialize(val.rows, is, mask);
410  if(mask[LBlockMask::NZVAL ]==1) deserialize(val.nzval, is, mask);
411  return 0;
412  }
413 
414  // U part
430  namespace UBlockMask{
431  enum {
432  BLOCKIDX,
433  NUMROW,
434  NUMCOL,
435  COLS,
436  NZVAL,
437  TOTAL_NUMBER
438  };
439  }
440 
441  template<typename T>
442  Int inline serialize(UBlock<T>& val, std::ostream& os, const std::vector<Int>& mask){
443  Int i = 0;
444  if(mask[i]==1) serialize(val.blockIdx, os, mask); i++;
445  if(mask[i]==1) serialize(val.numRow, os, mask); i++;
446  if(mask[i]==1) serialize(val.numCol, os, mask); i++;
447  if(mask[i]==1) serialize(val.cols, os, mask); i++;
448  if(mask[i]==1) serialize(val.nzval, os, mask); i++;
449  return 0;
450  }
451 
452  template<typename T>
453  Int inline deserialize(UBlock<T>& val, std::istream& is, const std::vector<Int>& mask){
454  Int i = 0;
455  if(mask[i]==1) deserialize(val.blockIdx, is, mask); i++;
456  if(mask[i]==1) deserialize(val.numRow, is, mask); i++;
457  if(mask[i]==1) deserialize(val.numCol, is, mask); i++;
458  if(mask[i]==1) deserialize(val.cols, is, mask); i++;
459  if(mask[i]==1) deserialize(val.nzval, is, mask); i++;
460  return 0;
461  }
462 
463  /**********************************************************************
464  * Main data structure in PSelInv: PMatrix
465  **********************************************************************/
466 
528 
529  template<typename T>
530  class PMatrix{
531  public:
534 
535  static PMatrix<T> * Create(const GridType * pGridType, const SuperNodeType * pSuper, const PSelInvOptions * pSelInvOpt , const SuperLUOptions * pLuOpt);
536  static PMatrix<T> * Create(const SuperLUOptions * pLuOpt);
537 
538  public:
539  // This is the tag used for mpi communication for selinv
540 
541  enum{
542  SELINV_TAG_U_SIZE,
543  SELINV_TAG_U_CONTENT,
544  SELINV_TAG_L_SIZE,
545  SELINV_TAG_L_CONTENT,
546  SELINV_TAG_L_REDUCE,
547  SELINV_TAG_D_SIZE,
548  SELINV_TAG_D_CONTENT,
549  SELINV_TAG_D_REDUCE,
550  SELINV_TAG_L_SIZE_CD,
551  SELINV_TAG_L_CONTENT_CD,
552  SELINV_TAG_COUNT
553  };
554 
555 
556  protected:
557  // *********************************************************************
558  // Variables
559  // *********************************************************************
560  // Data variables
561 
562  const GridType* grid_;
563 
564  const SuperNodeType* super_;
565 
566  const PSelInvOptions * options_;
567  const SuperLUOptions * optionsLU_;
568 
569 
570 
571  std::vector<std::vector<Int> > ColBlockIdx_;
572  std::vector<std::vector<Int> > RowBlockIdx_;
573  std::vector<std::vector<LBlock<T> > > L_;
574  std::vector<std::vector<UBlock<T> > > U_;
575 
576  std::vector<std::vector<Int> > workingSet_;
577 
578 
579  // Communication variables
580  BolNumMat isSendToBelow_;
581  BolNumMat isSendToRight_;
582  BolNumVec isSendToDiagonal_;
583  BolNumMat isSendToCrossDiagonal_;
584 
585  BolNumMat isRecvFromBelow_;
586  BolNumVec isRecvFromAbove_;
587  BolNumVec isRecvFromLeft_;
588  BolNumMat isRecvFromCrossDiagonal_;
589 
590 
591  std::vector<TreeBcast *> fwdToBelowTree_;
592  std::vector<TreeBcast *> fwdToRightTree_;
593  std::vector<TreeReduce<T> *> redToLeftTree_;
594  std::vector<TreeReduce<T> *> redToAboveTree_;
595 
596 
597 
599  NumMat<T> LUpdateBuf;
600  NumMat<T> DiagBuf;
601  std::vector<Int> RowLocalPtr;
602  std::vector<Int> BlockIdxLocal;
603  std::vector<char> SstrLcolSend;
604  std::vector<char> SstrUrowSend;
605  std::vector<char> SstrLcolRecv;
606  std::vector<char> SstrUrowRecv;
607  Int SizeSstrLcolSend;
608  Int SizeSstrUrowSend;
609  Int SizeSstrLcolRecv;
610  Int SizeSstrUrowRecv;
611  Int Index;
612  Int isReady;
613 
614 
616  SizeSstrLcolSend(0),
617  SizeSstrUrowSend(0),
618  SizeSstrLcolRecv(0),
619  SizeSstrUrowRecv(0),
620  Index(0),
621  isReady(0){}
622 
623  SuperNodeBufferType(Int &pIndex) :
624  SizeSstrLcolSend(0),
625  SizeSstrUrowSend(0),
626  SizeSstrLcolRecv(0),
627  SizeSstrUrowRecv(0),
628  Index(pIndex),
629  isReady(0) {}
630 
631  };
632 
633 
635  inline void SelInvIntra_P2p(Int lidx);
636 
638  inline void SelInv_lookup_indexes(SuperNodeBufferType & snode, std::vector<LBlock<T> > & LcolRecv, std::vector<UBlock<T> > & UrowRecv, NumMat<T> & AinvBuf,NumMat<T> & UBuf);
639 
641  inline void GetWorkSet(std::vector<Int> & snodeEtree, std::vector<std::vector<Int> > & WSet);
642 
644  inline void UnpackData(SuperNodeBufferType & snode, std::vector<LBlock<T> > & LcolRecv, std::vector<UBlock<T> > & UrowRecv);
645 
647  inline void ComputeDiagUpdate(SuperNodeBufferType & snode);
648 
650  inline void SendRecvCD_UpdateU(std::vector<SuperNodeBufferType > & arrSuperNodes, Int stepSuper);
651 
652  public:
653  // *********************************************************************
654  // Public member functions
655  // *********************************************************************
656 
657  PMatrix() {}
658 
659  PMatrix( const GridType* g, const SuperNodeType* s, const PEXSI::PSelInvOptions * o, const PEXSI::SuperLUOptions * oLU );
660 
661  void deallocate();
662 
663 
664  virtual ~PMatrix();
665  PMatrix( const PMatrix & C);
666  PMatrix & operator = ( const PMatrix & C);
667 
668  void Setup( const GridType* g, const SuperNodeType* s, const PEXSI::PSelInvOptions * o, const PEXSI::SuperLUOptions * oLU );
669 
670  Int NumCol() const { return super_ -> superIdx.m(); }
671 
672  Int NumSuper() const { return super_ ->superPtr.m() - 1; }
673 
675  Int NumLocalBlockCol() const { return CEILING( this->NumSuper(), grid_->numProcCol ); }
676 
678  Int NumLocalBlockRow() const { return CEILING( this->NumSuper(), grid_->numProcRow); }
679 
680 
681  std::vector< std::vector<Int> > & ColBlockIdx() { return ColBlockIdx_; }
682  std::vector< std::vector<Int> > & RowBlockIdx() { return RowBlockIdx_; }
683  std::vector<Int> & ColBlockIdx(Int jLocal) { return ColBlockIdx_[jLocal]; }
684  std::vector<Int> & RowBlockIdx(Int iLocal) { return RowBlockIdx_[iLocal]; }
685 
686 
689  Int NumBlockL( Int jLocal ) const { return L_[jLocal].size(); }
690 
693  Int NumBlockU( Int iLocal ) const { return U_[iLocal].size(); }
694 
696  const GridType* Grid() const { return grid_; }
697 
700  const SuperNodeType* SuperNode() const { return super_; }
701 
704  std::vector<LBlock<T> >& L( Int jLocal ) { return L_[jLocal]; }
705 
708  std::vector<UBlock<T> >& U( Int iLocal ) { return U_[iLocal]; }
709 
712  std::vector<std::vector<int> >& WorkingSet( ) { return workingSet_; }
713 
716  Int CountSendToRight(Int ksup) { Int count= std::count (isSendToRight_.VecData(ksup), isSendToRight_.VecData(ksup) + grid_->numProcCol, true); return (isSendToRight_(MYCOL(grid_),ksup)?count-1:count); }
717 
720  Int CountSendToBelow(Int ksup) { Int count= std::count (isSendToBelow_.VecData(ksup), isSendToBelow_.VecData(ksup) + grid_->numProcRow, true); return (isSendToBelow_(MYROW(grid_),ksup)?count-1:count); }
721 
724  Int CountRecvFromBelow(Int ksup) { Int count= std::count (isRecvFromBelow_.VecData(ksup), isRecvFromBelow_.VecData(ksup) + grid_->numProcRow, true); return (isRecvFromBelow_(MYROW(grid_),ksup)?count-1:count); }
725 
728  Int CountSendToCrossDiagonal(Int ksup) { Int count= std::count (isSendToCrossDiagonal_.VecData(ksup), isSendToCrossDiagonal_.VecData(ksup) + grid_->numProcCol, true); return ((isSendToCrossDiagonal_(MYCOL(grid_),ksup) && MYROW(grid_)==PROW(ksup,grid_))?count-1:count); }
729 
732  Int CountRecvFromCrossDiagonal(Int ksup) { Int count= std::count (isRecvFromCrossDiagonal_.VecData(ksup), isRecvFromCrossDiagonal_.VecData(ksup) + grid_->numProcRow, true); return ((isRecvFromCrossDiagonal_(MYROW(grid_),ksup) && MYCOL(grid_)==PCOL(ksup,grid_))?count-1:count); }
733 
734 
735 
736 
739  void GetEtree(std::vector<Int> & etree_supno );
740 
741 
746  virtual void ConstructCommunicationPattern( );
747 
748 
753 
754 
755 
784  virtual void PreSelInv( );
785 
910  virtual void SelInv( );
911 
913  void SelInv_P2p( );
914 
915 
922  void GetDiagonal( NumVec<T>& diag );
923  void GetColumn ( Int colIdx, NumVec<T>& col );
924 
925 
932 
943  const DistSparseMatrix<T>& A,
944  DistSparseMatrix<T>& B );
945 
946 
957  const DistSparseMatrix<T>& A,
958  DistSparseMatrix<T>& B );
959 
960 
963  Int NnzLocal();
964 
967  LongInt Nnz();
968 
972  void GetNegativeInertia ( Real& inertia );
973 
974  inline int IdxToTag(Int lidx, Int tag) { return SELINV_TAG_COUNT*(lidx)+(tag);}
975 
976  };
977 
978  template<typename T> class PMatrixUnsym;
979 
980 
981 } // namespace PEXSI
982 
983 
984 #include "pexsi/pselinv_impl.hpp"
985 
986 
987 #endif //_PEXSI_PSELINV_HPP_
virtual void PreSelInv()
PreSelInv prepares the structure in L_ and U_ so that SelInv only involves matrix-matrix multiplicati...
Definition: pselinv_impl.hpp:2677
Environmental variables.
Int blockIdx
Block index (supernodal index)
Definition: pselinv.hpp:236
void PMatrixToDistSparseMatrix(DistSparseMatrix< T > &A)
PMatrixToDistSparseMatrix converts the PMatrix into a distributed compressed sparse column matrix for...
Definition: pselinv_impl.hpp:3208
void SelInvIntra_P2p(Int lidx)
SelInvIntra_P2p.
Definition: pselinv_impl.hpp:1211
A thin interface for passing parameters to set the SuperLU options.
Definition: superlu_dist_internal.hpp:62
std::vector< LBlock< T > > & L(Int jLocal)
L returns the vector of nonzero L blocks for the local block column jLocal.
Definition: pselinv.hpp:704
SuperNodeType describes mapping between supernode and column, the permutation information, and potentially the elimination tree (not implemented here).
Definition: pselinv.hpp:165
static PMatrix< T > * Create(const GridType *pGridType, const SuperNodeType *pSuper, const PSelInvOptions *pSelInvOpt, const SuperLUOptions *pLuOpt)
Create is a factory method which returns a pointer either to a new PMatrix or to a new PMatrixUnsym d...
Definition: pselinv_impl.hpp:4248
Interface with SuperLU_Dist (version 3.0 and later)
void GetNegativeInertia(Real &inertia)
GetNegativeInertia computes the negative inertia of a PMatrix. This can be used to estimate e...
Int PROW(Int bnum, const GridType *g)
PROW returns the processor row that the bnum-th block (supernode) belongs to.
Definition: pselinv.hpp:292
Thin interface to LAPACK.
Int numRow
Number of nonzero rows.
Definition: pselinv.hpp:187
void UnpackData(SuperNodeBufferType &snode, std::vector< LBlock< T > > &LcolRecv, std::vector< UBlock< T > > &UrowRecv)
UnpackData.
Definition: pselinv_impl.hpp:971
Int maxPipelineDepth
The maximum pipeline depth.
Definition: pselinv.hpp:106
Int MYPROC(const GridType *g)
MYPROC returns the current processor rank.
Definition: pselinv.hpp:279
Int NumLocalBlockCol() const
NumLocalBlockCol returns the total number of block columns.
Definition: pselinv.hpp:675
Int PCOL(Int bnum, const GridType *g)
PCOL returns the processor column that the bnum-th block (supernode) belongs to.
Definition: pselinv.hpp:297
Int LBi(Int bnum, const GridType *g)
LBi returns the local block number on the processor at processor row PROW( bnum, g )...
Definition: pselinv.hpp:307
Int SuperSize(Int bnum, const SuperNodeType *s)
SuperSize returns the size of the block bnum.
Definition: pselinv.hpp:348
Int LBj(Int bnum, const GridType *g)
LBj returns the local block number on the processor at processor column PCOL( bnum, g ).
Definition: pselinv.hpp:312
Int GBj(Int jLocal, const GridType *g)
GBj returns the global block number from a local block number in the column direction.
Definition: pselinv.hpp:322
Int numCol
Number of nonzero columns.
Definition: pselinv.hpp:190
Int NumCol(const SuperNodeType *s)
NumCol returns the total number of columns for a supernodal partiiton.
Definition: pselinv.hpp:357
Definition: pselinv.hpp:598
Int CountRecvFromCrossDiagonal(Int ksup)
CountRecvFromCrossDiagonal returns the number of cross diagonal processors with which current process...
Definition: pselinv.hpp:732
void GetDiagonal(NumVec< T > &diag)
GetDiagonal extracts the diagonal elements of the PMatrix.
Definition: pselinv_impl.hpp:3080
std::vector< std::vector< int > > & WorkingSet()
WorkingSet returns the ordered list of supernodes which could be done in parallel.
Definition: pselinv.hpp:712
Implementation of the parallel SelInv.
void GetWorkSet(std::vector< Int > &snodeEtree, std::vector< std::vector< Int > > &WSet)
GetWorkSet.
Definition: pselinv_impl.hpp:1134
Int FirstBlockRow(Int bnum, const SuperNodeType *s)
FirstBlockRow returns the first column of a block bnum. Note: the functionality of FirstBlockRow is e...
Definition: pselinv.hpp:343
Definition: pselinv.hpp:82
void GetEtree(std::vector< Int > &etree_supno)
GetEtree computes the supernodal elimination tree to be used later in the pipelined selected inversio...
Definition: pselinv_impl.hpp:1065
const GridType * Grid() const
Grid returns the GridType structure of the current PMatrix.
Definition: pselinv.hpp:696
LBlock stores a nonzero block in the lower triangular part or the diagonal part in PSelInv...
Definition: pselinv.hpp:181
Int PNUM(Int i, Int j, const GridType *g)
PNUM returns the processor rank that the bnum-th block (supernode) belongs to.
Definition: pselinv.hpp:302
virtual void ConstructCommunicationPattern()
ConstructCommunicationPattern constructs the communication pattern to be used later in the selected i...
Definition: pselinv_impl.hpp:1951
Sparse matrix and Distributed sparse matrix in compressed column format.
void ConstructCommunicationPattern_P2p()
ConstructCommunicationPattern_P2p constructs the communication pattern to be used later in the select...
Definition: pselinv_impl.hpp:1959
Int GBi(Int iLocal, const GridType *g)
GBi returns the global block number from a local block number in the row direction.
Definition: pselinv.hpp:317
GridType is the PSelInv way of defining the grid.
Definition: pselinv.hpp:128
Numerical matrix.
Interface with MPI to facilitate communication.
Int MYCOL(const GridType *g)
MYCOL returns my processor column.
Definition: pselinv.hpp:287
Int CountSendToCrossDiagonal(Int ksup)
CountSendToCrossDiagonal returns the number of cross diagonal processors with which current processor...
Definition: pselinv.hpp:728
Int NumLocalBlockRow() const
NumLocalBlockRow returns the total number of block rows.
Definition: pselinv.hpp:678
Various utility subroutines.
const SuperNodeType * SuperNode() const
SuperNode returns the supernodal partition of the current PMatrix.
Definition: pselinv.hpp:700
void PMatrixToDistSparseMatrix_OLD(const DistSparseMatrix< T > &A, DistSparseMatrix< T > &B)
PMatrixToDistSparseMatrix_OLD converts the PMatrix into a distributed compressed sparse column matrix...
Definition: pselinv_impl.hpp:3489
IntNumVec rows
Dimension numRow * 1, index (0-based) for the number of nonzero rows.
Definition: pselinv.hpp:193
Int numCol
Number of nonzero columns.
Definition: pselinv.hpp:242
UBlock stores a nonzero block in the upper triangular part in PSelInv.
Definition: pselinv.hpp:233
std::vector< UBlock< T > > & U(Int iLocal)
U returns the vector of nonzero U blocks for the local block row iLocal.
Definition: pselinv.hpp:708
Int FirstBlockCol(Int bnum, const SuperNodeType *s)
FirstBlockCol returns the first column of a block bnum.
Definition: pselinv.hpp:336
Int NnzLocal()
NnzLocal computes the number of nonzero elements (L and U) saved locally.
Definition: pselinv_impl.hpp:4132
Int blockIdx
Block index (supernodal index)
Definition: pselinv.hpp:184
Thin interface to BLAS.
PMatrix contains the main data structure and the computational routine for the parallel selected inve...
Definition: ngchol_interf.hpp:57
void SendRecvCD_UpdateU(std::vector< SuperNodeBufferType > &arrSuperNodes, Int stepSuper)
SendRecvCD_UpdateU.
Definition: pselinv_impl.hpp:748
Int BlockIdx(Int i, const SuperNodeType *s)
BlockIdx returns the block index of a column i.
Definition: pselinv.hpp:331
Int numRow
Number of nonzero rows.
Definition: pselinv.hpp:239
Int CountSendToRight(Int ksup)
CountSendToRight returns the number of processors to the right of current processor with which it has...
Definition: pselinv.hpp:716
Int CountSendToBelow(Int ksup)
CountSendToBelow returns the number of processors below current processor with which it has to commun...
Definition: pselinv.hpp:720
Int CEILING(Int a, Int b)
CEILING is used for computing the storage space for local number of blocks.
Definition: pselinv.hpp:327
NumMat< T > nzval
Dimension numRow * numCol, nonzero elements.
Definition: pselinv.hpp:248
Int NumSuper(const SuperNodeType *s)
NumSuper returns the total number of supernodes.
Definition: pselinv.hpp:352
Numerical vector.
void SelInv_P2p()
Point-to-point version of the selected inversion.
Definition: pselinv_impl.hpp:2642
Int CountRecvFromBelow(Int ksup)
CountRecvFromBelow returns the number of processors below the current processor from which it receive...
Definition: pselinv.hpp:724
Int NumBlockL(Int jLocal) const
NumBlockL returns the number of nonzero L blocks for the local block column jLocal.
Definition: pselinv.hpp:689
NumMat< T > nzval
Dimension numRow * numCol, nonzero elements.
Definition: pselinv.hpp:197
A thin interface for passing parameters to set the PSelInv options.
Definition: pselinv.hpp:101
IntNumVec cols
Dimension numRow * 1, index (0-based) for the number of nonzero rows.
Definition: pselinv.hpp:245
Int NumBlockU(Int iLocal) const
NumBlockU returns the number of nonzero U blocks for the local block row iLocal.
Definition: pselinv.hpp:693
virtual void SelInv()
SelInv is the main function for the selected inversion.
Definition: pselinv_impl.hpp:2617
LongInt Nnz()
Nnz computes the total number of nonzero elements in the PMatrix.
Definition: pselinv_impl.hpp:4163
void SelInv_lookup_indexes(SuperNodeBufferType &snode, std::vector< LBlock< T > > &LcolRecv, std::vector< UBlock< T > > &UrowRecv, NumMat< T > &AinvBuf, NumMat< T > &UBuf)
SelInv_lookup_indexes.
Definition: pselinv_impl.hpp:391
void ComputeDiagUpdate(SuperNodeBufferType &snode)
ComputeDiagUpdate.
Definition: pselinv_impl.hpp:1025
DistSparseMatrix describes a Sparse matrix in the compressed sparse column format (CSC) and distribut...
Definition: sparse_matrix.hpp:91
PMatrixUnsym contains the main data structure and the computational routine for the parallel selected...
Definition: pselinv.hpp:978
Int MYROW(const GridType *g)
MYROW returns my processor row.
Definition: pselinv.hpp:283