Nektar++
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Pages
Forcing.cpp
Go to the documentation of this file.
1 ///////////////////////////////////////////////////////////////////////////////
2 //
3 // File: Forcing.cpp
4 //
5 // For more information, please see: http://www.nektar.info
6 //
7 // The MIT License
8 //
9 // Copyright (c) 2006 Division of Applied Mathematics, Brown University (USA),
10 // Department of Aeronautics, Imperial College London (UK), and Scientific
11 // Computing and Imaging Institute, University of Utah (USA).
12 //
13 // License for the specific language governing rights and limitations under
14 // Permission is hereby granted, free of charge, to any person obtaining a
15 // copy of this software and associated documentation files (the "Software"),
16 // to deal in the Software without restriction, including without limitation
17 // the rights to use, copy, modify, merge, publish, distribute, sublicense,
18 // and/or sell copies of the Software, and to permit persons to whom the
19 // Software is furnished to do so, subject to the following conditions:
20 //
21 // The above copyright notice and this permission notice shall be included
22 // in all copies or substantial portions of the Software.
23 //
24 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
25 // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
26 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
27 // THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
28 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
29 // FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
30 // DEALINGS IN THE SOFTWARE.
31 //
32 // Description: Abstract base class for forcing terms.
33 //
34 ///////////////////////////////////////////////////////////////////////////////
35 
37 
38 using namespace std;
39 
40 namespace Nektar
41 {
42  namespace SolverUtils
43  {
45  {
46  typedef Loki::SingletonHolder<ForcingFactory,
47  Loki::CreateUsingNew,
48  Loki::NoDestroy,
49  Loki::SingleThreaded> Type;
50  return Type::Instance();
51  }
52 
53  Forcing::Forcing(const LibUtilities::SessionReaderSharedPtr& pSession)
54  : m_session(pSession)
55  {
56 
57  }
58 
61  const unsigned int& pNumForcingFields,
62  const TiXmlElement* pForce)
63  {
64  v_InitObject(pFields, pNumForcingFields, pForce);
65  }
66 
67 
68  /**
69  * @param fields Expansion lists corresponding to input arrays
70  * @param inarray u^n from previous timestep
71  * @param outarray output array to append forcing to
72  */
75  const Array<OneD, Array<OneD, NekDouble> >& inarray,
76  Array<OneD, Array<OneD, NekDouble> >& outarray,
77  const NekDouble& time)
78  {
79  v_Apply(fields, inarray, outarray, time);
80  }
81 
82 
83  /**
84  *
85  */
86  vector<ForcingSharedPtr> Forcing::Load(
89  const unsigned int& pNumForcingFields)
90  {
91  vector<ForcingSharedPtr> vForceList;
92 
93  if (!pSession->DefinesElement("Nektar/Forcing"))
94  {
95  return vForceList;
96  }
97 
98  TiXmlElement* vForcing = pSession->GetElement("Nektar/Forcing");
99  if (vForcing)
100  {
101  unsigned int vNumForcingFields = pNumForcingFields;
102  if (!pNumForcingFields)
103  {
104  vNumForcingFields = pFields.num_elements();
105  }
106 
107  TiXmlElement* vForce = vForcing->FirstChildElement("FORCE");
108  while (vForce)
109  {
110  string vType = vForce->Attribute("TYPE");
111 
112  vForceList.push_back(GetForcingFactory().CreateInstance(
113  vType, pSession, pFields,
114  vNumForcingFields, vForce));
115  vForce = vForce->NextSiblingElement("FORCE");
116  }
117  }
118  return vForceList;
119  }
120 
122  {
123  return m_Forcing;
124  }
125 
127  {
128  return m_Forcing;
129  }
130 
133  std::string pFieldName,
134  Array<OneD, NekDouble>& pArray,
135  const std::string& pFunctionName,
136  NekDouble pTime)
137  {
138  ASSERTL0(pSession->DefinesFunction(pFunctionName),
139  "Function '" + pFunctionName + "' does not exist.");
140 
142  pSession->GetFunction(pFunctionName, pFieldName);
143 
144  EvaluateTimeFunction(pTime,ffunc,pArray);
145  }
146 
147 
149  const NekDouble pTime,
151  Array<OneD, NekDouble>& pArray)
152  {
153  // dummy array of zero pts.
154  Array<OneD, NekDouble> x0(pArray.num_elements(),0.0);
155 
156  pEqn->Evaluate(x0, x0, x0, pTime, pArray);
157  }
158 
159 
160 
164  std::string pFieldName,
165  Array<OneD, NekDouble>& pArray,
166  const std::string& pFunctionName,
167  NekDouble pTime)
168  {
169  ASSERTL0(pSession->DefinesFunction(pFunctionName),
170  "Function '" + pFunctionName + "' does not exist.");
171 
172  unsigned int nq = pFields[0]->GetNpoints();
173  if (pArray.num_elements() != nq)
174  {
175  pArray = Array<OneD, NekDouble> (nq);
176  }
177 
179  vType = pSession->GetFunctionType(pFunctionName, pFieldName);
181  {
182  Array<OneD, NekDouble> x0(nq);
183  Array<OneD, NekDouble> x1(nq);
184  Array<OneD, NekDouble> x2(nq);
185 
186  pFields[0]->GetCoords(x0, x1, x2);
188  pSession->GetFunction(pFunctionName, pFieldName);
189 
190  ffunc->Evaluate(x0, x1, x2, pTime, pArray);
191  }
192  else if (vType == LibUtilities::eFunctionTypeFile)
193  {
194  std::string filename = pSession->GetFunctionFilename(
195  pFunctionName,
196  pFieldName);
197 
198  std::vector<LibUtilities::FieldDefinitionsSharedPtr> FieldDef;
199  std::vector<std::vector<NekDouble> > FieldData;
200  Array<OneD, NekDouble> vCoeffs(pFields[0]->GetNcoeffs());
201  Vmath::Zero(vCoeffs.num_elements(), vCoeffs, 1);
202 
205  fld->Import(filename, FieldDef, FieldData);
206 
207  int idx = -1;
208  for (int i = 0; i < FieldDef.size(); ++i)
209  {
210  for (int j = 0; j < FieldDef[i]->m_fields.size(); ++j)
211  {
212  if (FieldDef[i]->m_fields[j] == pFieldName)
213  {
214  idx = j;
215  }
216  }
217 
218  if (idx >= 0)
219  {
220  pFields[0]->ExtractDataToCoeffs(
221  FieldDef[i],
222  FieldData[i],
223  FieldDef[i]->m_fields[idx],
224  vCoeffs);
225  }
226  else
227  {
228  cout << "Field " + pFieldName + " not found." << endl;
229  }
230  }
231  pFields[0]->BwdTrans_IterPerExp(vCoeffs, pArray);
232  }
233  }
234 
235  }
236 }
SOLVER_UTILS_EXPORT void EvaluateTimeFunction(LibUtilities::SessionReaderSharedPtr pSession, std::string pFieldName, Array< OneD, NekDouble > &pArray, const std::string &pFunctionName, NekDouble pTime=NekDouble(0))
Definition: Forcing.cpp:131
Array< OneD, Array< OneD, NekDouble > > m_Forcing
Evaluated forcing function.
Definition: Forcing.h:102
#define ASSERTL0(condition, msg)
Definition: ErrorUtil.hpp:198
SOLVER_UTILS_EXPORT void InitObject(const Array< OneD, MultiRegions::ExpListSharedPtr > &pFields, const unsigned int &pNumForcingFields, const TiXmlElement *pForce)
Initialise the forcing object.
Definition: Forcing.cpp:59
SOLVER_UTILS_EXPORT void Apply(const Array< OneD, MultiRegions::ExpListSharedPtr > &fields, const Array< OneD, Array< OneD, NekDouble > > &inarray, Array< OneD, Array< OneD, NekDouble > > &outarray, const NekDouble &time)
Apply the forcing.
Definition: Forcing.cpp:73
SOLVER_UTILS_EXPORT Array< OneD, Array< OneD, NekDouble > > & UpdateForces()
Definition: Forcing.cpp:121
ForcingFactory & GetForcingFactory()
Declaration of the forcing factory singleton.
Definition: Forcing.cpp:44
STL namespace.
SOLVER_UTILS_EXPORT void EvaluateFunction(Array< OneD, MultiRegions::ExpListSharedPtr > pFields, LibUtilities::SessionReaderSharedPtr pSession, std::string pFieldName, Array< OneD, NekDouble > &pArray, const std::string &pFunctionName, NekDouble pTime=NekDouble(0))
Definition: Forcing.cpp:161
static SOLVER_UTILS_EXPORT std::vector< ForcingSharedPtr > Load(const LibUtilities::SessionReaderSharedPtr &pSession, const Array< OneD, MultiRegions::ExpListSharedPtr > &pFields, const unsigned int &pNumForcingFields=0)
Definition: Forcing.cpp:86
boost::shared_ptr< SessionReader > SessionReaderSharedPtr
Definition: MeshPartition.h:51
SOLVER_UTILS_EXPORT const Array< OneD, const Array< OneD, NekDouble > > & GetForces()
Definition: Forcing.cpp:126
LibUtilities::NekFactory< std::string, Forcing, const LibUtilities::SessionReaderSharedPtr &, const Array< OneD, MultiRegions::ExpListSharedPtr > &, const unsigned int &, const TiXmlElement * > ForcingFactory
Declaration of the forcing factory.
Definition: Forcing.h:61
boost::shared_ptr< FieldIO > FieldIOSharedPtr
Definition: FieldIO.h:309
double NekDouble
LibUtilities::SessionReaderSharedPtr m_session
Session reader.
Definition: Forcing.h:100
boost::shared_ptr< Equation > EquationSharedPtr
static boost::shared_ptr< FieldIO > CreateForFile(const LibUtilities::SessionReaderSharedPtr session, const std::string &filename)
Construct a FieldIO object for a given input filename.
Definition: FieldIO.cpp:212
virtual SOLVER_UTILS_EXPORT void v_InitObject(const Array< OneD, MultiRegions::ExpListSharedPtr > &pFields, const unsigned int &pNumForcingFields, const TiXmlElement *pForce)=0
void Zero(int n, T *x, const int incx)
Zero vector.
Definition: Vmath.cpp:373
Provides a generic Factory class.
Definition: NekFactory.hpp:116
virtual SOLVER_UTILS_EXPORT void v_Apply(const Array< OneD, MultiRegions::ExpListSharedPtr > &fields, const Array< OneD, Array< OneD, NekDouble > > &inarray, Array< OneD, Array< OneD, NekDouble > > &outarray, const NekDouble &time)=0