xlifepp – Functions – S#

sameDofs#

bool xlifepp::sameDofs(const SuTermVector&, const SuTermVector&)#

tensor cross product => vector SuTermVector in 3D, scalar SuTermVector in 2D

check if 2 SuTermVector have same dofs

sameOrientation#

bool xlifepp::sameOrientation(std::vector<const Point*> border1, std::vector<const Point*> border2)#

determine if 2 lists of points ordered differently have the same orientation It is supposed that every point in each list is also in the other one

determine if 2 geometries (list of vertices) have the same orientation

sameStorage#

bool xlifepp::sameStorage(const MatrixStorage &sto1, const MatrixStorage &sto2)#

compare two storages, they are same if all the coefficients are travelled in the same way

test if two storages are similar

storage pointers are the same
storage types are the same, sizes are the same and storage structure are the same

saveCircArcToGeo#

void xlifepp::saveCircArcToGeo(CircArc &a, ShapeType sh, std::ofstream &fout, std::vector<PhysicalData> &pids, bool withLoopsStorage, bool withSideNames)#: writing a circle arc in a geo file

saveComponentExtraDataToGeo#

void xlifepp::saveComponentExtraDataToGeo(const Geometry &g, number_t nloops, std::ofstream &fout)#: writing the surface/volume definition (Plane Surface or Volume command in geo)

saveComponentToGeo#

void xlifepp::saveComponentToGeo(Geometry &g, ShapeType sh, std::ofstream &fout, std::vector<PhysicalData> &pids, bool withLoopsStorage, bool withFaceNames, bool withEdgeNames, bool withVertexNames)#: writing a component of composite geometry in a geo file whatever the dimension

saveConeToGeo#

void xlifepp::saveConeToGeo(Cone &c, ShapeType sh, std::ofstream &fout, std::vector<PhysicalData> &pids, bool withLoopsStorage, bool withFaceNames, bool withEdgeNames, bool withVertexNames)#

writing a conical volume in a geo file

writing a cone in a geo file

saveCylinderToGeo#

void xlifepp::saveCylinderToGeo(Cylinder &c, ShapeType sh, std::ofstream &fout, std::vector<PhysicalData> &pids, bool withLoopsStorage, bool withFaceNames, bool withEdgeNames, bool withVertexNames)#: writing a cylindrical volume in a geo file

saveDiskToGeo#

void xlifepp::saveDiskToGeo(Disk &d, ShapeType sh, std::ofstream &fout, std::vector<PhysicalData> &pids, bool withLoopsStorage, bool withEdgeNames, bool withVertexNames)#: writing a disk in a geo file

saveEllArcToGeo#

void xlifepp::saveEllArcToGeo(EllArc &a, ShapeType sh, std::ofstream &fout, std::vector<PhysicalData> &pids, bool withLoopsStorage, bool withSideNames)#: writing an elliptic arc in a geo file

saveEllipseToGeo#

void xlifepp::saveEllipseToGeo(Ellipse &e, ShapeType sh, std::ofstream &fout, std::vector<PhysicalData> &pids, bool withLoopsStorage, bool withEdgeNames, bool withVertexNames)#: writing an elliptic surface in a geo file

saveEllipsoidToGeo#

void xlifepp::saveEllipsoidToGeo(Ellipsoid &e, ShapeType sh, std::ofstream &fout, std::vector<PhysicalData> &pids, bool withLoopsStorage, bool withFaceNames, bool withEdgeNames, bool withVertexNames)#: writing an ellipsoidal volume or a ball in a geo file

saveExtByCompositionToGeo#

void xlifepp::saveExtByCompositionToGeo(const Geometry &g, const Transformation &t, std::ofstream &fout, const std::map<string_t, Strings> &inputs)#: writing an extrusion by a composition of translations and rotations in a geo file

saveExtByRotation2dToGeo#

void xlifepp::saveExtByRotation2dToGeo(const Geometry &g, const Rotation2d &r, std::vector<int_t> nnodesPerLine, std::ofstream &fout, const std::map<string_t, Strings> &inputs)#: writing an extrusion by Rotation2d in a geo file

saveExtByRotation3dToGeo#

void xlifepp::saveExtByRotation3dToGeo(const Geometry &g, const Rotation3d &r, std::vector<int_t> nnodesPerLine, std::ofstream &fout, const std::map<string_t, Strings> &inputs)#: writing an extrusion by Rotation3d in a geo file

saveExtByRotationSideNamesToGeo#

void xlifepp::saveExtByRotationSideNamesToGeo(const Geometry &g, const std::vector<string_t> &sidenames, const std::vector<std::pair<number_t, number_t>> &nbSidesPerComponent, const real_t angle, std::ofstream &fout, const std::map<string_t, Strings> &inputs, std::vector<PhysicalData> &pids)#

writing sidenames of an extrusion by Rotation2d in a geo file

writing sidenames of an extrusion by Rotation2d or Rotation3d in a geo file

saveExtByTranslationSideNamesToGeo#

void xlifepp::saveExtByTranslationSideNamesToGeo(const Geometry &g, const std::vector<string_t> &sidenames, const std::vector<std::pair<number_t, number_t>> &nbSidesPerComponent, const Translation &t, std::ofstream &fout, const std::map<string_t, Strings> &inputs, std::vector<PhysicalData> &pids)#: writing sidenames of an extrusion by Translation in a geo file

saveExtByTranslationToGeo#

void xlifepp::saveExtByTranslationToGeo(const Geometry &g, const Translation &t, std::vector<int_t> nnodesPerLine, std::ofstream &fout, const std::map<string_t, Strings> &inputs)#: writing an extrusion by Translation in a geo file

saveExtrusionComponentToGeo#

void xlifepp::saveExtrusionComponentToGeo(const Geometry &g, const Transformation &t, std::vector<int_t> nnodesPerLine, std::ofstream &fout, const std::map<string_t, Strings> &inputs)#: writing an extrusion in a geo file

saveExtrusionGeometryToGeo#

std::vector<std::pair<number_t, number_t>> xlifepp::saveExtrusionGeometryToGeo(Geometry &g, ShapeType sh, real_t angle, std::ofstream &fout, std::vector<PhysicalData> &pids, bool withLoopsStorage, bool withSideNames)#: writing an extrusion geometry in a geo file whatever the dimension

saveExtrusionInputsAsString#

string_t xlifepp::saveExtrusionInputsAsString(const std::map<string_t, Strings> &inputs)#: writing extrusion inputs as string

saveExtrusionSideNamesToGeo#

void xlifepp::saveExtrusionSideNamesToGeo(const Geometry &g, const std::vector<string_t> &sidenames, const std::vector<std::pair<number_t, number_t>> &nbSidesPerComponent, const Transformation &t, std::ofstream &fout, const std::map<string_t, Strings> &inputs, std::vector<PhysicalData> &pids)#: writing sidenames of an extrusion in a geo file

saveHexahedronToGeo#

void xlifepp::saveHexahedronToGeo(Hexahedron &h, ShapeType sh, std::ofstream &fout, std::vector<PhysicalData> &pids, bool withLoopsStorage, bool withFaceNames, bool withEdgeNames, bool withVertexNames)#: writing a hexahedron in a geo file

saveParallelepipedToGeo#

void xlifepp::saveParallelepipedToGeo(Parallelepiped &p, ShapeType sh, std::ofstream &fout, std::vector<PhysicalData> &pids, bool withLoopsStorage, bool withFaceNames, bool withEdgeNames, bool withVertexNames)#: writing a parallelepiped, a cuboid or a cube in a geo file

saveParametrizedArcToGeo#

void xlifepp::saveParametrizedArcToGeo(ParametrizedArc &a, ShapeType sh, std::ofstream &fout, std::vector<PhysicalData> &pids, bool withLoopsStorage, bool withSideNames)#: writing a parametrized arc in a geo file

saveParametrizedSurfaceToGeo#

void xlifepp::saveParametrizedSurfaceToGeo(ParametrizedSurface &s, ShapeType sh, std::ofstream &fout, std::vector<PhysicalData> &pids, bool withLoopsStorage, bool withEdgeNames, bool withVertexNames)#

writing a parametrized surface (split in triangle or nurbs) in a geo file split the parametrized surface s in s.nbParts elementary surface either quadrangle or triangle or nurbs (s.shapePart)

writing a parametrized surface in a geo file

savePolygonToGeo#

void xlifepp::savePolygonToGeo(Polygon &p, ShapeType sh, std::ofstream &fout, std::vector<PhysicalData> &pids, bool withLoopsStorage, bool withEdgeNames, bool withVertexNames)#

writing a triangle in a geo file

writing a polygon in a geo file

savePolyhedronToGeo#

void xlifepp::savePolyhedronToGeo(Polyhedron &p, ShapeType sh, std::ofstream &fout, std::vector<PhysicalData> &pids, bool withLoopsStorage, bool withFaceNames, bool withEdgeNames, bool withVertexNames)#

writing a polyhedral volume in a geo file

writing a polyhedron in a geo file

saveQuadrangleToGeo#

void xlifepp::saveQuadrangleToGeo(Quadrangle &q, ShapeType sh, std::ofstream &fout, std::vector<PhysicalData> &pids, bool withLoopsStorage, bool withEdgeNames, bool withVertexNames)#: writing a quadrangle, a rectangle or a square in a geo file

saveRevConeToGeo#

void xlifepp::saveRevConeToGeo(RevCone &c, ShapeType sh, std::ofstream &fout, std::vector<PhysicalData> &pids, bool withLoopsStorage, bool withFaceNames, bool withEdgeNames, bool withVertexNames)#

writing a revolution conical volume in a geo file

writing a revolution cone in a geo file

saveRevCylinderToGeo#

void xlifepp::saveRevCylinderToGeo(RevCylinder &c, ShapeType sh, std::ofstream &fout, std::vector<PhysicalData> &pids, bool withLoopsStorage, bool withFaceNames, bool withEdgeNames, bool withVertexNames)#

writing a prism in a geo file

writing a revolution cylindrical volume in a geo file

saveRevTrunkToGeo#

void xlifepp::saveRevTrunkToGeo(RevTrunk &t, ShapeType sh, std::ofstream &fout, std::vector<PhysicalData> &pids, bool withLoopsStorage, bool withFaceNames, bool withEdgeNames, bool withVertexNames)#

writing a prism in a geo file

writing a revolution trunk in a geo file

saveSegmentToGeo#

void xlifepp::saveSegmentToGeo(Segment &s, ShapeType sh, std::ofstream &fout, std::vector<PhysicalData> &pids, bool withLoopsStorage, bool withSideNames)#: writing a segment in a geo file

saveSplineArcToGeo#

void xlifepp::saveSplineArcToGeo(const SplineArc &a, ShapeType sh, std::ofstream &fout, std::vector<PhysicalData> &pids, bool withLoopsStorage, bool withSideNames)#

writing a spline arc in a geo file spline in standard gmsh factory corresponds to Catmull-Rom spline spline in occ gmsh factory corresponds to C2 spline

writing a parametrized arc in a geo file

saveTetrahedronToGeo#

void xlifepp::saveTetrahedronToGeo(Tetrahedron &t, ShapeType sh, std::ofstream &fout, std::vector<PhysicalData> &pids, bool withLoopsStorage, bool withFaceNames, bool withEdgeNames, bool withVertexNames)#: writing a tetrahedron in a geo file

saveToBrepGeo#

void xlifepp::saveToBrepGeo(Geometry &g, MeshData &meshData, ShapeType sh, number_t order, MeshPattern pattern, StructuredMeshSplitPattern splitPattern, const string_t &geofile, const string_t &brepfile)#: writing a 2D/3D geometry in a geo file using Open Cascade way and Brep format

saveToFile#

inline void xlifepp::saveToFile(const string_t &filename, const EigenElements &evs)#

inline void xlifepp::saveToFile(const string_t &filename, const EigenElements &evs, const Parameter &p1)#

inline void xlifepp::saveToFile(const string_t &filename, const EigenElements &evs, const Parameter &p1, const Parameter &p2)#

inline void xlifepp::saveToFile(const string_t &filename, const EigenElements &evs, const Parameter &p1, const Parameter &p2, const Parameter &p3)#

void xlifepp::saveToFile(const string_t &filename, const EigenElements &evs, const std::vector<Parameter> &ps)#: save eigenvalues into one file and eigenvectors into separate files

inline void xlifepp::saveToFile(const string_t &filename, const EigenElements &evs, IOFormat iof)#

void xlifepp::saveToFile(const string_t &filename, const GeomDomain &dom, IOFormat iof)#

inline void xlifepp::saveToFile(const string_t &filename, const Mesh &m)#

inline void xlifepp::saveToFile(const string_t &filename, const Mesh &m, const Parameter &p1)#

inline void xlifepp::saveToFile(const string_t &filename, const Mesh &m, const Parameter &p1, const Parameter &p2)#

inline void xlifepp::saveToFile(const string_t &filename, const Mesh &m, const Parameter &p1, const Parameter &p2, const Parameter &p3)#

inline void xlifepp::saveToFile(const string_t &filename, const Mesh &m, const Parameter &p1, const Parameter &p2, const Parameter &p3, const Parameter &p4)#

inline void xlifepp::saveToFile(const string_t &filename, const Mesh &m, IOFormat iof, bool withDomains = false)#

void xlifepp::saveToFile(const string_t &filename, const Space *sp, const list<SuTermVector*> &sutvs, IOFormat iof, bool withElementSplitting, string_t dataName, bool aFilePerDomain)#: save a list of SuTermVectors on a same Space to files

void xlifepp::saveToFile(const string_t &filename, const Space *sp, const std::list<SuTermVector*> &sutvs, IOFormat iof, bool split = true, string_t dataName = "", bool aFilePerDomain = true)#: input/output function

inline void xlifepp::saveToFile(const string_t &filename, const std::list<const TermVector*> &tvs)#

inline void xlifepp::saveToFile(const string_t &filename, const std::list<const TermVector*> &tvs, const Parameter &p1)#

inline void xlifepp::saveToFile(const string_t &filename, const std::list<const TermVector*> &tvs, const Parameter &p1, const Parameter &p2)#

inline void xlifepp::saveToFile(const string_t &filename, const std::list<const TermVector*> &tvs, const Parameter &p1, const Parameter &p2, const Parameter &p3)#

inline void xlifepp::saveToFile(const string_t &filename, const std::list<const TermVector*> &tvs, const Parameter &p1, const Parameter &p2, const Parameter &p3, const Parameter &p4)#

void xlifepp::saveToFile(const string_t &filename, const std::list<const TermVector*> &tvs, const std::vector<Parameter> &ps)#

inline void xlifepp::saveToFile(const string_t &filename, const SvdElements &evs)#

inline void xlifepp::saveToFile(const string_t &filename, const SvdElements &evs, const Parameter &p1)#

inline void xlifepp::saveToFile(const string_t &filename, const SvdElements &evs, const Parameter &p1, const Parameter &p2)#

inline void xlifepp::saveToFile(const string_t &filename, const SvdElements &evs, const Parameter &p1, const Parameter &p2, const Parameter &p3)#

void xlifepp::saveToFile(const string_t &filename, const SvdElements &evs, const std::vector<Parameter> &ps)#: save singular values into one file and singular vectors into separate files

inline void xlifepp::saveToFile(const string_t &filename, const SvdElements &evs, IOFormat iof)#

inline void xlifepp::saveToFile(const string_t &filename, const TermMatrix &A)#: save TermMatrix to file (dense or Matlab format)

inline void xlifepp::saveToFile(const string_t &filename, const TermMatrix &A, const Parameter &p1)#: save TermMatrix to file (dense or Matlab format)

inline void xlifepp::saveToFile(const string_t &filename, const TermMatrix &A, const Parameter &p1, const Parameter &p2)#: save TermMatrix to file (dense or Matlab format)

inline void xlifepp::saveToFile(const string_t &filename, const TermMatrix &A, StorageType st, bool enc = false)#: save TermMatrix to file (dense or Matlab format)

void xlifepp::saveToFile(const string_t &filename, const TermVector &tv)#

inline void xlifepp::saveToFile(const string_t &filename, const TermVector &tv, bool aFilePerDomain)#

void xlifepp::saveToFile(const string_t &filename, const TermVector &tv, const Parameter &p1)#

void xlifepp::saveToFile(const string_t &filename, const TermVector &tv, const Parameter &p1, const Parameter &p2)#

void xlifepp::saveToFile(const string_t &filename, const TermVector &tv, const Parameter &p1, const Parameter &p2, const Parameter &p3)#

void xlifepp::saveToFile(const string_t &filename, const TermVector &tv, const Parameter &p1, const Parameter &p2, const Parameter &p3, const Parameter &p4)#

inline void xlifepp::saveToFile(const string_t &filename, const TermVector &tv, IOFormat iof, bool aFilePerDomain = true)#

inline void xlifepp::saveToFile(const string_t &filename, const TermVector &tv, string_t dataName, bool aFilePerDomain = true)#

void xlifepp::saveToFile(const string_t &filename, const TermVector &tv1, const TermVector &tv2)#

inline void xlifepp::saveToFile(const string_t &filename, const TermVector &tv1, const TermVector &tv2, bool aFilePerDomain)#

void xlifepp::saveToFile(const string_t &filename, const TermVector &tv1, const TermVector &tv2, const Parameter &p1)#

void xlifepp::saveToFile(const string_t &filename, const TermVector &tv1, const TermVector &tv2, const Parameter &p1, const Parameter &p2)#

void xlifepp::saveToFile(const string_t &filename, const TermVector &tv1, const TermVector &tv2, const Parameter &p1, const Parameter &p2, const Parameter &p3)#

void xlifepp::saveToFile(const string_t &filename, const TermVector &tv1, const TermVector &tv2, const Parameter &p1, const Parameter &p2, const Parameter &p3, const Parameter &p4)#

void xlifepp::saveToFile(const string_t &filename, const TermVector &tv1, const TermVector &tv2, const TermVector &tv3)#

inline void xlifepp::saveToFile(const string_t &filename, const TermVector &tv1, const TermVector &tv2, const TermVector &tv3, bool aFilePerDomain)#

void xlifepp::saveToFile(const string_t &filename, const TermVector &tv1, const TermVector &tv2, const TermVector &tv3, const Parameter &p1)#

void xlifepp::saveToFile(const string_t &filename, const TermVector &tv1, const TermVector &tv2, const TermVector &tv3, const Parameter &p1, const Parameter &p2)#

void xlifepp::saveToFile(const string_t &filename, const TermVector &tv1, const TermVector &tv2, const TermVector &tv3, const Parameter &p1, const Parameter &p2, const Parameter &p3)#

void xlifepp::saveToFile(const string_t &filename, const TermVector &tv1, const TermVector &tv2, const TermVector &tv3, const Parameter &p1, const Parameter &p2, const Parameter &p3, const Parameter &p4)#

void xlifepp::saveToFile(const string_t &filename, const TermVector &tv1, const TermVector &tv2, const TermVector &tv3, const TermVector &tv4)#

inline void xlifepp::saveToFile(const string_t &filename, const TermVector &tv1, const TermVector &tv2, const TermVector &tv3, const TermVector &tv4, bool aFilePerDomain)#

void xlifepp::saveToFile(const string_t &filename, const TermVector &tv1, const TermVector &tv2, const TermVector &tv3, const TermVector &tv4, const Parameter &p1)#

void xlifepp::saveToFile(const string_t &filename, const TermVector &tv1, const TermVector &tv2, const TermVector &tv3, const TermVector &tv4, const Parameter &p1, const Parameter &p2)#

void xlifepp::saveToFile(const string_t &filename, const TermVector &tv1, const TermVector &tv2, const TermVector &tv3, const TermVector &tv4, const Parameter &p1, const Parameter &p2, const Parameter &p3)#

void xlifepp::saveToFile(const string_t &filename, const TermVector &tv1, const TermVector &tv2, const TermVector &tv3, const TermVector &tv4, const Parameter &p1, const Parameter &p2, const Parameter &p3, const Parameter &p4)#

inline void xlifepp::saveToFile(const string_t &filename, const TermVectors &tvs)#

inline void xlifepp::saveToFile(const string_t &filename, const TermVectors &tvs, bool aFilePerDomain)#

inline void xlifepp::saveToFile(const string_t &filename, const TermVectors &tvs, const Parameter &p1)#

inline void xlifepp::saveToFile(const string_t &filename, const TermVectors &tvs, const Parameter &p1, const Parameter &p2)#

inline void xlifepp::saveToFile(const string_t &filename, const TermVectors &tvs, const Parameter &p1, const Parameter &p2, const Parameter &p3)#

void xlifepp::saveToFile(const string_t &filename, const TermVectors &tvs, const std::vector<Parameter> &ps)#: save TermVectors to files

inline void xlifepp::saveToFile(const string_t &filename, const TermVectors &tvs, IOFormat iof, bool aFilePerDomain = false)#

inline void xlifepp::saveToFile(const string_t &filename, const TermVectors &tvs, string_t dataName = "", bool aFilePerDomain = false)#

void xlifepp::saveToFile(const string_t &fn, const TermVector &tv, const string_t &dataName, IOFormat format, bool aFilePerDomain)#: save 1 TermVector to files with a specific format (alias of the version with a list of TermVectors)

void xlifepp::saveToFile(const string_t &fn, const TermVector &tv1, const TermVector &tv2, const TermVector &tv3, const TermVector &tv4, IOFormat format, bool aFilePerDomain)#: save 4 TermVector to filesc01;nC110404 with a specific format (alias of the version with a list of TermVectors)

void xlifepp::saveToFile(const string_t &fn, const TermVector &tv1, const TermVector &tv2, const TermVector &tv3, const TermVector &tv4, string_t dataName, bool aFilePerDomain)#: save 4 TermVectors to files with a specific data name (alias of the version with a list of TermVectors)

void xlifepp::saveToFile(const string_t &fn, const TermVector &tv1, const TermVector &tv2, const TermVector &tv3, IOFormat format, bool aFilePerDomain)#: save 3 TermVector to files with a specific format (alias of the version with a list of TermVectors)

void xlifepp::saveToFile(const string_t &fn, const TermVector &tv1, const TermVector &tv2, const TermVector &tv3, string_t dataName, bool aFilePerDomain)#: save 3 TermVectors to files with a specific data name (alias of the version with a list of TermVectors)

void xlifepp::saveToFile(const string_t &fn, const TermVector &tv1, const TermVector &tv2, IOFormat format, bool aFilePerDomain)#: save 2 TermVector to files with a specific format (alias of the version with a list of TermVectors)

void xlifepp::saveToFile(const string_t &fn, const TermVector &tv1, const TermVector &tv2, string_t dataName, bool aFilePerDomain)#: save 2 TermVectors to files with a specific data name (alias of the version with a list of TermVectors)

saveToGeo#

void xlifepp::saveToGeo(Geometry &g, MeshData &meshData, number_t order, const string_t &filename)#: writing a 1D geometry in a geo file

void xlifepp::saveToGeo(Geometry &g, MeshData &meshData, ShapeType sh, number_t order, MeshPattern pattern, StructuredMeshSplitPattern splitPattern, const string_t &filename, std::set<CrackData> &cracks)#: writing a 2D/3D geometry in a geo file

saveToMsh#

void xlifepp::saveToMsh(ostream &fout, const Space *sp, const list<SuTermVector*> &sutvs, const vector<Point> &coords, const vector<pair<ShapeType, vector<number_t>>> &elementsInfo, const GeomDomain *dom, string_t dataName)#: save a list of SuTermVectors on the same Space to msh files

void xlifepp::saveToMsh(std::ostream &fout, const Space*, const std::list<SuTermVector*>&, const std::vector<Point> &coords, const splitvec_t &elementsInfo, const GeomDomain *dom, string_t dataName = "")#

saveToMtlb#

void xlifepp::saveToMtlb(ostream &fout, const Space *sp, const list<SuTermVector*> &sutvs, const vector<Point> &coords, const vector<pair<ShapeType, vector<number_t>>> &elementsInfo, const GeomDomain *dom, string_t dataName)#: save a list of SuTermVectors on the same Space to Matlab - Octave files

void xlifepp::saveToMtlb(std::ostream &fout, const Space*, const std::list<SuTermVector*>&, const std::vector<Point> &coords, const splitvec_t &elementsInfo, const GeomDomain *dom, string_t dataName = "")#

saveToVizir4#

void xlifepp::saveToVizir4(ostream &fout, ostream &gout, const Space *sp, const list<SuTermVector*> &sutvs, const vector<Point> &coords, const vector<pair<ShapeType, vector<number_t>>> &elementsInfo, const GeomDomain *dom, bool withElementSplitting, string_t dataName)#: save a list of SuTermVectors on the same Space to vtk xml files for unstructured grid type meshes

void xlifepp::saveToVizir4(std::ostream &fout, std::ostream &gout, const Space*, const std::list<SuTermVector*>&, const std::vector<Point> &coords, const splitvec_t &elementsInfo, const GeomDomain *dom, bool withElementSplitting, string_t dataName)#

saveToVtk#

void xlifepp::saveToVtk(ostream &fout, const Space *sp, const list<SuTermVector*> &sutvs, const vector<Point> &coords, const vector<pair<ShapeType, vector<number_t>>> &elementsInfo, const GeomDomain *dom, string_t dataName)#: save a list of SuTermVectors on the same Space to vtk files

void xlifepp::saveToVtk(std::ostream &fout, const Space*, const std::list<SuTermVector*>&, const std::vector<Point> &coords, const splitvec_t &elementsInfo, const GeomDomain *dom, string_t dataName = "")#

saveToVtkVtu#

void xlifepp::saveToVtkVtu(ostream &fout, const Space *sp, const list<SuTermVector*> &sutvs, const vector<Point> &coords, const vector<pair<ShapeType, vector<number_t>>> &elementsInfo, const GeomDomain *dom, string_t dataName)#: save a list of SuTermVectors on the same Space to vtk xml files for unstructured grid type meshes

void xlifepp::saveToVtkVtu(std::ostream &fout, const Space*, const std::list<SuTermVector*>&, const std::vector<Point> &coords, const splitvec_t &elementsInfo, const GeomDomain *dom, string_t dataName = "")#

saveToXyzVs#

void xlifepp::saveToXyzVs(ostream &fout, const Space *sp, const list<SuTermVector*> &sutvs, const vector<Point> &coords, string_t dataName, bool writeHeader)#: save a list of SuTermVectors v’s on the same Space as raw file x [y [z]] v1 [v2 …] the ouput of coordinates depends of the dimension of mesh nodes when vi is a complex output vi.real vi.imag when vi is a real vector output vi_x vi_y [vi_z] when vi is a complex vector output vi_x.real vi_x.imag vi_y.real vi_y.imag [vi_z.real vi_z.imag]

void xlifepp::saveToXyzVs(std::ostream &fout, const Space *sp, const std::list<SuTermVector*> &stvlist, const std::vector<Point> &coords, string_t dataName = "", bool writeHeader = true)#

saveTriangleToGeo#

void xlifepp::saveTriangleToGeo(Triangle &t, ShapeType sh, std::ofstream &fout, std::vector<PhysicalData> &pids, bool withLoopsStorage, bool withEdgeNames, bool withVertexNames)#: writing a triangle in a geo file

saveTrunkToGeo#

void xlifepp::saveTrunkToGeo(Trunk &t, ShapeType sh, std::ofstream &fout, std::vector<PhysicalData> &pids, bool withLoopsStorage, bool withFaceNames, bool withEdgeNames, bool withVertexNames)#

writing a cylindrical volume in a geo file

writing a trunk in a geo file

scaledVectorTpl#

template<typename scalar1, typename T1_iterator, typename R_iterator> void xlifepp::scaledVectorTpl(const scalar1 &s, T1_iterator b1, T1_iterator e1, T1_iterator b2, R_iterator Rb)#: Scaled vector R[i] = s * ( T1[i] - T2 [i] )

scaleVector#

void xlifepp::scaleVector(const complex_t &k, const Vector<complex_t> &v, Vector<real_t> &r)#

void xlifepp::scaleVector(const complex_t &k, const Vector<real_t> &v, Vector<real_t> &r)#

template<typename K, typename K1, typename K2> void xlifepp::scaleVector(const K &k, const Vector<K1> &v, Vector<K2> &r)#

void xlifepp::scaleVector(const real_t &k, const Vector<complex_t> &v, Vector<real_t> &r)#

scatteredFieldDiskDirichlet#

complex_t xlifepp::scatteredFieldDiskDirichlet(const Point &p, Parameters &param)#

Exact solution to the Helmholtz 2D problem outside a sphere: Field scattered by solid sphere of radius Rad of an incoming field Phi_w= exp^{(i*K*x}).

‘Exact solutions’ to the Helmholtz 2D problem outside a disk

Field scattered by solid disk of radius Rad of an incoming field Phi_w= exp^{(i*k*x}).

with Dirichlet boundary condition on the sphere

scatteredFieldDiskDirichlet_dr#

complex_t xlifepp::scatteredFieldDiskDirichlet_dr(const Point&, Parameters&)#

scatteredFieldDiskNeumann#

complex_t xlifepp::scatteredFieldDiskNeumann(const Point&, Parameters&)#

scatteredFieldMaxwellExn#

Vector<complex_t> xlifepp::scatteredFieldMaxwellExn(const Point &p, Parameters &param)#

Exact solution to the Maxwell 3D problem outside a sphere: Field scattered by solid sphere of radius Rad of an incoming vector field Phi_w= (1,0,0)*exp^{(i*K*z}).

‘Exact solutions’ to the Maxwell 3D problem outside a sphere

Field scattered by solid sphere of radius R of an incoming field Phi_w= exp^{(i*k*z}). with tangential boundary condition Exn = 0 (electric field) on the sphere:

\(\Phi(\rho,\theta \phi) = \sum_{n=1..\infty} i^n * (2n+1) * cos\phi*e_rho*c_rho[n] + cos\phi*e_theta*c_theta[n] + sin\phi*c_phi[n]\)

with

[ \(\sin\theta*\cos\phi\) ] [ \(\cos\theta*\cos\phi\) ] [ \(-\sin\phi\) ]
e_rho =[ \(\sin\theta*\sin\phi\) ] e_theta =[ \(\cos\theta*\sin\phi\) ] e_phi =[ \(\cos\phi\) ]
[ \(\cos\theta\) ] [ \(-\sin\theta\) ] [ 0 ] and
\(c_rho[n] = - A_n(K*R) * H_{n}(K*rho)/K*rho ) * Ps_n(\cos\theta)\)
c_theta[n] =
c–phi[n] =

where

A_n(r) = -i^{n-1} (2*n+1) real(hnp(r)) / hnp(r) where hnp(r) = d/dr[H_{n}](r) + H_{n}(r)
B_n(r) = -i^{n-1} (2*n+1) real(H_{n}(r)) / H_{n}(r) and
H_{n} = h_n^{(1)} = j_n + i*y_n is the spherical hankel function of first kind and order n
j_n: spherical bessel function of the first kind and order n
y_n: spherical bessel function of the second kind and order n

with electric field boundary condition Exn=0 on the sphere

Some computed values for K=1 X_1 X_2 X_3 Phi_1 Phi_2 Phi_3 1.0 0.0 0.0 | (1.75532926384 , 1.62107824182 ) (0 , 0 ) (-6.02796306309e-18,-1.58122117268e-18) 0.0 1.0 0.0 | (-1 , 4.81409564708e-17) (0 , 0 ) (0 , 0 ) 0.0 0.0 1.0 | (-5.40302305868e-01,-8.41470984808e-01) (0 , 0 ) (0 , 0 ) 1.0 1.0 1.0 | (-1.69184878965e-01, 1.61131192686e-01) (2.06589901137e-01, 2.52914553648e-01) (1.19848010392e-01, 3.28542217311e-01) 1.0 1.0 1.2 | (-1.86022424304e-01, 9.18508880491e-02) (1.49911272089e-01, 2.01342400004e-01) (9.37804387189e-02, 3.03355869671e-01) 1.0 1.0 1.4 | (-1.91775499206e-01, 3.34280295554e-02) (1.07142066815e-01, 1.59632591445e-01) (6.64556013889e-02, 2.71335010720e-01) 1.0 1.0 1.6 | (-1.88260942630e-01,-1.51180741005e-02) (7.54265673653e-02, 1.27220194457e-01) (4.11641109484e-02, 2.38176631400e-01) 1.0 1.0 1.8 | (-1.77261848423e-01,-5.51624601093e-02) (5.20175373132e-02, 1.02356587880e-01) (1.91974583103e-02, 2.06737287161e-01) 1.0 1.0 2.0 | (-1.60341338903e-01,-8.78244555191e-02) (3.47085585869e-02, 8.32071602821e-02) (8.24999561215e-04, 1.78106610047e-01) 1.2 1.4 1.0 | (-1.93790114095e-01, 7.12577504506e-02) (1.44884948487e-01, 2.06529528004e-01) (1.39532076671e-02, 1.97067304047e-01) 1.2 1.4 1.2 | (-1.90729686988e-01, 2.88712762800e-02) (1.12819966807e-01, 1.81439122245e-01) (9.10642428927e-03, 1.94073277948e-01) 1.2 1.4 1.4 | (-1.83137187727e-01,-1.04437244804e-02) (8.50160197427e-02, 1.57350273961e-01) (7.19355647585e-04, 1.84905785693e-01) 1.2 1.4 1.6 | (-1.70990951385e-01,-4.55518271208e-02) (6.17400731503e-02, 1.35416184077e-01) (-9.27523672141e-03, 1.71746716026e-01) 1.2 1.4 1.8 | (-1.54657449587e-01,-7.58575264387e-02) (4.27052811485e-02, 1.16028225273e-01) (-1.95184324637e-02, 1.56344795623e-01) 1.2 1.4 2.0 | (-1.34728108413e-01,-1.01074590219e-01) (2.73910156223e-02, 9.91350581457e-02) (-2.91430511034e-02, 1.39939464554e-01)

scatteredFieldSphereDirichlet#

complex_t xlifepp::scatteredFieldSphereDirichlet(const Point&, Parameters&)#

Field scattered by solid sphere of radius Rad of an incoming field Phi_w= exp^{(i*k*x}).

Exact solution to the Helmholtz 3D problem outside a sphere: Field scattered by solid sphere of radius Rad of an incoming field Phi_w= exp^{(i*K*x}).

with Dirichlet boundary condition on the sphere: Series representation of Bessel spherical functions and Legendre polynomials

\(\Phi(\rho,\phi) = \sum_{n=0}^\infty A\_n(K*Rad) h_n^{(1)}(K*\rho) P_n(cos(\phi))\)

where \(A_n(r) = i^n (2*n+1) { j_n(kR)/ h_n^{(1)}(kR)}\)

with Dirichlet boundary condition on the sphere

scatteredFieldSphereNeumann#

complex_t xlifepp::scatteredFieldSphereNeumann(const Point &p, Parameters &param)#

Exact solution to the Helmholtz 3D problem outside a sphere: Field scattered by solid sphere of radius Rad of an incoming field Phi_w= exp^{(i*K*x}).

‘Exact solutions’ to the Helmholtz 3D problem outside a sphere

Field scattered by solid sphere of radius Rad of an incoming field Phi_w= exp^{(i*k*x}). with Neumann boundary condition on the sphere: Series representation of Bessel spherical functions and Legendre polynomials

\(\Phi(\rho,\phi) = \sum_{n=0}^\infty A\_n(K*Rad) h_n^{(1)}(K*\rho) P_n(cos(\phi))\)

where \(A_n(r) = - i^n (2*n+1) { d/dr[j_n](r) / d/dr[h_n^{(1)}](r) }\) and

h_n^{(1)} = H_{n} = j_n + i*y_n is the spherical hankel function of first kind and order n
j_n: spherical bessel function of the first kind and order n
y_n: spherical bessel function of the second kind and order n

— for spherical Bessel functions, see

HANDBOOK Of MATHEMATICAL FUNCTIONS, Ed. M.ABRAMOWITZ & I.A. STEGUN
Chap. 10 : Bessel Functions of Fractional Order (p.437-494)
http://www.math.sfu.ca/~cbm/aands/page_437.htm — for Legendre polynomials, see
http://en.wikipedia.org/wiki/Legendre_polynomials

with Neumann boundary condition on the sphere

schurSolve#

TermVector xlifepp::schurSolve(TermMatrix &A, const TermVector &B, const Unknown &row_v, const Unknown &col_u, bool keepA)#

Schur Solver, only for 2x2 unknowns TermMatrix:

|A11  A12 ||X1|   |B1|
|         ||  | = |  |
|A21  A22 ||X2|   |B1|

if A11 is invertible: C21 = A21 * inv(A11) * A12 C22 = A22 - C21 D2 = B2 - A21 * inv(A11) * B1 if C22 invertible X2 = inv(C22) * D2 X1 = inv(A11)(B1 - A12 * X2)

A: multiple unknowns TermMatrix B: multiple unknowns TermVector row_v, col_u: unknowns pair defining the diagonal block used as pivot (say A11) keepA: true if TermMatrix has to be preserved (TermVector B is always preserved)

securedPath#

string_t xlifepp::securedPath(const string_t &path)#: adapt path to OS format and check if path exists

segmentQuadrature#

Quadrature *xlifepp::segmentQuadrature(QuadRule, number_t)#: find or create quadrature rule over the unit segment

selectRefHexahedron#

RefElement *xlifepp::selectRefHexahedron(const Interpolation *int_p)#: selectRefHexahedron construction of a Reference Element by interpolation type and interpolation subtype

selectRefPrism#

RefElement *xlifepp::selectRefPrism(const Interpolation *interp_p)#: selectRefPrism construction of a prismatic Reference Element by interpolation subtype and number

selectRefPyramid#

RefElement *xlifepp::selectRefPyramid(const Interpolation *interp_p)#: selectRefPyramid construction of a pyramidatic Reference Element by interpolation subtype and number

selectRefQuadrangle#

RefElement *xlifepp::selectRefQuadrangle(const Interpolation *interp_p)#: selectRefQuadrangle construction of a Reference Element by interpolation type and interpolation subtype

selectRefSegment#

RefElement *xlifepp::selectRefSegment(const Interpolation *interp_p)#: segment construction of a 1D Reference Element by interpolation type and interpolation subtype

selectRefTetrahedron#

RefElement *xlifepp::selectRefTetrahedron(const Interpolation *interp_p)#: tetrahedronConstructor construction of a Reference Element by interpolation type and interpolation subtype

selectRefTriangle#

RefElement *xlifepp::selectRefTriangle(const Interpolation *interp_p)#: selectReferenceTriangle construction of a Reference Element by interpolation type and interpolation subtype

setB#

inline void xlifepp::setB(Vector<real_t> &p)#

inline void xlifepp::setB(Vector<real_t> *p, number_t t)#

setBasisIndex#

inline void xlifepp::setBasisIndex(number_t i)#

inline void xlifepp::setBasisIndex(number_t i, number_t t)#

setBx#

inline void xlifepp::setBx(Vector<real_t> &p)#

inline void xlifepp::setBx(Vector<real_t> *p)#

inline void xlifepp::setBx(Vector<real_t> *p, number_t t)#

setBy#

inline void xlifepp::setBy(Vector<real_t> &p)#

inline void xlifepp::setBy(Vector<real_t> *p)#

inline void xlifepp::setBy(Vector<real_t> *p, number_t t)#

setColor#

void xlifepp::setColor(const GeomDomain &dom, const TermVector &tv, ColoringRule cr)#

set color of geom elements of domain according to vertex values and a coloring rule dom: the domain to colorize val: a single unknown TermVector containing the values used to colorize cr: the ColoringRule, i.e.

set color of geom elements of domain according to vertex values and a coloring rule

a function of the form: real_t cr(const Geomelement& gelt, const std::vector<real_t>& v) returning the color of the geometric element (see defaultColoringRule function for instance)

void xlifepp::setColor(const GeomDomain &dom, const TermVector &tv, VectorColoringRule vcr)#

set color of geom elements of domain according to vertex vector values and a vector coloring rule dom: the domain to colorize val: a single unknown TermVector containing the vector values used to colorize vcr: the vector ColoringRule, i.e.

set color of geom elements of domain according to vertex vector values and a vector coloring rule

a function of the form: real_t vcr(const Geomelement& gelt, const std::vector<Vector<real_t> >& v) returning the color of the geometric element (see defaultColoringRule function for instance)

void xlifepp::setColor(const GeomDomain &dom, real_t r)#: set the color of geom elements to r value

setDefaultCharacteristicLength#

inline void xlifepp::setDefaultCharacteristicLength(real_t h)#: set the characteristic length

setDerivative#

inline void xlifepp::setDerivative(number_t i)#

inline void xlifepp::setDerivative(number_t i, number_t t)#

setDof#

inline void xlifepp::setDof(Dof *p)#

inline void xlifepp::setDof(Dof *p, number_t t)#

setDomain#

inline void xlifepp::setDomain(GeomDomain *p)#

setDomainx#

inline void xlifepp::setDomainx(GeomDomain *p)#

setDomainy#

inline void xlifepp::setDomainy(GeomDomain *p)#

setElement#

inline void xlifepp::setElement(GeomElement *p)#

inline void xlifepp::setElement(GeomElement *p, number_t t)#

seteol#

inline void xlifepp::seteol(number_t n = 0)#: manage eol variable by adding n spaces after carriage return

setGlobalVerboseLevel#

void xlifepp::setGlobalVerboseLevel(const number_t)#: set a maximum value for all verbose levels setGlobalVerboseLevel(0) sets all levels to zero

setN#

inline void xlifepp::setN(Vector<real_t> &p)#

inline void xlifepp::setN(Vector<real_t> *p, number_t t)#

setNewHandler#

void xlifepp::setNewHandler()#: defines a new trace handler

setNx#

inline void xlifepp::setNx(Vector<real_t> &p)#

inline void xlifepp::setNx(Vector<real_t> *p)#

inline void xlifepp::setNx(Vector<real_t> *p, number_t t)#

setNy#

inline void xlifepp::setNy(Vector<real_t> &p)#

inline void xlifepp::setNy(Vector<real_t> *p)#

inline void xlifepp::setNy(Vector<real_t> *p, number_t t)#

setRanks#

void xlifepp::setRanks(std::vector<Unknown*>&, const std::vector<number_t>&)#: set ranks of unknowns

void xlifepp::setRanks(Unknown &u1, number_t r1)#

void xlifepp::setRanks(Unknown &u1, number_t r1, Unknown &u2, number_t r2)#

void xlifepp::setRanks(Unknown &u1, number_t r1, Unknown &u2, number_t r2, Unknown &u3, number_t r3)#

void xlifepp::setRanks(Unknown &u1, number_t r1, Unknown &u2, number_t r2, Unknown &u3, number_t r3, Unknown &u4, number_t r4)#

setRefCountedAlloc#

template<typename T> void xlifepp::setRefCountedAlloc(bool isAlloc, RefCounted<T> &ref)#

setT#

inline void xlifepp::setT(Vector<real_t> &p)#

inline void xlifepp::setT(Vector<real_t> *p, number_t t)#

setTx#

inline void xlifepp::setTx(Vector<real_t> &p)#

inline void xlifepp::setTx(Vector<real_t> *p)#

inline void xlifepp::setTx(Vector<real_t> *p, number_t t)#

setTy#

inline void xlifepp::setTy(Vector<real_t> &p)#

inline void xlifepp::setTy(Vector<real_t> *p)#

inline void xlifepp::setTy(Vector<real_t> *p, number_t t)#

shapeDim#

int_t xlifepp::shapeDim(ShapeType sh)#

dimension of a shape type (return -1 if not defined)

dimension of a shape type

shrink#

template<typename T> void xlifepp::shrink(std::vector<T> &u, number_t s)#: resize and shrink a vector to size s

sides#

GeomDomain &xlifepp::sides(GeomDomain &dom)#: access to domain defined from all sides of elements of domain dom, create it if not defined

sign#

inline SymbolicFunction &xlifepp::sign(const SymbolicFunction &f)#

template<typename T> int xlifepp::sign(T val)#

signe#

inline real_t xlifepp::signe(real_t x)#

signedDistancesToTriangleEdges#

std::vector<real_t> xlifepp::signedDistancesToTriangleEdges(const Point &M, const Point &T1, const Point &T2, const Point &T3)#

signed distances of a point M to the three edges of the triangle whose vertices are T1, T2 and T3

signed distances of a point to the 3 edges of a triangle

simplexVertexOutput#

void xlifepp::simplexVertexOutput(std::ofstream &os, const int refNum, const int v1, const int v2, const int v3, const int v4)#

simpson#

template<typename T> T xlifepp::simpson(const std::vector<T> &f, real_t h)#

template<typename T, typename Iterator> T xlifepp::simpson(number_t n, real_t h, Iterator itb, T &intg)#: uniform Simpson method from a list of n (odd) values uniformaly distributed (step h) n: number of values h: step itb: first position in the list of values intg: value of integral

template<typename T> T xlifepp::simpson(T (*f)(real_t), real_t a, real_t b, number_t n)#: uniform Simpson method on [a,b] interval from a function and a number of intervals

template<typename T> T xlifepp::simpson(T (*f)(real_t, Parameters&), Parameters &pars, real_t a, real_t b, number_t n)#: uniform Simpson method on [a,b] interval from a function with parameters and a number of intervals

sin#

inline SuTermVector xlifepp::sin(const SuTermVector &s)#

inline SymbolicFunction &xlifepp::sin(const SymbolicFunction &f)#

inline TermVector xlifepp::sin(const TermVector &s)#

sinh#

inline SuTermVector xlifepp::sinh(const SuTermVector &s)#

inline SymbolicFunction &xlifepp::sinh(const SymbolicFunction &f)#

inline TermVector xlifepp::sinh(const TermVector &s)#

sinhs#

template<typename T> T xlifepp::sinhs(const T &x)#: integrand at (t,z), extern call

sizeOf#

inline number_t xlifepp::sizeOf(const complex_t &x)#

inline number_t xlifepp::sizeOf(const real_t &x)#

inline number_t xlifepp::sizeOf(const std::vector<complex_t> &x)#

inline number_t xlifepp::sizeOf(const std::vector<real_t> &x)#

inline number_t xlifepp::sizeOf(const std::vector<Vector<complex_t>> &x)#

inline number_t xlifepp::sizeOf(const std::vector<Vector<real_t>> &x)#

skylinePointer#

std::vector<number_t> xlifepp::skylinePointer(const std::vector<number_t>&, const std::vector<number_t>&)#: get the skyline pointers from cs pointers

smallPivot#

inline bool xlifepp::smallPivot(complex_t piv)#

inline bool xlifepp::smallPivot(real_t piv)#

smartPtr#

template<typename T> inline SmartPtr<T> xlifepp::smartPtr(T *p)#

smartPtrConstCast#

template<typename T> const SmartPtr<typename RemoveConst<T>::type> xlifepp::smartPtrConstCast(const SmartPtr<T> &rhs)#

template<typename T> SmartPtr<typename RemoveConst<T>::type> xlifepp::smartPtrConstCast(SmartPtr<T> &rhs)#

smartPtrFromRef#

template<typename T> inline SmartPtr<T> xlifepp::smartPtrFromRef(T *p)#

spaces#

inline Spaces xlifepp::spaces(const Domains &doms, const Interpolation &inte, bool opt = true)#

inline Spaces xlifepp::spaces(const Domains &doms, const Interpolations &ints, bool opt = true)#: build a collection of space according to collections of domains and collection of interpolations

inline Spaces xlifepp::spaces(const GeomDomain &dom, const Interpolations &ints, bool opt = true)#

sphericalbesselJ0N#

std::vector<real_t> xlifepp::sphericalbesselJ0N(real_t x, number_t N)#: spherical Bessel function of the first kind and orders 0..N

sphericalbesselJ0NTest#

void xlifepp::sphericalbesselJ0NTest(std::ostream &out)#

sphericalbesselY0N#

std::vector<real_t> xlifepp::sphericalbesselY0N(real_t x, number_t N)#: spherical Bessel function of the second kind and orders 0..N

sphericalHarmonics#

void xlifepp::sphericalHarmonics(const Point &x, std::vector<std::vector<complex_t>> &ylm)#

This function computes spherical harmonics Y_{l}^{m} up to order n on the unit sphere; order n is computed by n=ylm.size()-1 and spherical harmonics ylm are computed for l=0,..,n and m=0,..,l.

Spherical harmonics and derivatives

Spherical harmonics Y^{m}_l up to order n (l=0,..,n; m=0,..,l) on the unit sphere We use here the normalized definition, in which harmonics form an orthonormal basis in L^2(unit_sphere). In spherical coordinates

\(r = \sqrt{x*^2+y^2+z^2} , \cos\theta = z/r, \tan\phi = y/x\)
with \(\theta in [0, Pi], \phi in [0, 2*Pi]\), we have the following formula:

\(Y^{m}_{l} = \sqrt{(2*l+1)/4Pi * (l-m)!/(l+m)!} * P^{m}_{l}(\cos\theta) * \exp(i*m*\phi)\)

where \(P^{m}_{l}\) is the m-th associated Legendre polynomial of order l.

\(Y^{m}_{l}\) satisfies for negative m: \(Y^{m}_{l} = (-1)^{m} Y^{-m}_{l}*\) where (terminal) * denotes the complex conjugate.

For spherical harmonics see

http://en.wikipedia.org/wiki/Spherical_harmonics and for associated Legendre functions
http://en.wikipedia.org/wiki/Associated_Legendre_polynomials

Y_{l}^{m}= \((-1)^{(|m|-m) /2} \sqrt{ (2l+1)/4\pi*(l-|m|)!/(l+|m|)! } P_{l}^{|m|}(\cos(\theta)) e^{im \phi}\)

which yields for m positive

Y_{l}^{m}= \(\sqrt{ (2l+1)/4\pi*(l-m)!/(l+m)! } P_{l}^{m}(\cos(\theta)) e^{im \phi}\)

Argument ylm is a “triangular 2d array” defined as a std::vector of vectors

the 1st std::vector carries the values: Y_{0}^{0} the 2nd one carries the values: Y_{1}^{0} Y_{1}^{1} and for l=2,..,n the l-th std::vector carries the values: Y_{l}^{0} Y_{l}^{1} .. Y_{l}^{l} if the size of std::vector ylm[l] is l+1.

For a given int n, container ylm can be declared (and defined) prior to call to this function by std::vector<std::vector<complex_t> > ylm(n+1); for (int l=0; l<=n; l++) ylm[l]=std::vector<complex_t>(l+1);

sphericalHarmonicsSurfaceGrad#

void xlifepp::sphericalHarmonicsSurfaceGrad(const Point&, std::vector<std::vector<Vector<complex_t>>>&)#

Spherical harmonics surface gradient gradS_Y^{m}_l up to order n (l=0,..,n; m=0,..,l) on the unit sphere.

This function computes spherical harmonics surface gradients gradY_{l}^{m} up to order n on the unit sphere; order n is computed by n=ylm.size()-1 and spherical harmonics ylm are computed for l=0,..,n and m=0,..,l.

Case ( \(\sin(\theta) = 0\)) : . gradS_Y_{l}^{1} = \(\sqrt{ (2l+1)/4\pi * (l-1)! / (l+1)! } * e^{i \phi} * . (P_{l}^{'1}(\cos(\theta)) e_\theta - i (\cos(\theta))^{l+1} \cos(\phi) l(l+1)/2 * e_\phi)\) . where \(e_\theta\) and \(e_\phi\) are the unit tangent std::vector on the unit sphere. . gradS_Y_{l}^{m}(x) = 0 if m =/= 1

Case ( \(\sin(\theta) /= 0\)) : . gradS_Y_{0}^{0}(x) = 0 . For l > 0 : . gradS_Y_{l}^{m} = \(\sqrt{ (2l+1)/4\pi * (l-m)! / (l+m)! } * e^{im \phi} * . ( P_{l}^{'|m|}(\cos(\theta)) e_\theta + im * P_{l}^{|m|}(\cos(\theta)) e_\phi)\) . where \(e_\theta\) and \(e_\phi\) are the unit tangent std::vector on the unit sphere.

Argument gradylm is a “triangular 2d array of 3d-vectors” defined as a vector of vectors of complex_t-Vectors. the 1st std::vector carries the 3d-vectorial values: gradY_{0}^{0} the 2nd one carries the 3d-vectorial values: gradY_{1}^{0} gradY_{1}^{1} and for l=2,..,n the l-th std::vector carries the 3d-vectorial values: gradY_{l}^{0} gradY_{l}^{1} .. gradY_{l}^{l} where the size of std::vector gradylm[l] is l+1.

For a given int n, container gradylm can be declared (and defined) prior to call to this function by std::vector<std::vector<Vector<complex_t> > > gradylm(n+1); for (int l=0; l<=n; l++) { gradylm[l]=std::vector<Vector<complex_t> >(l+1); for (int m=0; m<=l; m++) gradylm[l][m]=Vector<complex_t>(spaceDim); } where “spaceDim” is previously defined as the dimension space (necessarily 3 here). TELL DANIEL: We may put a test that stops the program if spaceDim is not 3.

sphericalHarmonicsSurfaceGradTest#

void xlifepp::sphericalHarmonicsSurfaceGradTest(const Point&, const number_t, std::ostream&)#: output function for test of Spherical harmonics and derivatives

sphericalHarmonicsTest#

void xlifepp::sphericalHarmonicsTest(const Point&, const number_t, std::ostream&)#: output function for test of Spherical harmonics

split#

inline Strings xlifepp::split(const string_t &s, char delim = ' ')#: split a string into vector of strings using blank space as default delimiter

std::vector<bfPair> xlifepp::split(std::vector<bfPair> &bfs)#

splitHexahedronQ1ToTetrahedraP1#

std::vector<std::vector<number_t>> xlifepp::splitHexahedronQ1ToTetrahedraP1(std::vector<number_t> nodeNumbers)#: return nodes numbers of first order tetrahedron elements when splitting first order hexahedron

splitHexahedronQ2ToHexahedraQ1#

std::vector<std::vector<number_t>> xlifepp::splitHexahedronQ2ToHexahedraQ1(std::vector<number_t> nodeNumbers)#: return nodes numbers of first order hexahedron elements when splitting second order hexahedron

splitHexahedronQ2ToTetrahedraP1#

std::vector<std::vector<number_t>> xlifepp::splitHexahedronQ2ToTetrahedraP1(std::vector<number_t> nodeNumbers)#: return nodes numbers of first order tetrahedron elements when splitting second order hexahedron

splitHexahedronQ3ToHexahedraQ1#

std::vector<std::vector<number_t>> xlifepp::splitHexahedronQ3ToHexahedraQ1(std::vector<number_t> nodeNumbers)#: return nodes numbers of first order hexahedron elements when splitting third order hexahedron

splitHexahedronQ3ToTetrahedraP1#

std::vector<std::vector<number_t>> xlifepp::splitHexahedronQ3ToTetrahedraP1(std::vector<number_t> nodeNumbers)#: return nodes numbers of first order tetrahedron elements when splitting third order hexahedron

splitInTriangles#

std::vector<std::vector<number_t>> xlifepp::splitInTriangles(const std::vector<Point> &pts)#

splitNumbersFind#

bool xlifepp::splitNumbersFind(std::vector<std::vector<number_t>> splitnum, std::vector<number_t> num)#: return nodes numbers by removing duplicates

splitNumbersMerge#

std::vector<std::vector<number_t>> xlifepp::splitNumbersMerge(std::vector<std::vector<number_t>> splitnum1, std::vector<std::vector<number_t>> splitnum2)#

splitNumbersUnique#

std::vector<std::vector<number_t>> xlifepp::splitNumbersUnique(std::vector<std::vector<number_t>> splitnum)#: return nodes numbers by removing duplicates

splitTetrahedronP2ToTetrahedraP1#

std::vector<std::vector<number_t>> xlifepp::splitTetrahedronP2ToTetrahedraP1(std::vector<number_t> nodeNumbers)#: return nodes numbers of first order tetrahedron elements when splitting second order tetrahedron

splitTetrahedronP3ToTetrahedraP1#

std::vector<std::vector<number_t>> xlifepp::splitTetrahedronP3ToTetrahedraP1(std::vector<number_t> nodeNumbers)#: return nodes numbers of first order tetrahedron elements when splitting third order tetrahedron

sqrt#

inline SuTermVector xlifepp::sqrt(const SuTermVector &s)#

inline SymbolicFunction &xlifepp::sqrt(const SymbolicFunction &f)#

inline TermVector xlifepp::sqrt(const TermVector &s)#

template<typename K> Vector<K> xlifepp::sqrt(const Vector<K> &v)#: sqrt(v)

sqrt2_over_pi#

static const real_t xlifepp::sqrt2_over_pi(std::sqrt(two_over_pi))#

squared#

inline SuTermVector xlifepp::squared(const SuTermVector &s)#

inline SymbolicFunction &xlifepp::squared(const SymbolicFunction &f)#

inline TermVector xlifepp::squared(const TermVector &s)#

squareDistance#

real_t xlifepp::squareDistance(const Point&, const Point&)#: returns the square distance between two points

storedLines#

static bool xlifepp::storedLines(MatrixEntry *mat, const std::vector<number_t> &rank, number_t nbl, bool byCol, std::vector<std::vector<std::pair<number_t, number_t>>> &lines)#: stored coefficients of some columns (byCol=true) or rows (byCol=false) of a matrix, extracted in one pass from the list of the stored coefficients (see MatrixStorage::storedPositions): lines[k-1] = list of (row or col index, address) of the line of rank k, rank[l] = rank of the line l (0 if the line is not selected), nbl the number of selected lines only for a scalar matrix with a compressed storage where each coefficient has its own address (so not a symmetric storage of a symmetric matrix), returns false else (the generic algorithms using getRows, getCol, … are used)

storeEigenVector#

void xlifepp::storeEigenVector(const TermMatrix *A_p, ValueType vt, bool singleUnknown, VectorEntry *eigvec, TermVector &resVec)#: Utility function to store data of an eigenvector into a TermVector.

storeElSides#

void xlifepp::storeElSides(const GeomElement *el_p, number_t noelt, SIDELTMAP &parentEl, const std::vector<bool> *marked = nullptr)#

void xlifepp::storeElSides(const GeomElement *el_p, number_t noelt, SIDELTMAP &parentEl, const vector<bool> *marked)#

str#

string_t xlifepp::str(const Parameter&)#: cast to string_t

stringto#

template<typename T> T xlifepp::stringto(const string_t &s)#: returns string converted to T

struct2Str#

string_t xlifepp::struct2Str(StrucType s)#

strucType#

inline StrucType xlifepp::strucType(const complex_t &x)#

inline StrucType xlifepp::strucType(const real_t &x)#

template<typename T> inline StrucType xlifepp::strucType(const std::vector<T> &x)#

struveNotH0#

real_t xlifepp::struveNotH0(real_t x)#: Struve function of order 0, H_0(x) returns H_0(x) for any |x|<=8, H_0(x)-Y_0(x) for any |x|>8.

struveNotH01#

std::pair<real_t, real_t> xlifepp::struveNotH01(real_t x)#: returns both H_0(x) and H_1(x) for any |x|<8, returns H_0(x)-Y_0(x) and H_1(x)-Y_1(x) for any |x|>8.

struveNotH1#

real_t xlifepp::struveNotH1(real_t x)#: Struve function of order 1, H_1(x) returns H_1(x) for any |x|<=‡8, H_1(x)-Y_1(x) for any |x|>8.

subSpace#

Space &xlifepp::subSpace(Space &sp, const GeomDomain &dom)#: return sub-space or trace space on domain of a space, created if not exist

substrCanonicalAndCanonical#

void xlifepp::substrCanonicalAndCanonical(const Geometry &g1, const Geometry &g2, Geometry &g)#

substrCanonicalAndComposite#

void xlifepp::substrCanonicalAndComposite(const Geometry &g1, const Geometry &g2, Geometry &g)#

substrCanonicalAndLoop#

void xlifepp::substrCanonicalAndLoop(const Geometry &g1, const Geometry &g2, Geometry &g)#

substrCompositeAndCanonical#

void xlifepp::substrCompositeAndCanonical(const Geometry &g1, const Geometry &g2, Geometry &g)#

substrCompositeAndComposite#

void xlifepp::substrCompositeAndComposite(const Geometry &g1, const Geometry &g2, Geometry &g)#

substrCompositeAndLoop#

void xlifepp::substrCompositeAndLoop(const Geometry &g1, const Geometry &g2, Geometry &g)#

substrLoopAndCanonical#

void xlifepp::substrLoopAndCanonical(const Geometry &g1, const Geometry &g2, Geometry &g)#

substrLoopAndComposite#

void xlifepp::substrLoopAndComposite(const Geometry &g1, const Geometry &g2, Geometry &g)#

substrLoopAndLoop#

void xlifepp::substrLoopAndLoop(const Geometry &g1, const Geometry &g2, Geometry &g)#

surfaceFrom#

Geometry xlifepp::surfaceFrom(const Geometry &c, string_t domName, bool isPlaneSurface)#

definition of a geometry 2D from its boundary 1D

definition of a geometry 2D from an union of boundaries 1D

surfToArcParametrizationu0#

Vector<real_t> xlifepp::surfToArcParametrizationu0(const Point &p, Parameters &pars, DiffOpType d)#

surfToArcParametrizationu1#

Vector<real_t> xlifepp::surfToArcParametrizationu1(const Point &p, Parameters &pars, DiffOpType d)#

surfToArcParametrizationv0#

Vector<real_t> xlifepp::surfToArcParametrizationv0(const Point &p, Parameters &pars, DiffOpType d)#

surfToArcParametrizationv1#

Vector<real_t> xlifepp::surfToArcParametrizationv1(const Point &p, Parameters &pars, DiffOpType d)#

svd#

template<typename T> LowRankMatrix<T> &xlifepp::svd(const LargeMatrix<T> &lm, LowRankMatrix<T> &lrm, number_t r = 0, real_t eps = theTolerance)#

svd of a LargeMatrix

SVD compression method of a LargeMatrix to a LowRankMatrix Lr produce the best matrix approximation Lr of rank r (see Eckart-Young-Mirsky theorem)

T: type of the result lm: LargeMatrix to be compressed r: prescribed rank of truncature, if 0 not used, the real rank at output eps: prescribed precision, if rk > 0 not used r=0 and eps=0 gives the full svd lrm: LowRankMatrix

template<typename T> void xlifepp::svd(Matrix<T> &A, Matrix<T> &U, Vector<T> &D, Matrix<T> &V, number_t r = 0, real_t eps = 0.)#: SVD or truncated SVD with either rank or precision truncation T: type of the matrix (real or complex) A: Matrix to be be factorized U,D,V: SVD factors A=U*D*V’ or A~U*D*V’ (output) r: prescribed rank eps: singularvalue threshold if r > 0, the SVD is restricted to the first r singular values else it is restricted to the first singular values smaller than eps rmk: r=0 and eps=0 gives the full svd.

template<typename T> void xlifepp::svd(T *A, number_t m, number_t n, T *U, T *D, T *V, number_t &rk, real_t eps = 0.)#

general template svd using Eigen, assuming A, U, V are pointers to first value of DENSE ROW matrix A: pointer to dense row matrix m,n: number of rows and cols of A U, V: pointer to dense row matrices, has to be allocated before S: pointer to S vector, has to be allocated before rk: prescribed rank of truncature, if 0 not used, the real rank at output eps: prescribed precision, if rk > 0 not used r=0 and eps=0 gives the full svd

note: may be used when A is a pointer to a m x n col dense matrix, by permuting arguments when calling: svd(A,n,m,V,D,U,rk,eps) produces the SVD of A produces the SVD of A = U*D*V’ where U, V are pointers to row dense matrices!

SvdElements xlifepp::svd(TermMatrix *A, const std::vector<Parameter> &ps)#: Main entry point for SVD decomposition using Arpack.

symAmd#

bool xlifepp::symAmd(number_t nbr, number_t nbc, const std::vector<number_t> &colIndices, const std::vector<number_t> &rowPointer, std::vector<number_t> &colPerm)#

symb#

inline SymbolicTermMatrix &xlifepp::symb(const TermMatrix &M)#

symbolic_curabc#

Vector<real_t> xlifepp::symbolic_curabc(const Point&, Parameters&, DiffOpType)#: to deal with symbolic paramerization curvilinear abcissa

symbolic_curvature#

Vector<real_t> xlifepp::symbolic_curvature(const Point&, Parameters&, DiffOpType)#: to deal with symbolic paramerization curvature

symbolic_f#

Vector<real_t> xlifepp::symbolic_f(const Point&, Parameters&, DiffOpType)#: to deal with symbolic paramerization f

symbolic_invParametrization#

Vector<real_t> xlifepp::symbolic_invParametrization(const Point&, Parameters&, DiffOpType)#: to deal with symbolic paramerization invParametrization

symbolic_length#

Vector<real_t> xlifepp::symbolic_length(const Point&, Parameters&, DiffOpType)#: to deal with symbolic paramerization length

symbolic_normal#

Vector<real_t> xlifepp::symbolic_normal(const Point&, Parameters&, DiffOpType)#: to deal with symbolic paramerization normal

symbolic_tangent#

Vector<real_t> xlifepp::symbolic_tangent(const Point&, Parameters&, DiffOpType)#: to deal with symbolic paramerization tangent