/*! \file fortranAPI.cpp
\brief Fortran style interface named as Dissecotion-fortran interface
\author Atsushi Suzuki, Laboratoire Jacques-Louis Lions
\date Mar. 30th 2012
\date Jul. 12th 2015
\date Nov. 30th 2016
*/
// This file is part of Dissection
//
// Dissection is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// Linking Dissection statically or dynamically with other modules is making
// a combined work based on Disssection. Thus, the terms and conditions of
// the GNU General Public License cover the whole combination.
//
// As a special exception, the copyright holders of Dissection give you
// permission to combine Dissection program with free software programs or
// libraries that are released under the GNU LGPL and with independent modules
// that communicate with Dissection solely through the Dissection-fortran
// interface. You may copy and distribute such a system following the terms of
// the GNU GPL for Dissection and the licenses of the other code concerned,
// provided that you include the source code of that other code when and as
// the GNU GPL requires distribution of source code and provided that you do
// not modify the Dissection-fortran interface.
//
// Note that people who make modified versions of Dissection are not obligated
// to grant this special exception for their modified versions; it is their
// choice whether to do so. The GNU General Public License gives permission to
// release a modified version without this exception; this exception also makes
// it possible to release a modified version which carries forward this
// exception. If you modify the Dissection-fortran interface, this exception
// does not apply to your modified version of Dissection, and you must remove
// this exception when you distribute your modified version.
//
// This exception is an additional permission under section 7 of the GNU
// General Public License, version 3 ("GPLv3")
//
// Dissection is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with Dissection. If not, see .
//
#include
#include
#include
#include
#ifdef DISSECTION_FORTRAN
#include "Interfaces/fortranAPI.h"
#else
#include "Interfaces/Dissection.hpp"
#endif
#include "Driver/DissectionSolver.hpp"
struct dissection_solver_ptr
{
int real_or_complex;
DissectionSolver *rptr;
DissectionSolver, double> *cptr;
DissectionSolver *rqtr;
DissectionSolver *rqtr_fwbw;
DissectionSolver, quadruple> *cqtr;
DissectionSolver, double,
complex, quadruple> *cqtr_fwbw;
FILE *fp;
bool verbose;
int called;
#ifdef BLAS_MKL
int mkl_num_threads;
#endif
int symbolic;
int numeric;
};
DISSECTION_API void DISS_VERSION(int *versn,
int *reles,
int *patch)
{
*versn = DISSECTION_VERSION;
*reles = DISSECTION_RELEASE;
*patch = DISSECTION_PATCHLEVEL;
}
DISSECTION_API void DISS_INIT(uint64_t &dslv_,
const int &called,
const int &real_or_complex,
const int &nthreads,
const int &verbose)
{
int num_threads;
dissection_solver_ptr *dslv;
dslv_ = (uint64_t)new dissection_solver_ptr;
dslv = (dissection_solver_ptr *)dslv_;
dslv->real_or_complex = real_or_complex;
dslv->called = called;
dslv->symbolic = 0;
dslv->numeric = 0;
{
int pid = (int)getpid();
char fname[256];
if (verbose > 0) {
dslv->verbose = true;
}
else {
dslv->verbose = false;
}
#if 1
if (dslv->verbose) {
fprintf(stderr, "pid = %d\n", pid);
sprintf(fname, "dissection.%04d.%04d.log", pid, called);
dslv->fp = fopen(fname, "a");
}
else {
dslv->fp = stderr;
}
#else
dslv->fp = stderr;
#endif
}
if (dslv->verbose) {
fprintf(dslv->fp, "%s %d : diss_init : called = %d\n",
__FILE__, __LINE__, dslv->called);
}
// _called++; // counter for dumping matrix data to debug
#ifdef BLAS_MKL
if (getenv("MKL_NUM_THREADS")) {
sscanf(getenv("MKL_NUM_THREADS"), "%d", &dslv->mkl_num_threads);
if (dslv->verbose > 0) {
fprintf(dslv->fp,
"environmental variable MKL_NUM_THREADS = %d\n",
dslv->mkl_num_threads);
}
}
else {
dslv->mkl_num_threads = mkl_get_max_threads();
}
if (dslv->verbose) {
fprintf(dslv->fp,
"MKL_NUM_THREADS = %d\n", dslv->mkl_num_threads);
}
#endif
if (nthreads == (-1)) {
if (getenv("NTHREADS")) {
sscanf(getenv("NTHREADS"), "%d", &num_threads);
}
else {
num_threads = 1;
}
}
if (nthreads > 0) {
num_threads = nthreads;
}
{
switch(real_or_complex) {
case DISSECTION_REAL_MATRIX:
dslv->rptr = new DissectionSolver(num_threads,
(verbose != 0 ? true : false),
dslv->called, dslv->fp);
break;
case DISSECTION_COMPLEX_MATRIX:
dslv->cptr = new DissectionSolver,
double>(num_threads,
(verbose != 0 ? true : false),
dslv->called, dslv->fp);
break;
default:
if (dslv->verbose) {
fprintf(dslv->fp, "%s %d : unknown matrix data type : %d\n",
__FILE__, __LINE__, dslv->real_or_complex);
}
}
}
}
DISSECTION_API void DISS_FREE(uint64_t &dslv_)
{
dissection_solver_ptr *dslv = (dissection_solver_ptr *)dslv_;
switch(dslv->real_or_complex) {
case DISSECTION_REAL_MATRIX:
delete dslv->rptr;
break;
case DISSECTION_COMPLEX_MATRIX:
delete dslv->cptr;
break;
default:
if (dslv->verbose) {
fprintf(dslv->fp, "%s %d : unknown matrix data type : %d\n",
__FILE__, __LINE__, dslv->real_or_complex);
}
}
delete dslv;
dslv_ = (uint64_t)NULL;
// _called--;
// if ((_called == 0) && (dslv->fp != stderr)) {
if (dslv->fp != stderr) {
fclose(dslv->fp);
}
#ifdef VECLIB
unsetenv("VECLIB_MAXIMUM_THREADS");
#endif
}
DISSECTION_API void DISS_NUMERIC_FREE(uint64_t &dslv_)
{
dissection_solver_ptr *dslv = (dissection_solver_ptr *)dslv_;
switch(dslv->real_or_complex) {
case DISSECTION_REAL_MATRIX:
dslv->rptr->NumericFree();
break;
case DISSECTION_COMPLEX_MATRIX:
dslv->cptr->NumericFree();
break;
default:
if (dslv->verbose) {
fprintf(dslv->fp, "%s %d unknown matrix data type : %d\n",
__FILE__, __LINE__, dslv->real_or_complex);
}
}
}
DISSECTION_API void DISS_S_FACT(uint64_t &dslv_,
const int &dim,
const int *ptRows,
const int *indCols,
const int &sym,
const int &decomposer)
{
// sym = 1 : symmetric with upper
// = 0 : unsymmetric,
// = 3 : symmetric with lower
// decomposer = 0 : SCOTCH
// = 1 : METIS
// = 2 : TRIDAIG without nested bisection
dissection_solver_ptr *dslv = (dissection_solver_ptr *)dslv_;
// int num_levels;
switch(dslv->real_or_complex) {
case DISSECTION_REAL_MATRIX:
dslv->rptr->SymbolicFact(dim, (int *)ptRows, (int *)indCols,
(bool)(sym % 2 == 1), (bool)((sym / 2) == 0),
(bool)((sym / 4) == 1),
decomposer); // using default parameter
break;
case DISSECTION_COMPLEX_MATRIX:
dslv->cptr->SymbolicFact(dim, (int *)ptRows, (int *)indCols,
(bool)(sym % 2 == 1), (bool)((sym / 2) == 0),
(bool)((sym / 4) == 1),
decomposer); // using default parameter
break;
default:
if (dslv->verbose) {
fprintf(dslv->fp, "%s %d unknown matrix data type : %d\n",
__FILE__, __LINE__, dslv->real_or_complex);
}
}
if (dslv->verbose) {
fprintf(dslv->fp, "%s:%d Dissection::SymbolicFact done\n",
__FILE__, __LINE__);
}
dslv->symbolic++;
}
DISSECTION_API void DISS_N_FACT(uint64_t &dslv_,
const double *coefs,
const int &scaling,
const double &eps_pivot,
const int &indefinite_flag)
{
// scaling = 0 : without scaling
// 1 : 1/sqrt(a_ii) or 1/sqrt(max|a_ij|)
// 2 : 1/sqrt(a_ii) or Schur complement corresponding to diagonal
// kernel_detection_all (for KKT type)
// eps_pivot = 1.0e-2 : threshold of pivot, ratio of contiguous diagonal
// entries with absolute value
// indefinite_flag = 1 : indefinite -> kernel_detection_all = false
// indefinite_flag = 0 : semi-definite -> kernel_detection_all = true
bool kernel_detection_all = indefinite_flag == 0 ? true : false;
// FILE *fout;
dissection_solver_ptr *dslv = (dissection_solver_ptr *)dslv_;
#ifdef BLAS_MKL
mkl_set_num_threads(1);
#endif
#ifdef VECLIB
setenv("VECLIB_MAXIMUM_THREADS", "1", true);
#endif
// dslv->NumericFree(); // for debugging : 20 Nov.2013
switch(dslv->real_or_complex) {
case DISSECTION_REAL_MATRIX:
dslv->rptr->NumericFact(dslv->numeric,
(double *)coefs, scaling,
eps_pivot,
kernel_detection_all);
if (dslv->rptr->getFactorized() == false) {
dslv->rptr->SaveMMMatrix(dslv->called, coefs);
}
break;
case DISSECTION_COMPLEX_MATRIX:
dslv->cptr->NumericFact(dslv->numeric,
(complex *)coefs, scaling,
eps_pivot,
kernel_detection_all);
break;
}
#ifdef BLAS_MKL
mkl_set_num_threads(dslv->mkl_num_threads);
#endif
if (dslv->verbose) {
fprintf(dslv->fp,
"%s %d : Dissection::NumericFact done : %d\n",
__FILE__, __LINE__, dslv->numeric);
}
dslv->numeric++;
}
DISSECTION_API void DISS_GET_COLORS(uint64_t &dslv_,
int *n)
{
dissection_solver_ptr *dslv = (dissection_solver_ptr *)dslv_;
switch(dslv->real_or_complex) {
case DISSECTION_REAL_MATRIX:
*n = dslv->rptr->GetMaxColors();
break;
case DISSECTION_COMPLEX_MATRIX:
*n = dslv->cptr->GetMaxColors();
break;
default:
if (dslv->verbose) {
fprintf(dslv->fp, "%s %d unknown matrix data type : %d\n",
__FILE__, __LINE__, dslv->real_or_complex);
}
}
}
DISSECTION_API void DISS_GET_KERN_DIM(uint64_t &dslv_,
int *n0)
{
dissection_solver_ptr *dslv = (dissection_solver_ptr *)dslv_;
switch(dslv->real_or_complex) {
case DISSECTION_REAL_MATRIX:
*n0 = dslv->rptr->kern_dimension();
break;
case DISSECTION_COMPLEX_MATRIX:
if (dslv->verbose) {
fprintf(dslv->fp,
"%s %d diss_get_kern_dim() for complex is not yet implemented\n",
__FILE__, __LINE__);
}
*n0 = 0;
break;
default:
if (dslv->verbose) {
fprintf(dslv->fp, "%s %d unknown matrix data type : %d\n",
__FILE__, __LINE__, dslv->real_or_complex);
}
}
}
DISSECTION_API void DISS_GET_NULLPIVOTS(uint64_t &dslv_,
int *pivots)
{
dissection_solver_ptr *dslv = (dissection_solver_ptr *)dslv_;
switch(dslv->real_or_complex) {
case DISSECTION_REAL_MATRIX:
dslv->rptr->GetNullPivotIndices(pivots);
break;
case DISSECTION_COMPLEX_MATRIX:
dslv->cptr->GetNullPivotIndices(pivots);
break;
default:
if (dslv->verbose) {
fprintf(dslv->fp, "%s %d unknown matrix data type : %d\n",
__FILE__, __LINE__, dslv->real_or_complex);
}
}
}
DISSECTION_API void DISS_GET_SMALLPIVOTS(uint64_t &dslv_,
const int &n,
int *pivots)
{
dissection_solver_ptr *dslv = (dissection_solver_ptr *)dslv_;
switch(dslv->real_or_complex) {
case DISSECTION_REAL_MATRIX:
dslv->rptr->GetSmallestPivotIndices(n, pivots);
break;
case DISSECTION_COMPLEX_MATRIX:
dslv->cptr->GetSmallestPivotIndices(n, pivots);
break;
default:
if (dslv->verbose) {
fprintf(dslv->fp, "%s %d unknown matrix data type : %d\n",
__FILE__, __LINE__, dslv->real_or_complex);
}
}
}
DISSECTION_API void DISS_GET_KERN_VECS(uint64_t &dslv_,
double *vec)
{
dissection_solver_ptr *dslv = (dissection_solver_ptr *)dslv_;
switch(dslv->real_or_complex) {
case DISSECTION_REAL_MATRIX:
dslv->rptr->GetKernelVectors(vec);
break;
case DISSECTION_COMPLEX_MATRIX:
if (dslv->verbose) {
fprintf(dslv->fp,
"%s %d diss_get_kern_vecs() for complex is not yet implemented\n",
__FILE__, __LINE__);
}
break;
default:
if (dslv->verbose) {
fprintf(dslv->fp, "%s %d unknown matrix data type : %d\n",
__FILE__, __LINE__, dslv->real_or_complex);
}
}
}
DISSECTION_API void DISS_GET_KERNT_VECS(uint64_t &dslv_,
double *vec)
{
dissection_solver_ptr *dslv = (dissection_solver_ptr *)dslv_;
switch(dslv->real_or_complex) {
case DISSECTION_REAL_MATRIX:
dslv->rptr->GetTransKernelVectors(vec);
break;
case DISSECTION_COMPLEX_MATRIX:
if (dslv->verbose) {
fprintf(dslv->fp,
"%s %d diss_get_kern_vecs() for complex is not yet implemented\n",
__FILE__, __LINE__);
}
break;
default:
if (dslv->verbose) {
fprintf(dslv->fp, "%s %d unknown matrix data type : %d\n",
__FILE__, __LINE__, dslv->real_or_complex);
}
}
}
DISSECTION_API void DISS_PROJECT(uint64_t &dslv_,
double *x)
{
dissection_solver_ptr *dslv = (dissection_solver_ptr *)dslv_;
int n0;
switch(dslv->real_or_complex) {
case DISSECTION_REAL_MATRIX:
n0 = dslv->rptr->kern_dimension();
if (n0 > 0) {
dslv->rptr->ProjectionImageSingle(x);
}
break;
case DISSECTION_COMPLEX_MATRIX:
if (dslv->verbose) {
fprintf(dslv->fp,
"%s %d diss_project() for complex is not yet implemented\n",
__FILE__, __LINE__);
}
break;
default:
if (dslv->verbose) {
fprintf(dslv->fp, "%s %d unknown matrix data type : %d\n",
__FILE__, __LINE__, dslv->real_or_complex);
}
}
}
DISSECTION_API void DISS_SOLVE_1(uint64_t &dslv_,
double *x,
const int &projection,
const int &trans)
{
const bool isProj = (bool)(projection == 1);
const bool isTrans = (bool)(trans == 1);
dissection_solver_ptr *dslv = (dissection_solver_ptr *)dslv_;
switch(dslv->real_or_complex) {
case DISSECTION_REAL_MATRIX:
dslv->rptr->SolveSingle(x, isProj, isTrans, true);
break;
case DISSECTION_COMPLEX_MATRIX:
fprintf(dslv->cptr->get_filedescriptor(),
"Dissection::SolveSingle : %p\n", dslv->cptr);
dslv->cptr->SolveSingle((complex *)x, isProj, isTrans, true);
// isTrans
break;
default:
if (dslv->verbose) {
fprintf(dslv->fp, "%s %d unknown matrix data type : %d\n",
__FILE__, __LINE__, dslv->real_or_complex);
}
}
}
DISSECTION_API void DISS_SOLVE_N(uint64_t &dslv_,
double *x,
const int &nrhs, const int &projection,
const int &trans)
{
const bool isProj = (bool)(projection == 1);
const bool isTrans = (bool)(trans == 1);
dissection_solver_ptr *dslv = (dissection_solver_ptr *)dslv_;
switch(dslv->real_or_complex) {
case DISSECTION_REAL_MATRIX:
dslv->rptr->SolveMulti(x, nrhs, isProj, isTrans, true);
break;
case DISSECTION_COMPLEX_MATRIX:
dslv->cptr->SolveMulti((complex *)x, nrhs, isProj, isTrans, true);
break;
default:
if (dslv->verbose) {
fprintf(dslv->fp, "%s %d unknown matrix data type : %d\n",
__FILE__, __LINE__, dslv->real_or_complex);
}
}
}
DISSECTION_API void DISS_MATRIX_PRODUCT(uint64_t &dslv_,
const double* x, double* y)
{
dissection_solver_ptr *dslv = (dissection_solver_ptr *)dslv_;
switch(dslv->real_or_complex) {
case DISSECTION_REAL_MATRIX:
dslv->rptr->SpMV(x, y);
break;
case DISSECTION_COMPLEX_MATRIX:
dslv->cptr->SpMV((complex *)x, (complex *)y);
break;
default:
if (dslv->verbose) {
fprintf(dslv->fp, "%s %d unknown matrix data type : %d\n",
__FILE__, __LINE__, dslv->real_or_complex);
}
}
}