/********************************
* Interface to create a domain *
********************************/
ALGEB lbCreateDomain (MKernelVector kv, ALGEB *argv){
M_INT argc = MapleNumArgs(kv, (ALGEB) argv);
const DomainKey *key;
try {
if (argc < 1){
LB_GMP_SET();
key = &createDomain(0);
LB_GMP_RESTORE();
return DomainKeyToMaple(kv, *key);
}
//LinBox::integer *p = GMPMapleToLinBox(kv, argv[1]);
LinBox::integer p;
GMPMapleToLinBox(p, kv, argv[1]);
if (argc == 1){
LB_GMP_SET();
key = &createDomain(p);
LB_GMP_RESTORE();
return DomainKeyToMaple(kv, *key);
}
if (argc == 2){
LB_GMP_SET();
key = &createDomain(p, MapleToString(kv, argv[2]));
LB_GMP_RESTORE();
return DomainKeyToMaple(kv, *key);
}
if (argc > 2){
MapleRaiseError(kv, "wrong number of argument");
return ToMapleNULL(kv);
}
}
catch ( lb_runtime_error &t )
{ lbRaiseError(kv, t); return ToMapleNULL(kv);}
return ToMapleNULL(kv);
}
/**
* Create the output workspace group.
* @param baseName :: The base name for the output workspace. Suffix "Workspace"
* will be added to it.
* @param function :: A function to calculate the values. Must be of the
* MultiDomainFunction type.
* @param domain :: Domain created earlier with this creator (unused)
* @param values :: Values created earlier with this creator (unused)
* @param outputWorkspacePropertyName :: Name for the property to hold the
* output workspace. If
* empty the property won't be created.
* @return A shared pointer to the created workspace.
*/
boost::shared_ptr<API::Workspace> MultiDomainCreator::createOutputWorkspace(
const std::string &baseName, API::IFunction_sptr function,
boost::shared_ptr<API::FunctionDomain> domain,
boost::shared_ptr<API::FunctionValues> values,
const std::string &outputWorkspacePropertyName) {
UNUSED_ARG(domain);
UNUSED_ARG(values);
auto mdFunction =
boost::dynamic_pointer_cast<API::MultiDomainFunction>(function);
if (!mdFunction) {
throw std::runtime_error("A MultiDomainFunction is expected to be used "
"with MultiDomainCreator.");
}
// split the function into independent parts
std::vector<API::IFunction_sptr> functions =
mdFunction->createEquivalentFunctions();
// there must be as many parts as there are domains
if (functions.size() != m_creators.size()) {
throw std::runtime_error("Number of functions and domains don't match");
}
API::WorkspaceGroup_sptr outWS =
API::WorkspaceGroup_sptr(new API::WorkspaceGroup());
for (size_t i = 0; i < functions.size(); ++i) {
std::string localName =
baseName + "Workspace_" + boost::lexical_cast<std::string>(i);
auto fun = functions[i];
auto creator = m_creators[i];
boost::shared_ptr<API::FunctionDomain> localDomain;
boost::shared_ptr<API::FunctionValues> localValues;
fun->setUpForFit();
creator->createDomain(localDomain, localValues);
creator->initFunction(fun);
auto ws = creator->createOutputWorkspace(localName, fun, localDomain,
localValues, "");
API::AnalysisDataService::Instance().addOrReplace(localName, ws);
outWS->addWorkspace(ws);
}
if (!outputWorkspacePropertyName.empty()) {
declareProperty(
new API::WorkspaceProperty<API::WorkspaceGroup>(
outputWorkspacePropertyName, "", Kernel::Direction::Output),
"Name of the output Workspace holding resulting simulated spectrum");
m_manager->setPropertyValue(outputWorkspacePropertyName,
baseName + "Workspaces");
m_manager->setProperty(outputWorkspacePropertyName, outWS);
}
return outWS;
}
/**********************************
* Interface to create a blackbox *
**********************************/
ALGEB lbCreateBlackboxFromMatrix(MKernelVector kv, ALGEB A, const LinBox::integer &p){
RTableSettings setting;
RTableGetSettings(kv,&setting,A);
size_t m,n;
m = RTableUpperBound(kv, A, 1);
n = RTableUpperBound(kv, A, 2);
std::stringstream *buffer= new std::stringstream();//std::string(buffer_data, m*n));
//Timer chrono;
//chrono.start();
if (setting.storage == RTABLE_RECT)
DenseMatrixToBuffer(kv, A, *buffer, m, n, setting);
else
if (setting.storage == RTABLE_SPARSE)
SparseMatrixToBuffer(kv, A, *buffer, m, n, setting);
else
MapleRaiseError(kv, "Matrix storage must be either dense or sparse");
//chrono.stop();
//std::ofstream FILE("MAPLE_FILE.TXT");
//FILE<<buffer->str()<<"\n";
//FILE.close();
//std::cout<<"buffering in <- : "<<chrono;
//chrono.clear();
//chrono.start();
LB_GMP_SET();
const DomainKey *Dkey = &createDomain(p);
const BlackboxKey *Bkey = &createBlackbox(*Dkey, *buffer);
deleteDomain (*Dkey);
LB_GMP_RESTORE();
//chrono.stop();
//std::cout<<"buffering out -> : "<<chrono;
delete buffer;
return BlackboxKeyToMaple(kv, *Bkey);
}
int main(int argc, char **argv){
PetscErrorCode ierr;
int nx = 63, ny = 63;
DM dm;
PetscBool flg;
Mat A;
Vec u, b;
KSP solver;
PC pc;
double norm;
PetscInt stage;
ierr = PetscInitialize(&argc, &argv, NULL, NULL);CHKERRQ(ierr);
ierr = PetscOptionsGetInt(PETSC_NULL, "-nx", &nx, PETSC_NULL);CHKERRQ(ierr);
ierr = PetscOptionsGetInt(PETSC_NULL, "-ny", &ny, PETSC_NULL);CHKERRQ(ierr);
ierr = PetscOptionsHasName(PETSC_NULL, "-assemble", &flg);CHKERRQ(ierr);
ierr = PetscLogStageRegister("preparing",&stage); CHKERRQ(ierr);
ierr = PetscLogStagePush(stage);CHKERRQ(ierr);
ierr = PetscLogStageRegister("Domain creation",&stage); CHKERRQ(ierr);
ierr = PetscLogStagePush(stage);CHKERRQ(ierr);
ierr = createDomain(&dm, nx, ny);CHKERRQ(ierr);
ierr = PetscLogStagePop();CHKERRQ(ierr);
ierr = PetscLogStageRegister("matrix creation",&stage); CHKERRQ(ierr);
ierr = PetscLogStagePush(stage);CHKERRQ(ierr);
ierr = createMat(dm, &A, flg);CHKERRQ(ierr);
ierr = PetscLogStagePop();CHKERRQ(ierr);
ierr = PetscLogStageRegister("Vector creation",&stage); CHKERRQ(ierr);
ierr = PetscLogStagePush(stage);CHKERRQ(ierr);
ierr = PetscLogStagePop();CHKERRQ(ierr);
ierr = DMCreateGlobalVector(dm, &b);CHKERRQ(ierr);
ierr = VecDuplicate(b, &u);CHKERRQ(ierr);
ierr = PetscLogStageRegister("Domain initialisation",&stage); CHKERRQ(ierr);
ierr = PetscLogStagePush(stage);CHKERRQ(ierr);
ierr = init2d(dm, b);CHKERRQ(ierr);
ierr = PetscLogStagePop();CHKERRQ(ierr);
ierr = PetscLogStageRegister("solver creation",&stage); CHKERRQ(ierr);
ierr = PetscLogStagePush(stage);CHKERRQ(ierr);
ierr = KSPCreate(PETSC_COMM_WORLD, &solver);CHKERRQ(ierr);
ierr = KSPSetOptionsPrefix(solver, "poisson_");CHKERRQ(ierr);
ierr = KSPSetOperators(solver, A, A, DIFFERENT_NONZERO_PATTERN);CHKERRQ(ierr);
ierr = KSPSetType(solver, KSPCG);
ierr = KSPGetPC(solver, &pc);CHKERRQ(ierr);
ierr = PCSetType(pc, PCNONE);CHKERRQ(ierr);
ierr = KSPSetFromOptions(solver);CHKERRQ(ierr);
ierr = PetscLogStagePop();CHKERRQ(ierr);
ierr = PetscLogStagePop();CHKERRQ(ierr);
ierr = PetscLogStageRegister("Solving",&stage); CHKERRQ(ierr);
ierr = PetscLogStagePush(stage);CHKERRQ(ierr);
ierr = KSPSolve(solver, b, u);CHKERRQ(ierr);
ierr = PetscLogStagePop();CHKERRQ(ierr);
//ierr = VecView(u, PETSC_VIEWER_DRAW_WORLD);CHKERRQ(ierr);
//sleep(10);
VecDestroy(&u);
VecDestroy(&b);
MatDestroy(&A);
DMDestroy(&dm);
KSPDestroy(&solver);
ierr = PetscFinalize();
return 0;
}
ALGEB lbCreateVectorFromVector(MKernelVector kv, ALGEB V, const LinBox::integer &p){
LB_GMP_SET();
const DomainKey *Dkey = &createDomain(p);
LB_GMP_RESTORE();
std::stringstream buffer;
RTableSettings setting;
RTableData tmp;
RTableGetSettings(kv,&setting,V);
size_t n;
n = RTableUpperBound(kv, V, 1);
buffer<<n<<"\n";
M_INT index[1];
if (setting.data_type == RTABLE_INTEGER8)
for (size_t i=1;i<n+1; ++i){index[0]=(M_INT)i;
tmp=RTableSelect(kv, V, index);
buffer<<tmp.int8<<"\n";
}
if (setting.data_type == RTABLE_INTEGER16)
for (size_t i=1;i<n+1; ++i){index[0]=(M_INT)i;
tmp=RTableSelect(kv, V, index);
buffer<<tmp.int16<<"\n";
}
if (setting.data_type == RTABLE_INTEGER32)
for (size_t i=1;i<n+1; ++i){index[0]=(M_INT)i;
tmp=RTableSelect(kv, V, index);
buffer<<tmp.int32<<"\n";
}
if (setting.data_type == RTABLE_INTEGER64)
for (size_t i=1;i<n+1; ++i){index[0]=(M_INT)i;
tmp=RTableSelect(kv, V, index);
buffer<<tmp.int64<<"\n";
}
if (setting.data_type == RTABLE_FLOAT32)
for (size_t i=1;i<n+1; ++i){index[0]=(M_INT)i;
tmp=RTableSelect(kv, V, index);
buffer<<tmp.float32<<"\n";
}
if (setting.data_type == RTABLE_FLOAT64)
for (size_t i=1;i<n+1; ++i){index[0]=(M_INT)i;
tmp=RTableSelect(kv, V, index);
buffer<<tmp.float64<<"\n";
}
if (setting.data_type == RTABLE_DAG) {
LinBox::integer ibuf;
for (size_t i=1;i<n+1; ++i){index[0]=(M_INT)i;
tmp=RTableSelect(kv, V, index);
GMPMapleToLinBox(ibuf, kv,tmp.dag);
buffer<<ibuf<<"\n";
}
}
if ((setting.data_type == RTABLE_COMPLEX)|| (setting.data_type == RTABLE_CXDAG))
MapleRaiseError(kv, "data type format in the matrix is not yet recognized by LinBox ");
LB_GMP_SET();
const VectorKey *Vkey = &createVector(*Dkey, buffer);
deleteDomain (*Dkey);
LB_GMP_RESTORE();
return VectorKeyToMaple(kv, *Vkey);
}
