You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
109 lines
3.8 KiB
109 lines
3.8 KiB
#include <array>
|
|
#include <bitset>
|
|
#include <iostream>
|
|
#include <booluarray.hpp>
|
|
|
|
|
|
#include <cstddef>
|
|
#include <iostream>
|
|
#include <iomanip>
|
|
#include <fstream>
|
|
#include <vector>
|
|
#include "bernstein.hpp"
|
|
#include "multiloop.hpp"
|
|
#include "quadrature_multipoly.hpp"
|
|
#include "binomial.hpp"
|
|
|
|
#include "real.hpp"
|
|
#include "uvector.hpp"
|
|
#include "vector"
|
|
#include "xarray.hpp"
|
|
#include <chrono>
|
|
#include <cmath>
|
|
#include <memory>
|
|
|
|
#include "organizer/primitive.hpp"
|
|
|
|
namespace algoim::Organizer
|
|
{
|
|
class BasicTask
|
|
{
|
|
public:
|
|
// std::vector<std::shared_ptr<PrimitiveDesc>> primitives;
|
|
|
|
// BasicTask(std::vector<std::shared_ptr<PrimitiveDesc>> ps) {};
|
|
|
|
BasicTask(std::shared_ptr<PrimitiveDesc> p)
|
|
{
|
|
int q = 20;
|
|
real volume = 0;
|
|
real xmin = -1;
|
|
real xmax = 1;
|
|
auto integrand = [](const uvector<real, 3>& x) { return 1.0; };
|
|
uvector3 range = xmax - xmin;
|
|
|
|
|
|
if (auto pt = std::dynamic_pointer_cast<SphereDesc>(p)) {
|
|
tensor3 tensor(nullptr, 3);
|
|
algoim_spark_alloc(real, tensor);
|
|
makeSphere(*pt, tensor);
|
|
detail::powerTransformation(range, xmin, tensor);
|
|
|
|
tensor3 phi(nullptr, 3);
|
|
algoim_spark_alloc(real, phi);
|
|
detail::power2BernsteinTensor(tensor, phi);
|
|
|
|
uvector<real, 3> testX(0., 0., 0.25);
|
|
real testEvalBernstein = bernstein::evalBernsteinPoly(phi, testX);
|
|
// auto vec1 = xarray2StdVector(phi);
|
|
std::cout << "eval bernstein without interpolation:" << testEvalBernstein << std::endl;
|
|
|
|
ImplicitPolyQuadrature<3> ipquad(phi);
|
|
ipquad.integrate(AutoMixed, q, [&](const uvector<real, 3>& x, real w) {
|
|
if (isInsideBernstein(phi, x)) volume += w * integrand(xmin + x * (xmax - xmin));
|
|
});
|
|
} else if (auto pt = std::dynamic_pointer_cast<MeshDesc>(p)) {
|
|
const int faceCount = pt->indexInclusiveScan.size();
|
|
assert(faceCount > 1);
|
|
std::vector<tensor3> planeTensors(faceCount, tensor3(nullptr, 2));
|
|
algoim_spark_alloc(real, planeTensors);
|
|
|
|
tensor3 compositeTensor(nullptr, 1 + faceCount);
|
|
algoim_spark_alloc(real, compositeTensor);
|
|
|
|
makeMesh(*pt, compositeTensor, planeTensors);
|
|
detail::powerTransformation(range, xmin, compositeTensor);
|
|
|
|
tensor3 phi(nullptr, 1 + faceCount);
|
|
algoim_spark_alloc(real, phi);
|
|
detail::power2BernsteinTensor(compositeTensor, phi);
|
|
|
|
ImplicitPolyQuadrature<3> ipquad(phi);
|
|
ipquad.integrate(AutoMixed, q, [&](const uvector<real, 3>& x, real w) {
|
|
auto realX = x * range + xmin;
|
|
if (isInsidePowers(planeTensors, realX)) volume += w * integrand(realX);
|
|
});
|
|
}
|
|
volume *= pow(xmax - xmin, 3);
|
|
std::cout << "Volume xxx: " << volume << std::endl;
|
|
};
|
|
|
|
// BasicTask(std::shared_ptr<PowerTensorComplex> pc)
|
|
// {
|
|
// int q = 10;
|
|
// real volume;
|
|
// uvector3 xmin = 0;
|
|
// uvector3 xmax = 1;
|
|
// auto integrand = [](const uvector<real, 3>& x) { return 1.0; };
|
|
// uvector3 range = xmax - xmin;
|
|
|
|
// detail::powerTransformation(range, xmin, pc->compositeTensor);
|
|
// auto primitive = BernsteinTensorComplex(*pc);
|
|
// ImplicitPolyQuadrature<3> ipquad(primitive.compositeTensor);
|
|
// ipquad.integrate(AutoMixed, q, [&](const uvector<real, 3>& x, real w) {
|
|
// if (primitive.isInside(x)) volume += w * integrand(xmin + x * (xmax - xmin));
|
|
// });
|
|
// std::cout << "Volume xxx: " << volume << std::endl;
|
|
// };
|
|
};
|
|
}; // namespace algoim::Organizer
|
|
|