ENH: autoLayerDriver: better layering information message
[OpenFOAM-2.0.x.git] / src / topoChangerFvMesh / linearValveLayersFvMesh / linearValveLayersFvMesh.C
blob90243b27d7224fb4aee024214bde56029510219b
1 /*---------------------------------------------------------------------------*\
2   =========                 |
3   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
4    \\    /   O peration     |
5     \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
6      \\/     M anipulation  |
7 -------------------------------------------------------------------------------
8 License
9     This file is part of OpenFOAM.
11     OpenFOAM is free software: you can redistribute it and/or modify it
12     under the terms of the GNU General Public License as published by
13     the Free Software Foundation, either version 3 of the License, or
14     (at your option) any later version.
16     OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
17     ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
18     FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
19     for more details.
21     You should have received a copy of the GNU General Public License
22     along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
24 \*---------------------------------------------------------------------------*/
26 #include "linearValveLayersFvMesh.H"
27 #include "Time.H"
28 #include "slidingInterface.H"
29 #include "layerAdditionRemoval.H"
30 #include "pointField.H"
31 #include "mapPolyMesh.H"
32 #include "polyTopoChange.H"
33 #include "addToRunTimeSelectionTable.H"
35 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
37 namespace Foam
39     defineTypeNameAndDebug(linearValveLayersFvMesh, 0);
40     addToRunTimeSelectionTable
41     (
42         topoChangerFvMesh,
43         linearValveLayersFvMesh,
44         IOobject
45     );
49 // * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
51 void Foam::linearValveLayersFvMesh::addZonesAndModifiers()
53     // Add zones and modifiers for motion action
55     if
56     (
57         pointZones().size()
58      || faceZones().size()
59      || cellZones().size()
60      || topoChanger_.size()
61     )
62     {
63         Info<< "void linearValveLayersFvMesh::addZonesAndModifiers() : "
64             << "Zones and modifiers already present.  Skipping."
65             << endl;
67         return;
68     }
70     Info<< "Time = " << time().timeName() << endl
71         << "Adding zones and modifiers to the mesh" << endl;
73     // Add zones
74     List<pointZone*> pz(1);
75     List<faceZone*> fz(4);
76     List<cellZone*> cz(0);
79     // Add an empty zone for cut points
81     pz[0] = new pointZone
82     (
83         "cutPointZone",
84         labelList(0),
85         0,
86         pointZones()
87     );
90     // Do face zones for slider
92     // Inner slider
93     const word innerSliderName(motionDict_.subDict("slider").lookup("inside"));
94     const polyPatch& innerSlider = boundaryMesh()[innerSliderName];
96     labelList isf(innerSlider.size());
98     forAll(isf, i)
99     {
100         isf[i] = innerSlider.start() + i;
101     }
103     fz[0] = new faceZone
104     (
105         "insideSliderZone",
106         isf,
107         boolList(innerSlider.size(), false),
108         0,
109         faceZones()
110     );
112     // Outer slider
113     const word outerSliderName(motionDict_.subDict("slider").lookup("outside"));
114     const polyPatch& outerSlider = boundaryMesh()[outerSliderName];
116     labelList osf(outerSlider.size());
118     forAll(osf, i)
119     {
120         osf[i] = outerSlider.start() + i;
121     }
123     fz[1] = new faceZone
124     (
125         "outsideSliderZone",
126         osf,
127         boolList(outerSlider.size(), false),
128         1,
129         faceZones()
130     );
132     // Add empty zone for cut faces
133     fz[2] = new faceZone
134     (
135         "cutFaceZone",
136         labelList(0),
137         boolList(0, false),
138         2,
139         faceZones()
140     );
142     // Add face zone for layer addition
143     const word layerPatchName
144     (
145         motionDict_.subDict("layer").lookup("patch")
146     );
148     const polyPatch& layerPatch = boundaryMesh()[layerPatchName];
150     labelList lpf(layerPatch.size());
152     forAll(lpf, i)
153     {
154         lpf[i] = layerPatch.start() + i;
155     }
157     fz[3] = new faceZone
158     (
159         "valveLayerZone",
160         lpf,
161         boolList(layerPatch.size(), true),
162         0,
163         faceZones()
164     );
167     Info<< "Adding point and face zones" << endl;
168     addZones(pz, fz, cz);
170     // Add a topology modifier
172     List<polyMeshModifier*> tm(2);
174     tm[0] = new slidingInterface
175     (
176         "valveSlider",
177         0,
178         topoChanger_,
179         outerSliderName + "Zone",
180         innerSliderName + "Zone",
181         "cutPointZone",
182         "cutFaceZone",
183         outerSliderName,
184         innerSliderName,
185         slidingInterface::INTEGRAL,
186         true                          // Attach-detach action
187     );
189     tm[1] =
190         new layerAdditionRemoval
191         (
192             "valveLayer",
193             1,
194             topoChanger_,
195             "valveLayerZone",
196             readScalar
197             (
198                 motionDict_.subDict("layer").lookup("minThickness")
199             ),
200             readScalar
201             (
202                 motionDict_.subDict("layer").lookup("maxThickness")
203             )
204         );
207     Info<< "Adding topology modifiers" << endl;
208     addTopologyModifiers(tm);
210     // Write mesh
211     write();
215 void Foam::linearValveLayersFvMesh::makeLayersLive()
217     const polyTopoChanger& topoChanges = topoChanger_;
219     // Enable layering
220     forAll(topoChanges, modI)
221     {
222         if (isA<layerAdditionRemoval>(topoChanges[modI]))
223         {
224             topoChanges[modI].enable();
225         }
226         else if (isA<slidingInterface>(topoChanges[modI]))
227         {
228             topoChanges[modI].disable();
229         }
230         else
231         {
232             FatalErrorIn("void linearValveLayersFvMesh::makeLayersLive()")
233                 << "Don't know what to do with mesh modifier "
234                 << modI << " of type " << topoChanges[modI].type()
235                 << abort(FatalError);
236         }
237     }
241 void Foam::linearValveLayersFvMesh::makeSlidersLive()
243     const polyTopoChanger& topoChanges = topoChanger_;
245     // Enable sliding interface
246     forAll(topoChanges, modI)
247     {
248         if (isA<layerAdditionRemoval>(topoChanges[modI]))
249         {
250             topoChanges[modI].disable();
251         }
252         else if (isA<slidingInterface>(topoChanges[modI]))
253         {
254             topoChanges[modI].enable();
255         }
256         else
257         {
258             FatalErrorIn("void linearValveLayersFvMesh::makeLayersLive()")
259                 << "Don't know what to do with mesh modifier "
260                 << modI << " of type " << topoChanges[modI].type()
261                 << abort(FatalError);
262         }
263     }
267 bool Foam::linearValveLayersFvMesh::attached() const
269     const polyTopoChanger& topoChanges = topoChanger_;
271     bool result = false;
273     forAll(topoChanges, modI)
274     {
275         if (isA<slidingInterface>(topoChanges[modI]))
276         {
277             result =
278                 result
279              || refCast<const slidingInterface>(topoChanges[modI]).attached();
280         }
281     }
283     // Check thal all sliders are in sync (debug only)
284     forAll(topoChanges, modI)
285     {
286         if (isA<slidingInterface>(topoChanges[modI]))
287         {
288             if
289             (
290                 result
291              != refCast<const slidingInterface>(topoChanges[modI]).attached()
292             )
293             {
294                 FatalErrorIn("bool linearValveLayersFvMesh::attached() const")
295                     << "Slider " << modI << " named "
296                     << topoChanges[modI].name()
297                     << " out of sync: Should be" << result
298                     << abort(FatalError);
299             }
300         }
301     }
303     return result;
307 Foam::tmp<Foam::pointField> Foam::linearValveLayersFvMesh::newPoints() const
309     tmp<pointField> tnewPoints
310     (
311         new pointField(points())
312     );
314     pointField& np = tnewPoints();
316     const word layerPatchName
317     (
318         motionDict_.subDict("layer").lookup("patch")
319     );
321     const polyPatch& layerPatch = boundaryMesh()[layerPatchName];
323     const labelList& patchPoints = layerPatch.meshPoints();
325     const vector vel
326     (
327         motionDict_.lookup("pistonVelocity")
328     );
330     forAll(patchPoints, ppI)
331     {
332         np[patchPoints[ppI]] += vel*time().deltaTValue();
333     }
335     return tnewPoints;
340 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
342 // Construct from components
343 Foam::linearValveLayersFvMesh::linearValveLayersFvMesh(const IOobject& io)
345     topoChangerFvMesh(io),
346     motionDict_
347     (
348         IOdictionary
349         (
350             IOobject
351             (
352                 "dynamicMeshDict",
353                 time().constant(),
354                 *this,
355                 IOobject::MUST_READ_IF_MODIFIED,
356                 IOobject::NO_WRITE,
357                 false
358             )
359         ).subDict(typeName + "Coeffs")
360     )
362     addZonesAndModifiers();
366 // * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
368 Foam::linearValveLayersFvMesh::~linearValveLayersFvMesh()
371 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
373 void Foam::linearValveLayersFvMesh::update()
375     // Detaching the interface
376     if (attached())
377     {
378         Info<< "Decoupling sliding interfaces" << endl;
379         makeSlidersLive();
381         // Changing topology
382         resetMorph();
383         setMorphTimeIndex(3*time().timeIndex());
384         updateMesh();
385     }
386     else
387     {
388         Info<< "Sliding interfaces decoupled" << endl;
389     }
391     // Perform layer action and mesh motion
392     makeLayersLive();
394     // Changing topology
395     resetMorph();
396     setMorphTimeIndex(3*time().timeIndex() + 1);
397     updateMesh();
399     if (topoChangeMap.valid())
400     {
401         if (topoChangeMap().hasMotionPoints())
402         {
403             Info<< "Topology change; executing pre-motion" << endl;
404             movePoints(topoChangeMap().preMotionPoints());
405         }
406     }
408     // Move points
409     movePoints(newPoints());
411     // Attach the interface
412     Info<< "Coupling sliding interfaces" << endl;
413     makeSlidersLive();
415     // Changing topology
416     resetMorph();
417     setMorphTimeIndex(3*time().timeIndex() + 2);
418     updateMesh();
420     Info<< "Moving points post slider attach" << endl;
421 //     const pointField p = allPoints();
422 //     movePoints(p);
424     Info<< "Sliding interfaces coupled: " << attached() << endl;
428 // ************************************************************************* //