Foam::tmp<Foam::scalarField> Foam::primitiveMesh::movePoints
(
    const pointField& newPoints,
    const pointField& oldPoints
)
{
    if (newPoints.size() <  nPoints() || oldPoints.size() < nPoints())
    {
        FatalErrorIn
        (
            "primitiveMesh::movePoints(const pointField& newPoints, "
            "const pointField& oldPoints)"
        )   << "Cannot move points: size of given point list smaller "
            << "than the number of active points" << nl
            << "newPoints: " << newPoints.size()
            << " oldPoints: " << oldPoints.size()
            << " nPoints(): " << nPoints() << nl
            << abort(FatalError);
    }

    // Create swept volumes
    const faceList& f = faces();

    tmp<scalarField> tsweptVols(new scalarField(f.size()));
    scalarField& sweptVols = tsweptVols();

    forAll(f, faceI)
    {
        sweptVols[faceI] = f[faceI].sweptVol(oldPoints, newPoints);
    }
Foam::List<Foam::objectHit>
Foam::PrimitivePatch<Face, FaceList, PointField, PointType>::
projectPoints
(
    const ToPatch& targetPatch,
    const Field<PointType>& projectionDirection,
    const intersection::algorithm alg,
    const intersection::direction dir
) const
{
    // The current patch is slave, i.e. it is being projected onto the target

    if (projectionDirection.size() != nPoints())
    {
        FatalErrorIn
        (
            "PrimitivePatch<Face, FaceList, PointField, PointType>::"
            "projectPoints(const PrimitivePatch& "
            ", const Field<PointType>&) const"
        )   << "Projection direction field does not correspond to "
            << "patch points." << endl
            << "Size: " << projectionDirection.size()
            << " Number of points: " << nPoints()
            << abort(FatalError);
    }

    const labelList& slavePointOrder = localPointOrder();

    const labelList& slaveMeshPoints = meshPoints();

    // Result
    List<objectHit> result(nPoints());

    // If there are no faces in the master patch, return: all misses
    if (targetPatch.size() == 0)
    {
        // Null-constructed object hit is a miss
        return result;
    }

    const labelListList& masterFaceFaces = targetPatch.faceFaces();

    const ToPatch& masterFaces = targetPatch;

    const Field<PointType>& masterPoints = targetPatch.points();

    // Estimate face centre of target side
    Field<PointType> masterFaceCentres(targetPatch.size());

    forAll (masterFaceCentres, faceI)
    {
        masterFaceCentres[faceI] =
            average(masterFaces[faceI].points(masterPoints));
    }
Ejemplo n.º 3
0
/*!
 * \brief Load data from specified file
 */
bool Data2D::load(const char* fileName)
{
	// Open file and check that we're OK to proceed reading from it
	LineParser parser(fileName);

	if (!parser.ready())
	{
		msg.print("Couldn't open file '%s' for reading.\n", fileName);
		return false;
	}

	int success;
	double oldZ = z_;
	clear();
	while (!parser.atEnd())
	{
		success = parser.getArgs(LineParser::SkipBlanks);
		if (!success)
		{
			parser.closeFiles();
			msg.print("Error reading from file '%s'.\n", fileName);
			return false;
		}

		addPoint(parser.argd(0), parser.argd(1));
	}
	
	parser.closeFiles();
	
	msg.print("Loaded %i points from file '%s'.\n", nPoints(), fileName);
	z_ = oldZ;
	
	return true;
}
const Foam::labelListList& Foam::primitiveMesh::pointFaces() const
{
    if (!pfPtr_)
    {
        if (debug)
        {
            Pout<< "primitiveMesh::pointFaces() : "
                << "calculating pointFaces" << endl;
        }
        // Invert faces()
        pfPtr_ = new labelListList(nPoints());
        invertManyToMany(nPoints(), faces(), *pfPtr_);
    }

    return *pfPtr_;
}
void Foam::primitiveMesh::calcPointCells() const
{
    // Loop through cells and mark up points

    if (debug)
    {
        Pout<< "primitiveMesh::calcPointCells() : "
            << "calculating pointCells"
            << endl;

        if (debug == -1)
        {
            // For checking calls:abort so we can quickly hunt down
            // origin of call
            FatalErrorIn("primitiveMesh::calcPointCells()")
                << abort(FatalError);
        }
    }

    // It is an error to attempt to recalculate pointCells
    // if the pointer is already set
    if (pcPtr_)
    {
        FatalErrorIn("primitiveMesh::calcPointCells() const")
            << "pointCells already calculated"
            << abort(FatalError);
    }
    else
    {
        const cellList& cf = cells();

        // Count number of cells per point

        labelList npc(nPoints(), 0);

        forAll (cf, cellI)
        {
            const labelList curPoints = cf[cellI].labels(faces());

            forAll (curPoints, pointI)
            {
                label ptI = curPoints[pointI];

                npc[ptI]++;
            }
        }


        // Size and fill cells per point

        pcPtr_ = new labelListList(npc.size());
        labelListList& pointCellAddr = *pcPtr_;

        forAll (pointCellAddr, pointI)
        {
            pointCellAddr[pointI].setSize(npc[pointI]);
        }
Ejemplo n.º 6
0
void Foam::h5Write::meshWritePoints()
{   
    Info<< "  meshWritePoints" << endl;
    
    const pointField& points = mesh_.points();
    
    
    // Find out how many points each process has
    List<label> nPoints(Pstream::nProcs());
    nPoints[Pstream::myProcNo()] = points.size();
    Pstream::gatherList(nPoints);
    Pstream::scatterList(nPoints);
    
    
    // Create the different datasets (needs to be done collectively)
    char datasetName[80];
    hsize_t dimsf[2];
    hid_t fileSpace;
    hid_t dsetID;
    hid_t plistID;
    
    forAll(nPoints, proc)
    {
        
        // Create the dataspace for the dataset
        dimsf[0] = nPoints[proc];
        dimsf[1] = 3;
        fileSpace = H5Screate_simple(2, dimsf, NULL);
        
        // Set property to create parent groups as neccesary
        plistID = H5Pcreate(H5P_LINK_CREATE);
        H5Pset_create_intermediate_group(plistID, 1);
        
        // Create the dataset for points
        sprintf
            (
                datasetName,
                "MESH/%s/processor%i/POINTS",
                mesh_.time().timeName().c_str(),
                proc
            );
        
        dsetID = H5Dcreate2
            (
                fileID_,
                datasetName,
                H5T_SCALAR,
                fileSpace,
                plistID,
                H5P_DEFAULT,
                H5P_DEFAULT
            );
        H5Dclose(dsetID);
        H5Pclose(plistID);
        H5Sclose(fileSpace);
    }
Ejemplo n.º 7
0
void CompositeDataset::print() const
{
    std::cout << "Composite dataset:" << std::endl;
    std::cout << "Name: " << getName() << std::endl;
    std::cout << "N points: " << nPoints() << std::endl;
    std::cout << "dataset includes:" << std::endl;
    std::list< Dataset* >::const_iterator itrDat;
    for ( itrDat = _datasets.begin(); itrDat != _datasets.end(); ++itrDat ) {
        (*itrDat)->print();
    }
}
Ejemplo n.º 8
0
XML_Node& Domain1D::save(XML_Node& o, const doublereal* const sol)
{
    XML_Node& d = o.addChild("domain");
    d.addAttribute("points", nPoints());
    d.addAttribute("components", nComponents());
    d.addAttribute("id", id());
    addFloatArray(d, "abstol_transient", nComponents(), &m_atol_ts[0]);
    addFloatArray(d, "reltol_transient", nComponents(), &m_rtol_ts[0]);
    addFloatArray(d, "abstol_steady", nComponents(), &m_atol_ss[0]);
    addFloatArray(d, "reltol_steady", nComponents(), &m_rtol_ss[0]);
    return d;
}
Ejemplo n.º 9
0
/*!
 * \brief Convolute this data with the supplied data, by products
 */
bool Data2D::convoluteProduct(Data2D& data)
{
	// Check compatibility of datasets
	if (data.nPoints() != nPoints())
	{
		msg.print("Refusing to convolute by product two datasets of different sizes.\n");
		return false;
	}
	for (int n=0; n<nPoints(); ++n)
	{
		if (fabs(data.x(n) - x_[n]) > 1.0e-5)
		{
			msg.print("Refusing to convolute by product two datasets with different x-values.\n");
			return false;
		}
	}

	// Ready to go...
	for (int n=0; n<nPoints(); ++n) y_[n] *= data.y(n);
	
	return true;
}
Ejemplo n.º 10
0
/*!
 * \brief Compute absolute integral of the data
 * \details Compute the absolute integral of the current data using the Trapezium method
 */
double Data2D::absIntegral()
{
	if (nPoints() < 2) return 0.0;
	double total = 0.0, y0 = y_.first(), y1, x0 = x_.first(), x1;
	for (int n=1; n<x_.nItems(); ++n)
	{
		x1 = x_[n];
		y1 = y_[n];
		total += fabs((x1 - x0) * (y0 + y1) * 0.5);
		x0 = x1;
		y0 = y1;
	}
	return total;
}
Ejemplo n.º 11
0
void GeoMapper::mapData()
{
	const std::vector<GeoLib::Point*> *points (this->_geo_objects.getPointVec(this->_geo_name));
	GeoLib::Station* stn_test = dynamic_cast<GeoLib::Station*>((*points)[0]);
	bool is_borehole(false);
	if (stn_test != nullptr && static_cast<GeoLib::StationBorehole*>((*points)[0])->type() == GeoLib::Station::StationType::BOREHOLE)
		is_borehole = true;
	
	double min_val(0), max_val(0);
	if (_mesh)
	{
		GeoLib::AABB<GeoLib::Point> bounding_box (_mesh->getNodes().begin(), _mesh->getNodes().end());
		min_val = bounding_box.getMinPoint()[2];
		max_val = bounding_box.getMaxPoint()[2];
	}
	size_t nPoints (points->size());

	if (!is_borehole)
	{
		for (unsigned j=0; j<nPoints; ++j)
		{
			GeoLib::Point* pnt ((*points)[j]);
			(*pnt)[2] = (_grid) ? this->getMeshElevation((*pnt)[0],(*pnt)[1], min_val, max_val)
				                : this->getDemElevation((*pnt)[0],(*pnt)[1]);
		}
	}
	else
	{
		for (unsigned j=0; j<nPoints; ++j)
		{
			GeoLib::Point* pnt ((*points)[j]);
			double offset = (_grid) ? (this->getMeshElevation((*pnt)[0],(*pnt)[1], min_val, max_val) - (*pnt)[2])
				                    : (this->getDemElevation((*pnt)[0],(*pnt)[1]) - (*pnt)[2]);

			GeoLib::StationBorehole* borehole = static_cast<GeoLib::StationBorehole*>(pnt);
			const std::vector<GeoLib::Point*> layers = borehole->getProfile();
			size_t nLayers = layers.size();
			for (unsigned k=0; k<nLayers; ++k)
			{
				GeoLib::Point* layer_pnt = layers[k];
				(*layer_pnt)[2] = (*layer_pnt)[2] + offset;
			}
		}
	}
}
void Foam::polyMesh::updateMesh(const mapPolyMesh& mpm)
{
    // Update zones.  Since boundary depends on zones, they need to be
    // updated first.  HJ, 20/May/2014
    pointZones_.updateMesh();
    faceZones_.updateMesh();
    cellZones_.updateMesh();

    // Update boundaryMesh (note that patches themselves are already ok)
    boundary_.updateMesh();

    // Clear out parallel data.  HJ, 27/Nov/2009
    deleteDemandDrivenData(globalMeshDataPtr_);

    setInstance(time().timeName());

    // Map the old motion points if present
    if (oldAllPointsPtr_)
    {
        // Make a copy of the original points
        pointField oldMotionPoints = *oldAllPointsPtr_;

        pointField& newMotionPoints = *oldAllPointsPtr_;

        // Resize the list to new size
        newMotionPoints.setSize(allPoints_.size());

        // Map the list
        newMotionPoints.map(oldMotionPoints, mpm.pointMap());

        // Reset old points if present
        if (oldPointsPtr_)
        {
            oldPointsPtr_->reset(*oldAllPointsPtr_, nPoints());
        }
    }

    // Reset valid directions (could change by faces put into empty patches)
    geometricD_ = Vector<label>::zero;
    solutionD_ = Vector<label>::zero;

    // Update all function objects
    // Moved from fvMesh.C in 1.6.x merge.  HJ, 29/Aug/2010
    meshObjectBase::allUpdateTopology<polyMesh>(*this, mpm);
}
Ejemplo n.º 13
0
void LinearEditDialog::setupDialog(const std::vector<size_t> &dis_nodes, const std::vector<double> &dis_values)
{
	size_t nPoints(_line.getNumberOfPoints());
	this->tableWidget->setRowCount(nPoints);
	QList<QString> indexlist;

	for (size_t i=0; i<nPoints; i++)
	{
		indexlist.push_back(QString::number(i));
		QTableWidgetItem *newItem = new QTableWidgetItem("");
		tableWidget->setItem(i, 0, newItem);
	}
	QStringList vHeaders(indexlist);
	tableWidget->setVerticalHeaderLabels(vHeaders);

	size_t nValues (dis_values.size());
	for (size_t i=0; i<nValues; i++)
		tableWidget->item(dis_nodes[i],0)->setText(QString::number(dis_values[i]));
}
Ejemplo n.º 14
0
void CCurve::Serialize(CArchive& ar)
{
    CElement::Serialize(ar);             // Call the base class function
    // Serialize the vector of points
    if (ar.IsStoring()) {
        ar << m_Points.size();             // Store the point count
        // Now store the points
        for (size_t i = 0 ; i < m_Points.size() ; ++i)
            ar << m_Points[i];
    } else {
        size_t nPoints(0);                 // Stores number of points
        ar >> nPoints;                     // Retrieve the number of points
        // Now retrieve the points
        CPoint point;
        for (size_t i = 0 ; i < nPoints ; ++i) {
            ar >> point;
            m_Points.push_back(point);
        }
    }
}
Ejemplo n.º 15
0
void GeoMapper::mapData(MeshLib::Mesh const*const mesh)
{
	const std::vector<GeoLib::Point*> *points (this->_geo_objects.getPointVec(this->_geo_name));
	GeoLib::Station* stn_test = dynamic_cast<GeoLib::Station*>((*points)[0]);
	bool is_borehole(false);
	if (stn_test != NULL && static_cast<GeoLib::StationBorehole*>((*points)[0])->type() == GeoLib::Station::BOREHOLE)
		is_borehole = true;
	size_t nPoints (points->size());

	if (!is_borehole)
	{
		for (unsigned j=0; j<nPoints; ++j)
		{
			GeoLib::Point* pnt ((*points)[j]);
			(*pnt)[2] = (_grid) ? this->getMeshElevation((*pnt)[0],(*pnt)[1], mesh)
				                : this->getDemElevation((*pnt)[0],(*pnt)[1]);
		}
	}
	else
	{
		for (unsigned j=0; j<nPoints; ++j)
		{
			GeoLib::Point* pnt ((*points)[j]);
			double offset = (_grid) ? (this->getMeshElevation((*pnt)[0],(*pnt)[1], mesh) - (*pnt)[2])
				                    : (this->getDemElevation((*pnt)[0],(*pnt)[1]) - (*pnt)[2]);

			GeoLib::StationBorehole* borehole = static_cast<GeoLib::StationBorehole*>(pnt);
			const std::vector<GeoLib::Point*> layers = borehole->getProfile();
			size_t nLayers = layers.size();
			for (unsigned k=0; k<nLayers; ++k)
			{
				GeoLib::Point* layer_pnt = layers[k];
				(*layer_pnt)[2] = (*layer_pnt)[2] + offset;
			}
		}
	}


}
Ejemplo n.º 16
0
GeoLib::Grid<GeoLib::PointWithID>* GeoMapper::getFlatGrid(MeshLib::Mesh const*const mesh, std::vector<GeoLib::PointWithID*> sfc_pnts) const
{
	if (mesh->getDimension()<3) //much faster
	{
		size_t nNodes (mesh->getNNodes());
		sfc_pnts.resize(nNodes);
		const std::vector<MeshLib::Node*> nodes (mesh->getNodes());
		for (unsigned i(0); i<nNodes; ++i)
			sfc_pnts[i] = new GeoLib::PointWithID(nodes[i]->getCoords(), nodes[i]->getID());
	}
	else
	{
		double dir[3] = {1,0,0};
		sfc_pnts = MeshLib::MshEditor::getSurfaceNodes(*mesh, dir);
	}
	size_t nPoints (sfc_pnts.size());
	for (unsigned i=0; i<nPoints; ++i)
	{
		GeoLib::PointWithID* pnt (sfc_pnts[i]);
		(*pnt)[2] = 0;
	}

	return new GeoLib::Grid<GeoLib::PointWithID>(sfc_pnts.begin(), sfc_pnts.end());
}
Ejemplo n.º 17
0
bool Foam::twoStrokeEngine::update()
{
    // Detaching the interface
    if (attached())
    {
        Info << "Decoupling sliding interfaces" << endl;
        makeSlidersLive();

        // Changing topology by hand
        autoPtr<mapPolyMesh> topoChangeMap5 = topoChanger_.changeMesh();

        if (topoChangeMap5->hasMotionPoints() && topoChangeMap5->morphing())
        {
            Info << "Topology change; executing pre-motion after "
                << "sliding detach" << endl;
            movePoints(topoChangeMap5->preMotionPoints());
        }

        Info << "sliding interfaces successfully decoupled!!!" << endl;
    }
    else
    {
        Info << "Sliding interfaces decoupled" << endl;
    }

    Info << "Executing layer action" << endl;

    // Piston Layering

    makeLayersLive();
    // Changing topology by hand


// /* Tommaso, 23/5/2008

    // Find piston mesh modifier
    const label pistonLayerID =
        topoChanger_.findModifierID("pistonLayer");

    if (pistonLayerID < 0)
    {
        FatalErrorIn("void engineFvMesh::moveAndMorph()")
            << "Piston modifier not found."
            << abort(FatalError);
    }

    scalar minLayerThickness = piston().minLayer();
    scalar deltaZ = engTime().pistonDisplacement().value();
    virtualPistonPosition() += deltaZ;

    Info << "virtualPistonPosition = " << virtualPistonPosition()
    << ", deckHeight = " << deckHeight()
    << ", pistonPosition = " << pistonPosition() << endl;

    if (realDeformation())
    {
        // Dectivate piston layer
        Info << "Mesh deformation mode" << endl;
        topoChanger_[pistonLayerID].disable();
    }
    else
    {
        // Activate piston layer
        Info << "Piston layering mode" << endl;
        topoChanger_[pistonLayerID].enable();
    }


    // Changing topology by hand
    autoPtr<mapPolyMesh> topoChangeMap = topoChanger_.changeMesh();

    // Work array for new points position.
    pointField newPoints = allPoints();
    const pointField& refPoints = allPoints();

    if (topoChangeMap->morphing())
    {
        if (topoChangeMap->hasMotionPoints())
        {
            Info<< "Topology change; executing pre-motion after "
                << "dynamic layering" << endl;
            movePoints(topoChangeMap->preMotionPoints());
            newPoints = topoChangeMap->preMotionPoints();
        }

        setV0();
        resetMotion();
    }

    // Reset the position of layered interfaces

    boolList scaleDisp(nPoints(), true);

    boolList pistonPoint(newPoints.size(), false);
    boolList headPoint(newPoints.size(), false);

    // Make a list of piston and head points. HJ, 2/Dec/2009

    labelList pistonPoints;
    labelList headPoints;
    {
        label pistonCellIndex = cellZones().findZoneID("pistonCells");

        if (pistonCellIndex < 0)
        {
            FatalErrorIn("bool twoStrokeEngine::update()")
                << "Cannot find cell zone pistonCells"
                << abort(FatalError);
        }


        const labelList& pistonCells = cellZones()[pistonCellIndex];

        label headCellIndex = cellZones().findZoneID("headCells");

        if (headCellIndex < 0)
        {
            FatalErrorIn("bool twoStrokeEngine::update()")
                << "Cannot find cell zone headCells"
                << abort(FatalError);
        }

        const labelList& headCells = cellZones()[headCellIndex];

        const labelListList& cp = cellPoints();

        boolList count(newPoints.size(), false);

        forAll (pistonCells, cellI)
        {
            const labelList& curCellPoints = cp[pistonCells[cellI]];

            forAll (curCellPoints, i)
            {
                count[curCellPoints[i]] = true;
            }
        }

        // Count the points
        label nCounted = 0;
        forAll (count, pointI)
        {
            if (count[pointI] == true)
            {
                nCounted++;
            }
        }

        pistonPoints.setSize(nCounted);

        // Collect the points
        nCounted = 0;
        forAll (count, pointI)
        {
            if (count[pointI] == true)
            {
                pistonPoints[nCounted] = pointI;
                nCounted++;
            }
        }

        // Repeat for head points
        count = false;

        forAll (headCells, cellI)
        {
            const labelList& curCellPoints = cp[pistonCells[cellI]];

            forAll (curCellPoints, i)
            {
                count[curCellPoints[i]] = true;
            }
        }

        // Count the points
        nCounted = 0;
        forAll (count, pointI)
        {
            if (count[pointI] == true)
            {
                nCounted++;
            }
        }

        headPoints.setSize(nCounted);

        // Collect the points
        nCounted = 0;
        forAll (count, pointI)
        {
            if (count[pointI] == true)
            {
                headPoints[nCounted] = pointI;
                nCounted++;
            }
        }
    }


    label nScaled = nPoints();

//     label pistonPtsIndex = pointZones().findZoneID("pistonPoints");
//     const labelList& pistonPoints = pointZones()[pistonPtsIndex];

//     label headPtsIndex = pointZones().findZoneID("headPoints");
//     const labelList& headPoints = pointZones()[headPtsIndex];

    const scalarField& movingPointsM = movingPointsMask();

    forAll(pistonPoints, i)
    {
        label pointI = pistonPoints[i];
        pistonPoint[pointI] = true;
        point& p = newPoints[pointI];

        if (p.z() < pistonPosition() - 1.0e-6)
        {
            scaleDisp[pointI] = false;
            nScaled--;
        }
    }
Ejemplo n.º 18
0
AABB::AABB(const std::vector<GEOLIB::Point*>* points)
{
	size_t nPoints(points->size());
	for (size_t i = 0; i < nPoints; i++)
		this->update((*(*points)[i])[0], (*(*points)[i])[1], (*(*points)[i])[2]);
}
Ejemplo n.º 19
0
void Foam::block::createPoints() const
{
    // set local variables for mesh specification
    const label ni = meshDensity().x();
    const label nj = meshDensity().y();
    const label nk = meshDensity().z();

    const point& p000 = blockPoint(0);
    const point& p100 = blockPoint(1);
    const point& p110 = blockPoint(2);
    const point& p010 = blockPoint(3);

    const point& p001 = blockPoint(4);
    const point& p101 = blockPoint(5);
    const point& p111 = blockPoint(6);
    const point& p011 = blockPoint(7);


    // list of edge point and weighting factors
    const List< List<point> >& p = blockEdgePoints();
    const scalarListList& w = blockEdgeWeights();

    //
    // generate vertices
    //
    vertices_.clear();
    vertices_.setSize(nPoints());

    for (label k = 0; k <= nk; k++)
    {
        for (label j = 0; j <= nj; j++)
        {
            for (label i = 0; i <= ni; i++)
            {
                const label vertexNo = vtxLabel(i, j, k);

                // points on edges
                vector edgex1 = p000 + (p100 - p000)*w[0][i];
                vector edgex2 = p010 + (p110 - p010)*w[1][i];
                vector edgex3 = p011 + (p111 - p011)*w[2][i];
                vector edgex4 = p001 + (p101 - p001)*w[3][i];

                vector edgey1 = p000 + (p010 - p000)*w[4][j];
                vector edgey2 = p100 + (p110 - p100)*w[5][j];
                vector edgey3 = p101 + (p111 - p101)*w[6][j];
                vector edgey4 = p001 + (p011 - p001)*w[7][j];

                vector edgez1 = p000 + (p001 - p000)*w[8][k];
                vector edgez2 = p100 + (p101 - p100)*w[9][k];
                vector edgez3 = p110 + (p111 - p110)*w[10][k];
                vector edgez4 = p010 + (p011 - p010)*w[11][k];


                // calculate the importance factors for all edges

                // x-direction
                scalar impx1 =
                (
                    (1.0 - w[0][i])*(1.0 - w[4][j])*(1.0 - w[8][k])
                  + w[0][i]*(1.0 - w[5][j])*(1.0 - w[9][k])
                );

                scalar impx2 =
                (
                    (1.0 - w[1][i])*w[4][j]*(1.0 - w[11][k])
                  + w[1][i]*w[5][j]*(1.0 - w[10][k])
                );

                scalar impx3 =
                (
                     (1.0 - w[2][i])*w[7][j]*w[11][k]
                   + w[2][i]*w[6][j]*w[10][k]
                );

                scalar impx4 =
                (
                    (1.0 - w[3][i])*(1.0 - w[7][j])*w[8][k]
                  + w[3][i]*(1.0 - w[6][j])*w[9][k]
                );

                scalar magImpx = impx1 + impx2 + impx3 + impx4;
                impx1 /= magImpx;
                impx2 /= magImpx;
                impx3 /= magImpx;
                impx4 /= magImpx;


                // y-direction
                scalar impy1 =
                (
                    (1.0 - w[4][j])*(1.0 - w[0][i])*(1.0 - w[8][k])
                  + w[4][j]*(1.0 - w[1][i])*(1.0 - w[11][k])
                );

                scalar impy2 =
                (
                    (1.0 - w[5][j])*w[0][i]*(1.0 - w[9][k])
                  + w[5][j]*w[1][i]*(1.0 - w[10][k])
                );

                scalar impy3 =
                (
                    (1.0 - w[6][j])*w[3][i]*w[9][k]
                  + w[6][j]*w[2][i]*w[10][k]
                );

                scalar impy4 =
                (
                    (1.0 - w[7][j])*(1.0 - w[3][i])*w[8][k]
                  + w[7][j]*(1.0 - w[2][i])*w[11][k]
                );

                scalar magImpy = impy1 + impy2 + impy3 + impy4;
                impy1 /= magImpy;
                impy2 /= magImpy;
                impy3 /= magImpy;
                impy4 /= magImpy;


                // z-direction
                scalar impz1 =
                (
                    (1.0 - w[8][k])*(1.0 - w[0][i])*(1.0 - w[4][j])
                  + w[8][k]*(1.0 - w[3][i])*(1.0 - w[7][j])
                );

                scalar impz2 =
                (
                    (1.0 - w[9][k])*w[0][i]*(1.0 - w[5][j])
                  + w[9][k]*w[3][i]*(1.0 - w[6][j])
                );

                scalar impz3 =
                (
                    (1.0 - w[10][k])*w[1][i]*w[5][j]
                  + w[10][k]*w[2][i]*w[6][j]
                );

                scalar impz4 =
                (
                    (1.0 - w[11][k])*(1.0 - w[1][i])*w[4][j]
                  + w[11][k]*(1.0 - w[2][i])*w[7][j]
                );

                scalar magImpz = impz1 + impz2 + impz3 + impz4;
                impz1 /= magImpz;
                impz2 /= magImpz;
                impz3 /= magImpz;
                impz4 /= magImpz;


                // calculate the correction vectors
                vector corx1 = impx1*(p[0][i] - edgex1);
                vector corx2 = impx2*(p[1][i] - edgex2);
                vector corx3 = impx3*(p[2][i] - edgex3);
                vector corx4 = impx4*(p[3][i] - edgex4);

                vector cory1 = impy1*(p[4][j] - edgey1);
                vector cory2 = impy2*(p[5][j] - edgey2);
                vector cory3 = impy3*(p[6][j] - edgey3);
                vector cory4 = impy4*(p[7][j] - edgey4);

                vector corz1 = impz1*(p[8][k] - edgez1);
                vector corz2 = impz2*(p[9][k] - edgez2);
                vector corz3 = impz3*(p[10][k] - edgez3);
                vector corz4 = impz4*(p[11][k] - edgez4);


                // multiply by the importance factor

                // x-direction
                edgex1 *= impx1;
                edgex2 *= impx2;
                edgex3 *= impx3;
                edgex4 *= impx4;

                // y-direction
                edgey1 *= impy1;
                edgey2 *= impy2;
                edgey3 *= impy3;
                edgey4 *= impy4;

                // z-direction
                edgez1 *= impz1;
                edgez2 *= impz2;
                edgez3 *= impz3;
                edgez4 *= impz4;


                // add the contributions
                vertices_[vertexNo] =
                (
                    edgex1 + edgex2 + edgex3 + edgex4
                  + edgey1 + edgey2 + edgey3 + edgey4
                  + edgez1 + edgez2 + edgez3 + edgez4
                ) / 3.0;

                vertices_[vertexNo] +=
                (
                    corx1 + corx2 + corx3 + corx4
                  + cory1 + cory2 + cory3 + cory4
                  + corz1 + corz2 + corz3 + corz4
                );
            }
        }
    }
}
Ejemplo n.º 20
0
        nCells = max(nCells, neighbour_[facei]);
    }

    nCells++;

    // Reset the primitiveMesh with the sizes of the primitive arrays
    primitiveMesh::reset
    (
        points_.size(),
        neighbour_.size(),
        owner_.size(),
        nCells
    );

    string meshInfo =
        "nPoints:" + Foam::name(nPoints())
      + "  nCells:" + Foam::name(this->nCells())
      + "  nFaces:" + Foam::name(nFaces())
      + "  nInternalFaces:" + Foam::name(nInternalFaces());

    owner_.note() = meshInfo;
    neighbour_.note() = meshInfo;
}


void Foam::polyMesh::initMesh(cellList& c)
{
    if (debug)
    {
        Info<< "void polyMesh::initMesh(cellList& c) : "
            << "calculating owner-neighbour arrays" << endl;
Ejemplo n.º 21
0
void Foam::block::createPoints()
{
    // Set local variables for mesh specification
    const label ni = density().x();
    const label nj = density().y();
    const label nk = density().z();

    const point& p000 = blockPoint(0);
    const point& p100 = blockPoint(1);
    const point& p110 = blockPoint(2);
    const point& p010 = blockPoint(3);

    const point& p001 = blockPoint(4);
    const point& p101 = blockPoint(5);
    const point& p111 = blockPoint(6);
    const point& p011 = blockPoint(7);

    // List of edge point and weighting factors
    pointField p[12];
    scalarList w[12];
    label nCurvedEdges = edgesPointsWeights(p, w);

    points_.setSize(nPoints());

    points_[pointLabel(0,  0,  0)] = p000;
    points_[pointLabel(ni, 0,  0)] = p100;
    points_[pointLabel(ni, nj, 0)] = p110;
    points_[pointLabel(0,  nj, 0)] = p010;
    points_[pointLabel(0,  0,  nk)] = p001;
    points_[pointLabel(ni, 0,  nk)] = p101;
    points_[pointLabel(ni, nj, nk)] = p111;
    points_[pointLabel(0,  nj, nk)] = p011;

    for (label k=0; k<=nk; k++)
    {
        for (label j=0; j<=nj; j++)
        {
            for (label i=0; i<=ni; i++)
            {
                // Skip block vertices
                if (vertex(i, j, k)) continue;

                const label vijk = pointLabel(i, j, k);

                // Calculate the weighting factors for all edges

                // x-direction
                scalar wx1 = (1 - w0)*(1 - w4)*(1 - w8) + w0*(1 - w5)*(1 - w9);
                scalar wx2 = (1 - w1)*w4*(1 - w11)      + w1*w5*(1 - w10);
                scalar wx3 = (1 - w2)*w7*w11            + w2*w6*w10;
                scalar wx4 = (1 - w3)*(1 - w7)*w8       + w3*(1 - w6)*w9;

                const scalar sumWx = wx1 + wx2 + wx3 + wx4;
                wx1 /= sumWx;
                wx2 /= sumWx;
                wx3 /= sumWx;
                wx4 /= sumWx;


                // y-direction
                scalar wy1 = (1 - w4)*(1 - w0)*(1 - w8) + w4*(1 - w1)*(1 - w11);
                scalar wy2 = (1 - w5)*w0*(1 - w9)       + w5*w1*(1 - w10);
                scalar wy3 = (1 - w6)*w3*w9             + w6*w2*w10;
                scalar wy4 = (1 - w7)*(1 - w3)*w8       + w7*(1 - w2)*w11;

                const scalar sumWy = wy1 + wy2 + wy3 + wy4;
                wy1 /= sumWy;
                wy2 /= sumWy;
                wy3 /= sumWy;
                wy4 /= sumWy;


                // z-direction
                scalar wz1 = (1 - w8)*(1 - w0)*(1 - w4) + w8*(1 - w3)*(1 - w7);
                scalar wz2 = (1 - w9)*w0*(1 - w5)       + w9*w3*(1 - w6);
                scalar wz3 = (1 - w10)*w1*w5            + w10*w2*w6;
                scalar wz4 = (1 - w11)*(1 - w1)*w4      + w11*(1 - w2)*w7;

                const scalar sumWz = wz1 + wz2 + wz3 + wz4;
                wz1 /= sumWz;
                wz2 /= sumWz;
                wz3 /= sumWz;
                wz4 /= sumWz;


                // Points on straight edges
                const vector edgex1 = p000 + (p100 - p000)*w0;
                const vector edgex2 = p010 + (p110 - p010)*w1;
                const vector edgex3 = p011 + (p111 - p011)*w2;
                const vector edgex4 = p001 + (p101 - p001)*w3;

                const vector edgey1 = p000 + (p010 - p000)*w4;
                const vector edgey2 = p100 + (p110 - p100)*w5;
                const vector edgey3 = p101 + (p111 - p101)*w6;
                const vector edgey4 = p001 + (p011 - p001)*w7;

                const vector edgez1 = p000 + (p001 - p000)*w8;
                const vector edgez2 = p100 + (p101 - p100)*w9;
                const vector edgez3 = p110 + (p111 - p110)*w10;
                const vector edgez4 = p010 + (p011 - p010)*w11;

                // Add the contributions
                points_[vijk] =
                (
                    wx1*edgex1 + wx2*edgex2 + wx3*edgex3 + wx4*edgex4
                  + wy1*edgey1 + wy2*edgey2 + wy3*edgey3 + wy4*edgey4
                  + wz1*edgez1 + wz2*edgez2 + wz3*edgez3 + wz4*edgez4
                )/3;


                // Apply curved-edge correction if block has curved edges
                if (nCurvedEdges)
                {
                    // Calculate the correction vectors
                    const vector corx1 = wx1*(p[0][i] - edgex1);
                    const vector corx2 = wx2*(p[1][i] - edgex2);
                    const vector corx3 = wx3*(p[2][i] - edgex3);
                    const vector corx4 = wx4*(p[3][i] - edgex4);

                    const vector cory1 = wy1*(p[4][j] - edgey1);
                    const vector cory2 = wy2*(p[5][j] - edgey2);
                    const vector cory3 = wy3*(p[6][j] - edgey3);
                    const vector cory4 = wy4*(p[7][j] - edgey4);

                    const vector corz1 = wz1*(p[8][k] - edgez1);
                    const vector corz2 = wz2*(p[9][k] - edgez2);
                    const vector corz3 = wz3*(p[10][k] - edgez3);
                    const vector corz4 = wz4*(p[11][k] - edgez4);

                    points_[vijk] +=
                    (
                        corx1 + corx2 + corx3 + corx4
                      + cory1 + cory2 + cory3 + cory4
                      + corz1 + corz2 + corz3 + corz4
                    );
                }
            }
        }
    }

    if (!nCurvedFaces()) return;

    // Apply curvature correction to face points
    FixedList<pointField, 6> facePoints(this->facePoints(points_));
    correctFacePoints(facePoints);

    // Loop over points and apply the correction from the from the i-faces
    for (label ii=0; ii<=ni; ii++)
    {
        // Process the points on the curved faces last
        label i = (ii + 1)%(ni + 1);

        for (label j=0; j<=nj; j++)
        {
            for (label k=0; k<=nk; k++)
            {
                // Skip non-curved faces and edges
                if (flatFaceOrEdge(i, j, k)) continue;

                const label vijk = pointLabel(i, j, k);

                scalar wf0 =
                (
                    (1 - w0)*(1 - w4)*(1 - w8)
                  + (1 - w1)*w4*(1 - w11)
                  + (1 - w2)*w7*w11
                  + (1 - w3)*(1 - w7)*w8
                );

                scalar wf1 =
                (
                    w0*(1 - w5)*(1 - w9)
                  + w1*w5*(1 - w10)
                  + w2*w5*w10
                  + w3*(1 - w6)*w9
                );

                const scalar sumWf = wf0 + wf1;
                wf0 /= sumWf;
                wf1 /= sumWf;

                points_[vijk] +=
                (
                    wf0
                   *(
                       facePoints[0][facePointLabel(0, j, k)]
                     - points_[pointLabel(0, j, k)]
                    )
                  + wf1
                   *(
                       facePoints[1][facePointLabel(1, j, k)]
                     - points_[pointLabel(ni, j, k)]
                    )
                );
            }
        }
    }

    // Loop over points and apply the correction from the from the j-faces
    for (label jj=0; jj<=nj; jj++)
    {
        // Process the points on the curved faces last
        label j = (jj + 1)%(nj + 1);

        for (label i=0; i<=ni; i++)
        {
            for (label k=0; k<=nk; k++)
            {
                // Skip flat faces and edges
                if (flatFaceOrEdge(i, j, k)) continue;

                const label vijk = pointLabel(i, j, k);

                scalar wf2 =
                (
                    (1 - w4)*(1 - w1)*(1 - w8)
                  + (1 - w5)*w0*(1 - w9)
                  + (1 - w6)*w3*w9
                  + (1 - w7)*(1 - w3)*w8
                );

                scalar wf3 =
                (
                    w4*(1 - w1)*(1 - w11)
                  + w5*w1*(1 - w10)
                  + w6*w2*w10
                  + w7*(1 - w2)*w11
                );

                const scalar sumWf = wf2 + wf3;
                wf2 /= sumWf;
                wf3 /= sumWf;

                points_[vijk] +=
                (
                    wf2
                   *(
                       facePoints[2][facePointLabel(2, i, k)]
                     - points_[pointLabel(i, 0, k)]
                    )
                  + wf3
                   *(
                       facePoints[3][facePointLabel(3, i, k)]
                     - points_[pointLabel(i, nj, k)]
                    )
                );
            }
        }
    }

    // Loop over points and apply the correction from the from the k-faces
    for (label kk=0; kk<=nk; kk++)
    {
        // Process the points on the curved faces last
        label k = (kk + 1)%(nk + 1);

        for (label i=0; i<=ni; i++)
        {
            for (label j=0; j<=nj; j++)
            {
                // Skip flat faces and edges
                if (flatFaceOrEdge(i, j, k)) continue;

                const label vijk = pointLabel(i, j, k);

                scalar wf4 =
                (
                    (1 - w8)*(1 - w0)*(1 - w4)
                  + (1 - w9)*w0*(1 - w5)
                  + (1 - w10)*w1*w5
                  + (1 - w11)*(1 - w1)*w4
                );

                scalar wf5 =
                (
                    w8*(1 - w3)*(1 - w7)
                  + w9*w3*(1 - w6)
                  + w10*w2*w6
                  + w11*(1 - w2)*w7
                );

                const scalar sumWf = wf4 + wf5;
                wf4 /= sumWf;
                wf5 /= sumWf;

                points_[vijk] +=
                (
                    wf4
                   *(
                       facePoints[4][facePointLabel(4, i, j)]
                     - points_[pointLabel(i, j, 0)]
                    )
                  + wf5
                   *(
                       facePoints[5][facePointLabel(5, i, j)]
                     - points_[pointLabel(i, j, nk)]
                    )
                );
            }
        }
    }
}
Foam::multiSolidBodyMotionFvMesh::multiSolidBodyMotionFvMesh(const IOobject& io)
:
    dynamicFvMesh(io),
    dynamicMeshCoeffs_
    (
        IOdictionary
        (
            IOobject
            (
                "dynamicMeshDict",
                io.time().constant(),
                *this,
                IOobject::MUST_READ_IF_MODIFIED,
                IOobject::NO_WRITE,
                false
            )
        ).subDict(typeName + "Coeffs")
    ),
    undisplacedPoints_
    (
        IOobject
        (
            "points",
            io.time().constant(),
            meshSubDir,
            *this,
            IOobject::MUST_READ,
            IOobject::NO_WRITE,
            false
        )
    )
{
    if (undisplacedPoints_.size() != nPoints())
    {
        FatalIOErrorInFunction
        (
            dynamicMeshCoeffs_
        )   << "Read " << undisplacedPoints_.size()
            << " undisplaced points from " << undisplacedPoints_.objectPath()
            << " but the current mesh has " << nPoints()
            << exit(FatalIOError);
    }


    zoneIDs_.setSize(dynamicMeshCoeffs_.size());
    SBMFs_.setSize(dynamicMeshCoeffs_.size());
    pointIDs_.setSize(dynamicMeshCoeffs_.size());
    label zoneI = 0;

    forAllConstIter(dictionary, dynamicMeshCoeffs_, iter)
    {
        if (iter().isDict())
        {
            zoneIDs_[zoneI] = cellZones().findZoneID(iter().keyword());

            if (zoneIDs_[zoneI] == -1)
            {
                FatalIOErrorInFunction
                (
                    dynamicMeshCoeffs_
                )   << "Cannot find cellZone named " << iter().keyword()
                    << ". Valid zones are " << cellZones().names()
                    << exit(FatalIOError);
            }

            const dictionary& subDict = iter().dict();

            SBMFs_.set
            (
                zoneI,
                solidBodyMotionFunction::New(subDict, io.time())
            );

            // Collect points of cell zone.
            const cellZone& cz = cellZones()[zoneIDs_[zoneI]];

            boolList movePts(nPoints(), false);

            forAll(cz, i)
            {
                label celli = cz[i];
                const cell& c = cells()[celli];
                forAll(c, j)
                {
                    const face& f = faces()[c[j]];
                    forAll(f, k)
                    {
                        label pointi = f[k];
                        movePts[pointi] = true;
                    }
                }
            }
Ejemplo n.º 23
0
Polyline* Polyline::constructPolylineFromSegments(const std::vector<Polyline*>& ply_vec, double prox)
{
	size_t nLines = ply_vec.size();

	Polyline* new_ply = new Polyline(*ply_vec[0]);
	std::vector<GEOLIB::Point*> pnt_vec(new_ply->getPointsVec());

	std::vector<Polyline*> local_ply_vec;
	for (size_t i = 1; i < nLines; i++)
		local_ply_vec.push_back(ply_vec[i]);

	while (!local_ply_vec.empty())
	{
		bool ply_found(false);
		prox *= prox; // square distance once to save time later
		for (std::vector<Polyline*>::iterator it = local_ply_vec.begin(); it != local_ply_vec.end(); ++it)
		{
			if (pnt_vec == (*it)->getPointsVec())
			{
				size_t nPoints((*it)->getNumberOfPoints());

				// if (new_ply->getPointID(0) == (*it)->getPointID(0))
				if (pointsAreIdentical(pnt_vec, new_ply->getPointID(0), (*it)->getPointID(0), prox))
				{
					Polyline* tmp = new Polyline((*it)->getPointsVec());
					for (size_t k = 0; k < nPoints; k++)
						tmp->addPoint((*it)->getPointID(nPoints - k - 1));

					size_t new_ply_size(new_ply->getNumberOfPoints());
					for (size_t k = 1; k < new_ply_size; k++)
						tmp->addPoint(new_ply->getPointID(k));
					delete new_ply;
					new_ply = tmp;
					ply_found = true;
				}
				// else if (new_ply->getPointID(0) == (*it)->getPointID(nPoints-1))
				else if (pointsAreIdentical(pnt_vec, new_ply->getPointID(0), (*it)->getPointID(nPoints - 1), prox))
				{
					Polyline* tmp = new Polyline(**it);
					size_t new_ply_size(new_ply->getNumberOfPoints());
					for (size_t k = 1; k < new_ply_size; k++)
						tmp->addPoint(new_ply->getPointID(k));
					delete new_ply;
					new_ply = tmp;
					ply_found = true;
				}
				// else if (new_ply->getPointID(new_ply->getNumberOfPoints()-1) == (*it)->getPointID(0))
				else if (pointsAreIdentical(pnt_vec, new_ply->getPointID(new_ply->getNumberOfPoints() - 1),
				                            (*it)->getPointID(0), prox))
				{
					for (size_t k = 1; k < nPoints; k++)
						new_ply->addPoint((*it)->getPointID(k));
					ply_found = true;
				}
				// else if (new_ply->getPointID(new_ply->getNumberOfPoints()-1) == (*it)->getPointID(nPoints-1))
				else if (pointsAreIdentical(pnt_vec, new_ply->getPointID(new_ply->getNumberOfPoints() - 1),
				                            (*it)->getPointID(nPoints - 1), prox))
				{
					for (size_t k = 1; k < nPoints; k++)
						new_ply->addPoint((*it)->getPointID(nPoints - k - 1));
					ply_found = true;
				}
				if (ply_found)
				{
					local_ply_vec.erase(it);
					break;
				}
			}
			else
				std::cout << "Error in Polyline::contructPolylineFromSegments() - Line segments use different point "
				             "vectors..."
				          << "\n";
		}

		if (!ply_found)
		{
			std::cout << "Error in Polyline::contructPolylineFromSegments() - Not all segments are connected..."
			          << "\n";
			new_ply = NULL;
			break;
		}
	}
	return new_ply;
}
Ejemplo n.º 24
0
    void toPython()
    {
        RefElem RefConv;

        std::ostringstream ostr;

        ostr << getName() << "_" << getPointsInfo() << ".py";

        std::ofstream ofs( ostr.str().c_str() );

        ofs << "from pyx import *\n";

        ofs << "p=path.path(";

        for ( uint16_type i = 0; i < Convex::numEdges; ++i )
        {
            for ( uint16_type  j = 0; j < 2; ++j )
            {
                node_type x( 2 );

                if ( Convex::nRealDim == 1 )
                {
                    x( 0 ) = RefConv.edgeVertex( i,j )( 0 );
                    x( 1 ) = value_type( 0 );
                }

                if ( Convex::nRealDim == 2 )
                {
                    x = RefConv.edgeVertex( i, j );
                }

                if ( Convex::nRealDim == 3 )
                {
                    x( 0 ) = RefConv.edgeVertex( i, j )( 0 )+RefConv.edgeVertex( i, j )( 1 )*std::cos( M_PI/4 );
                    x( 1 ) = RefConv.edgeVertex( i, j )( 2 )+RefConv.edgeVertex( i, j )( 1 )*std::sin( M_PI/4 );
                }

                if ( j == 0 )
                    ofs << "path.moveto(" << double( x( 0 ) )<< "," << double( x( 1 ) ) << "),\n";

                else if ( j == 1 )
                    ofs << "path.lineto(" << double( x( 0 ) )<< "," << double( x( 1 ) ) << "),\n";
            }
        }

        ofs << "path.closepath() )\n";

        ofs << "text.set(mode=\"latex\")\n"
            << "c = canvas.canvas()\n"
            << "c.stroke(p, [style.linewidth.Thin])\n";

        for ( uint16_type i = 0; i < nPoints(); ++i )
        {
            node_type x( 2 );

            if ( Convex::nRealDim == 1 )
            {
                x( 0 ) = this->point( i )( 0 );
                x( 1 ) = value_type( 0 );
            }

            if ( Convex::nRealDim == 2 )
            {
                x = this->point( i );
            }

            if ( Convex::nRealDim == 3 )
            {
                x( 0 ) = this->point( i )( 0 ) + this->point( i )( 1 )*std::cos( M_PI/4 );
                x( 1 ) = this->point( i )( 2 ) + this->point( i )( 1 )*std::sin( M_PI/4 );
            }


            ofs << "c.fill ( path.circle(" << double( x( 0 ) ) << "," << double( x( 1 ) )<< ", 0.02 ),[deco.filled([color.rgb.red])])\n";
            ofs << "c.text( " << double( x( 0 )+0.025 ) << "," << double( x( 1 )+0.025 )<< ", r\"{\\scriptsize " << i << "}\")\n";
        }

        ofs << "c.writeEPSfile(\"" << getName() << "_" << getPointsInfo()
            << "\", document.paperformat.A4)\n";
    }
Ejemplo n.º 25
0
    {
        nonGlobalPatchPointsPtr_ = new labelList(nPoints());
        labelList& ngpp = *nonGlobalPatchPointsPtr_;
        forAll(ngpp, i)
        {
            ngpp[i] = i;
        }
    }
    else
    {

        // Get reference to shared points
        const labelList& sharedPoints =
            boundaryMesh().mesh()().globalData().sharedPointLabels();

        nonGlobalPatchPointsPtr_ = new labelList(nPoints());
        labelList& ngpp = *nonGlobalPatchPointsPtr_;

        const labelList& faMeshPatchPoints = pointLabels();

        const labelList& meshPoints = 
            boundaryMesh().mesh().patch().meshPoints();

        label noFiltPoints = 0;

        forAll (faMeshPatchPoints, pointI)
        {
            label curP = meshPoints[faMeshPatchPoints[pointI]];

            bool found = false;
Ejemplo n.º 26
0
int main()
{
  typedef double                            scalar_type; 
  typedef numeric::vector     <scalar_type> vector_type;
  typedef numeric::matrix     <scalar_type> matrix_type;
  
  typedef scalar_type (*function_type            )( vector_type const & );
  typedef vector_type (*function_grad_type       )( vector_type const & );
  typedef matrix_type (*function_inv_hessian_type)( vector_type const & );
  typedef scalar_type (*scalar_norm_type  )( scalar_type );
  typedef scalar_type (*vector_norm_type  )( numeric::ublas::vector_expression<vector_type> const & );
  
  typedef numeric::barrier_method::PointDebugInfo<scalar_type> points_debug_info_type;
    
  function_type             const f                  = &function::function<vector_type>;
  function_grad_type        const df                 = &function::functionGrad<vector_type>;
  scalar_type               const preferredPrecision = function::preferredPrecision;
  scalar_norm_type          const sNorm              = &xmath::abs<scalar_type>;
  vector_norm_type          const vNorm              = &numeric::ublas::norm_2<vector_type>;

  vector_type startPoint(2);
  startPoint(0) = function::startX;
  startPoint(1) = function::startY;
  
  scalar_type const startMu = function::startMu;
  scalar_type const beta    = function::beta;
  
  std::vector<function_type>      constraints;
  std::vector<function_grad_type> constraintsGrads;
  
  constraints.     push_back(&function::limitFunc1<scalar_type>);
  constraints.     push_back(&function::limitFunc2<scalar_type>);
  constraintsGrads.push_back(&function::limitFuncGrad1<scalar_type>);
  constraintsGrads.push_back(&function::limitFuncGrad2<scalar_type>);

  // TODO: Separate this constants.
  scalar_type               const gradientDescentPrecision = 1e-8;
  scalar_type               const gradientDescentStep      = 1.0;
  
  {
    // 
    // Calculating Lipschitz constant.
    //
    
    vector_type x(2);
    x(0) = function::loLipschitzX;
    x(1) = function::loLipschitzY;

    vector_type y(2);
    y(0) = function::hiLipschitzX;
    y(1) = function::hiLipschitzY;
    
    vector_type step(2);
    step(0) = function::lipschitzStepX;
    step(1) = function::lipschitzStepY;

    scalar_type const R = 
        numeric::lipschitz_constant<function_type, scalar_type, scalar_norm_type, vector_type, vector_norm_type>(
            f, sNorm, x, y, vNorm, step);
    
    {
      // Saving Lipschitz constant.
      char const *dataFileName = "../output/lipschitz_const.tex";
      boost::scoped_ptr<std::ofstream> ofs(new std::ofstream(dataFileName));
      if (ofs->fail())
      {
        std::cerr << "Failed to open data file '" << dataFileName << "'.\n";
        return 1;
      }
      
      *ofs << boost::format("%1$15.8f") % R;
    }
  }

  {
    //
    // Barrier method.
    //
    
    std::vector<points_debug_info_type> points;
    
    vector_type const xMin = numeric::barrier_method::find_min
                                 <function_type, function_grad_type, scalar_type>(
                                    f, df, 
                                    constraints.begin(),      constraints.end(), 
                                    constraintsGrads.begin(), constraintsGrads.end(),
                                    startPoint, 
                                    startMu, beta,
                                    preferredPrecision, 
                                    gradientDescentPrecision, gradientDescentStep, std::back_inserter(points));
    
    {
      // Saving passed spots.
      char const *dataFileName = "../output/ne_points.dat"; // TODO: Correct file name.
      boost::scoped_ptr<std::ofstream> ofs(new std::ofstream(dataFileName));
      if (ofs->fail())
      {
        std::cerr << "Failed to open data file '" << dataFileName << "'.\n";
        return 1;
      }
      
      for (size_t i = 0; i < points.size(); ++i)
      {
        points_debug_info_type const &pdi = points[i];
        
        numeric::output_vector_coordinates<std::ofstream, vector_type>(*ofs, pdi.x, " ", "\n", "%1$15.8f");
      }
    }
    
    {
      // Saving detail report.
      char const *dataFileName = "../output/bm_points.tex";
      boost::scoped_ptr<std::ofstream> ofs(new std::ofstream(dataFileName));
      if (ofs->fail())
      {
        std::cerr << "Failed to open data file '" << dataFileName << "'.\n";
        return 1;
      }
      
      for (size_t i = 0; i < points.size(); ++i)
      {
        points_debug_info_type const &pdi = points[i];
        
        *ofs << i + 1 << " & ";
        // TODO: There is space between brackets and numbers!
        *ofs << "( "; numeric::output_vector_coordinates(*ofs, pdi.x, ", ", "", "%1$15.8f"); *ofs << " ) & ";
        *ofs << boost::format("%1$15.8f") % (pdi.fx) << " & ";
        *ofs << boost::format("%1$15.8f") % (pdi.mu) << " & ";
        *ofs << boost::format("%1$15.8f") % (pdi.Bx) << " & ";
        *ofs << boost::format("%1$15.8f") % (pdi.mu * pdi.Bx) << " & ";
        *ofs << boost::format("%1$15.8f") % (pdi.fx + pdi.mu * pdi.Bx) << " \\\\ " << std::endl;
      }
    }
    
    if (points.begin() != points.end())
    {
      // Saving passed spots function values (for contours).
      char const *dataFileName = "../output/ne_contours.gp"; // TODO: Correct file name.
      boost::scoped_ptr<std::ofstream> ofs(new std::ofstream(dataFileName));
      if (ofs->fail())
      {
        std::cerr << "Failed to open data file '" << dataFileName << "'.\n";
        return 1;
      }
      
      *ofs << "set cntrparam levels discrete ";
      
      for (size_t i = 1; i < points.size(); ++i)
        *ofs << points[i].fx << ",";
      *ofs << points[0].fx;
      *ofs << std::endl;
    }
  }
  
  {
    // Generating report data.
    
    char const *dataFileName = "../output/ne_points.tex";
    boost::scoped_ptr<std::ofstream> ofs(new std::ofstream(dataFileName));
    if (ofs->fail())
    {
      std::cerr << "Failed to open data file '" << dataFileName << "'.\n";
      return 1;
    }
    
    boost::optional<scalar_type> prevFMinVal;
    for (size_t p = 0; p < numeric::array_size(function::precisions); ++p)
    {
      scalar_type const precision = function::precisions[p];
      
      size_t nPoints(0);
      numeric::CountingOutputIterator outputIterator(nPoints);
      vector_type const xMin = numeric::barrier_method::find_min
                                 <function_type, function_grad_type, scalar_type>(
                                    f, df, 
                                    constraints.begin(),      constraints.end(), 
                                    constraintsGrads.begin(), constraintsGrads.end(),
                                    startPoint, 
                                    startMu, beta,
                                    precision, 
                                    gradientDescentPrecision, gradientDescentStep, outputIterator);
      
      // Outputting: precision, number of iterations, xMin, f(xMin), f(xMin) - f(xPrevMin), grad f, g1(xMin), g2(xMin).
      *ofs << boost::format("%1$1.0e") % precision << " & " << nPoints << " & (";
      numeric::output_vector_coordinates(*ofs, xMin, ", ", "");
      *ofs << ") & ";
      
      scalar_type const curFMinVal = f(xMin);
      
      *ofs << boost::format("%1$15.8f") % curFMinVal << " & ";
      
      if (prevFMinVal)
        *ofs << boost::format("%1e") % (curFMinVal - *prevFMinVal);
      
      prevFMinVal = curFMinVal;
      
      vector_type const curGrad = df(xMin);
      *ofs << " & (";
      numeric::output_vector_coordinates(*ofs, curGrad, ", ", "", "%1e");
      *ofs << ")";
      
      *ofs << " & " << constraints[0](xMin);
      *ofs << " & " << constraints[1](xMin);

      *ofs << " \\\\\n";
    }
  }
}
Ejemplo n.º 27
0
Foam::polyMesh::polyMesh(const IOobject& io)
:
    objectRegistry(io),
    primitiveMesh(),
    points_
    (
        IOobject
        (
            "points",
            time().findInstance(meshDir(), "points"),
            meshSubDir,
            *this,
            IOobject::MUST_READ,
            IOobject::NO_WRITE
        )
    ),
    faces_
    (
        IOobject
        (
            "faces",
            time().findInstance(meshDir(), "faces"),
            meshSubDir,
            *this,
            IOobject::MUST_READ,
            IOobject::NO_WRITE
        )
    ),
    owner_
    (
        IOobject
        (
            "owner",
            faces_.instance(),
            meshSubDir,
            *this,
            IOobject::READ_IF_PRESENT,
            IOobject::NO_WRITE
        )
    ),
    neighbour_
    (
        IOobject
        (
            "neighbour",
            faces_.instance(),
            meshSubDir,
            *this,
            IOobject::READ_IF_PRESENT,
            IOobject::NO_WRITE
        )
    ),
    clearedPrimitives_(false),
    boundary_
    (
        IOobject
        (
            "boundary",
            time().findInstance(meshDir(), "boundary"),
            meshSubDir,
            *this,
            IOobject::MUST_READ,
            IOobject::NO_WRITE
        ),
        *this
    ),
    bounds_(points_),
    comm_(UPstream::worldComm),
    geometricD_(Vector<label>::zero),
    solutionD_(Vector<label>::zero),
    tetBasePtIsPtr_(NULL),
    cellTreePtr_(NULL),
    pointZones_
    (
        IOobject
        (
            "pointZones",
            time().findInstance
            (
                meshDir(),
                "pointZones",
                IOobject::READ_IF_PRESENT
            ),
            meshSubDir,
            *this,
            IOobject::READ_IF_PRESENT,
            IOobject::NO_WRITE
        ),
        *this
    ),
    faceZones_
    (
        IOobject
        (
            "faceZones",
            time().findInstance
            (
                meshDir(),
                "faceZones",
                IOobject::READ_IF_PRESENT
            ),
            meshSubDir,
            *this,
            IOobject::READ_IF_PRESENT,
            IOobject::NO_WRITE
        ),
        *this
    ),
    cellZones_
    (
        IOobject
        (
            "cellZones",
            time().findInstance
            (
                meshDir(),
                "cellZones",
                IOobject::READ_IF_PRESENT
            ),
            meshSubDir,
            *this,
            IOobject::READ_IF_PRESENT,
            IOobject::NO_WRITE
        ),
        *this
    ),
    globalMeshDataPtr_(NULL),
    moving_(false),
    topoChanging_(false),
    curMotionTimeIndex_(time().timeIndex()),
    oldPointsPtr_(NULL)
{
    if (exists(owner_.objectPath()))
    {
        initMesh();
    }
    else
    {
        cellCompactIOList cLst
        (
            IOobject
            (
                "cells",
                time().findInstance(meshDir(), "cells"),
                meshSubDir,
                *this,
                IOobject::MUST_READ,
                IOobject::NO_WRITE
            )
        );

        // Set the primitive mesh
        initMesh(cLst);

        owner_.write();
        neighbour_.write();
    }

    // Calculate topology for the patches (processor-processor comms etc.)
    boundary_.updateMesh();

    // Calculate the geometry for the patches (transformation tensors etc.)
    boundary_.calcGeometry();

    // Warn if global empty mesh
    if (returnReduce(nPoints(), sumOp<label>()) == 0)
    {
        WarningIn("polyMesh(const IOobject&)")
            << "no points in mesh" << endl;
    }
    if (returnReduce(nCells(), sumOp<label>()) == 0)
    {
        WarningIn("polyMesh(const IOobject&)")
            << "no cells in mesh" << endl;
    }

    // Initialise demand-driven data
    calcDirections();
}
Ejemplo n.º 28
0
Foam::solidBodyMotionFvMesh::solidBodyMotionFvMesh(const IOobject& io)
:
    dynamicFvMesh(io),
    dynamicMeshCoeffs_
    (
        IOdictionary
        (
            IOobject
            (
                "dynamicMeshDict",
                io.time().constant(),
                *this,
                IOobject::MUST_READ_IF_MODIFIED,
                IOobject::NO_WRITE,
                false
            )
        ).subDict(typeName + "Coeffs")
    ),
    SBMFPtr_(solidBodyMotionFunction::New(dynamicMeshCoeffs_, io.time())),
    undisplacedPoints_
    (
        IOobject
        (
            "points",
            io.time().constant(),
            meshSubDir,
            *this,
            IOobject::MUST_READ,
            IOobject::NO_WRITE,
            false
        )
    ),
    zoneID_(-1),
    pointIDs_()
{
    if (undisplacedPoints_.size() != nPoints())
    {
        FatalIOErrorIn
        (
            "solidBodyMotionFvMesh::solidBodyMotionFvMesh(const IOobject&)",
            dynamicMeshCoeffs_
        )   << "Read " << undisplacedPoints_.size()
            << " undisplaced points from " << undisplacedPoints_.objectPath()
            << " but the current mesh has " << nPoints()
            << exit(FatalError);
    }

    word cellZoneName =
        dynamicMeshCoeffs_.lookupOrDefault<word>("cellZone", "none");

    if (cellZoneName != "none")
    {
        zoneID_ = cellZones().findZoneID(cellZoneName);
        Info<< "Applying solid body motion to cellZone " << cellZoneName
            << endl;

        const cellZone& cz = cellZones()[zoneID_];


        // collect point IDs of points in cell zone

        boolList movePts(nPoints(), false);

        forAll(cz, i)
        {
            label cellI = cz[i];
            const cell& c = cells()[cellI];
            forAll(c, j)
            {
                const face& f = faces()[c[j]];
                forAll(f, k)
                {
                    label pointI = f[k];
                    movePts[pointI] = true;
                }
            }
Foam::solidBodyMotionFvMesh::solidBodyMotionFvMesh(const IOobject& io)
:
    dynamicFvMesh(io),
    dynamicMeshCoeffs_
    (
        IOdictionary
        (
            IOobject
            (
                "dynamicMeshDict",
                io.time().constant(),
                *this,
                IOobject::MUST_READ_IF_MODIFIED,
                IOobject::NO_WRITE,
                false
            )
        ).subDict(typeName + "Coeffs")
    ),
    SBMFPtr_(solidBodyMotionFunction::New(dynamicMeshCoeffs_, io.time())),
    undisplacedPoints_
    (
        IOobject
        (
            "points",
            io.time().constant(),
            meshSubDir,
            *this,
            IOobject::MUST_READ,
            IOobject::NO_WRITE,
            false
        )
    ),
    pointIDs_(),
    moveAllCells_(false),
    UName_(dynamicMeshCoeffs_.lookupOrDefault<word>("UName", "U"))
{
    if (undisplacedPoints_.size() != nPoints())
    {
        FatalIOErrorIn
        (
            "solidBodyMotionFvMesh::solidBodyMotionFvMesh(const IOobject&)",
            dynamicMeshCoeffs_
        )   << "Read " << undisplacedPoints_.size()
            << " undisplaced points from " << undisplacedPoints_.objectPath()
            << " but the current mesh has " << nPoints()
            << exit(FatalIOError);
    }

    word cellZoneName =
        dynamicMeshCoeffs_.lookupOrDefault<word>("cellZone", "none");

    word cellSetName =
        dynamicMeshCoeffs_.lookupOrDefault<word>("cellSet", "none");

    if ((cellZoneName != "none") && (cellSetName != "none"))
    {
        FatalIOErrorIn
        (
            "solidBodyMotionFvMesh::solidBodyMotionFvMesh(const IOobject&)",
            dynamicMeshCoeffs_
        )
            << "Either cellZone OR cellSet can be supplied, but not both. "
            << "If neither is supplied, all cells will be included"
            << exit(FatalIOError);
    }


    labelList cellIDs;
    if (cellZoneName != "none")
    {
        Info<< "Applying solid body motion to cellZone " << cellZoneName
            << endl;

        label zoneID = cellZones().findZoneID(cellZoneName);

        if (zoneID == -1)
        {
            FatalErrorIn
            (
                "solidBodyMotionFvMesh::solidBodyMotionFvMesh(const IOobject&)"
            )
                << "Unable to find cellZone " << cellZoneName
                << ".  Valid celLZones are:"
                << cellZones().names()
                << exit(FatalError);
        }

        cellIDs = cellZones()[zoneID];
    }

    if (cellSetName != "none")
    {
        Info<< "Applying solid body motion to cellSet " << cellSetName
            << endl;

        cellSet set(*this, cellSetName);

        cellIDs = set.toc();
    }

    label nCells = returnReduce(cellIDs.size(), sumOp<label>());
    moveAllCells_ = nCells == 0;

    if (moveAllCells_)
    {
        Info<< "Applying solid body motion to entire mesh" << endl;
    }
    else
    {
        // collect point IDs of points in cell zone

        boolList movePts(nPoints(), false);

        forAll(cellIDs, i)
        {
            label cellI = cellIDs[i];
            const cell& c = cells()[cellI];
            forAll(c, j)
            {
                const face& f = faces()[c[j]];
                forAll(f, k)
                {
                    label pointI = f[k];
                    movePts[pointI] = true;
                }
            }
        }
Ejemplo n.º 30
0
void SetupAxis(int nm, GLuint &vao, GLuint &vbo, GLuint &ibo)
{
	std::vector<gmtl::Point3f>start;
	std::vector<gmtl::Point3f> verts;
	std::vector<unsigned int> indices;
	std::vector<gmtl::Point3f> color;
	std::vector<gmtl::Point2f> uvs;
	std::vector<gmtl::Point3f> normals;

	int np = 5;
	gmtl::Point3f p0(.0f, .0f, .0f);
	gmtl::Point3f p1(.025f, .0f, .0f);
	gmtl::Point3f p2(.025f, .85f, .0f);
	gmtl::Point3f p3(.055f, .85f, .0f);
	gmtl::Point3f p4(.0f, 1.0f, .0f);

	start.push_back(p0);
	start.push_back(p1);
	start.push_back(p2);
	start.push_back(p3);
	start.push_back(p4);

	verts = rPoints(start, nm, np, 'y');
	color = cPoints(verts, 'o');
	normals = nPoints(verts, 'a');
	uvs = uvPoints(nm, np);

	GenerateIndices(nm, np, indices);
	axisIndexSize = indices.size();

	int vertOffset = verts.size() * sizeof(gmtl::Point3f);
	int uvOffset = uvs.size() * sizeof(gmtl::Point2f);
	int colorOffset = color.size() * sizeof(gmtl::Point3f);
	int indexOffset = indices.size() * sizeof(GLuint);
	int normalOffset = normals.size() * sizeof(gmtl::Point3f);

	glGenVertexArrays(1, &vao);
	glBindVertexArray(vao);

	glGenBuffers(1, &ibo); //Setup 1 buffer name and store the generated buffer object name their
	glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ibo); //bind the buffer name to the target
	glBufferData(GL_ELEMENT_ARRAY_BUFFER, //target buffer object
		indexOffset, //size of buffer object
		&indices[0], //pointer to the data
		GL_STATIC_DRAW);


	glGenBuffers(1, &vbo);
	glBindBuffer(GL_ARRAY_BUFFER, vbo);
	//Set the size and data of the Vertex Buffer Object and set it to STATIC_DRAW
	glBufferData(GL_ARRAY_BUFFER, //this is the target we are buffering to
		vertOffset + colorOffset + normalOffset + uvOffset, //this is the total size of the buffer
		NULL, //address of the content to be updated nothing because we are setting it in the subData buffers
		GL_STATIC_DRAW);//+ uvOffset + normalOffset
	glBufferSubData(GL_ARRAY_BUFFER,
		0, //offset where data replacement will begin
		vertOffset, //size
		&verts[0]);//address of the content to be updated
	glBufferSubData(GL_ARRAY_BUFFER,
		vertOffset, //offset where data replacement will begin
		colorOffset, //size
		&color[0]);//data
	glBufferSubData(GL_ARRAY_BUFFER,
		vertOffset + colorOffset,
		normalOffset,
		&normals[0]);
	glBufferSubData(GL_ARRAY_BUFFER,
		vertOffset + colorOffset + normalOffset,
		uvOffset,
		&uvs[0]);
	//verts|uv|color|normals
	//layout(location = 0) in vec4 VertexPosition;
	//layout(location = 1) in vec4 VertexColor;
	//layout(location = 2) in vec3 VertexNormal;
	//layout(location = 3) in vec2 VertexUV;
	//This is the layout in the shader for the attribute variables
	//that will be binded to the different geometry buffers
	glEnableVertexAttribArray(0);
	glVertexAttribPointer(0,
		3,
		GL_FLOAT,
		GL_FALSE,
		0,
		(void*)(0));
	glEnableVertexAttribArray(1);
	glVertexAttribPointer(1,
		3,
		GL_FLOAT,
		GL_FALSE,
		0,
		(void*)(vertOffset)); // vertex buffer object

	glEnableVertexAttribArray(2);
	glVertexAttribPointer(2,
		3,
		GL_FLOAT,
		GL_FALSE,
		0,
		(void*)(vertOffset + colorOffset)); // vertex buffer object

	glEnableVertexAttribArray(3);
	glVertexAttribPointer(3,
		2,
		GL_FLOAT,
		GL_FALSE,
		0,
		(void*)(vertOffset + colorOffset + normalOffset));


	glBindVertexArray(0);
	//Bind the index buffer for the object
	glBindBuffer(GL_ARRAY_BUFFER, 0);
	// Bind the index buffer for the object
	glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);


}