MBDyn-1.7.3
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups
Classes | Functions
strmappingext.h File Reference
#include <vector>
#include <string>
#include "extforce.h"
#include "spmapmh.h"
#include "stlvh.h"
Include dependency graph for strmappingext.h:
This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes

class  StructMappingExtForce
 
struct  StructMappingExtForce::OffsetData
 
struct  StructMappingExtForce::NodeData
 
class  StructMembraneMappingExtForce
 
struct  StructMembraneMappingExtForce::NodeConnData
 

Functions

Elem * ReadStructMappingExtForce (DataManager *pDM, MBDynParser &HP, unsigned int uLabel)
 

Function Documentation

Elem* ReadStructMappingExtForce ( DataManager *  pDM,
MBDynParser &  HP,
unsigned int  uLabel 
)

Definition at line 1804 of file strmappingext.cc.

References ASSERT, c, Vec3::Cross(), dRaDegr, Eye3, Elem::FORCE, DataManager::fReadOutput(), IncludeParser::GetFileName(), HighParser::GetInt(), WithLabel::GetLabel(), IncludeParser::GetLineData(), MBDynParser::GetPosRel(), StructNode::GetRCurr(), HighParser::GetReal(), StructDispNode::GetXCurr(), HighParser::GetYesNo(), StructMembraneMappingExtForce::NodeConnData::h1, StructMembraneMappingExtForce::NodeConnData::h2, host, HighParser::IsArg(), HighParser::IsKeyWord(), MatR2EulerAngles123(), MBC_ROT_EULER_123, MBC_ROT_MAT, MBC_ROT_NONE, MBC_ROT_THETA, MBDYN_EXCEPT_ARGS, Mat3x3::MulTV(), Vec3::Norm(), order, output(), StructMembraneMappingExtForce::NodeConnData::pNode, ReadExtForce(), DataManager::ReadNode(), ReadSparseMappingMatrix(), SAFENEWWITHCONSTRUCTOR, Node::STRUCTURAL, and Zero3.

Referenced by ReadForce().

1807 {
1808  ExtFileHandlerBase *pEFH = 0;
1809  int iCoupling;
1810 
1811  bool bSendAfterPredict;
1812  ReadExtForce(pDM, HP, uLabel, pEFH, bSendAfterPredict, iCoupling);
1813 
1814  const StructNode *pRefNode(0);
1815  if (HP.IsKeyWord("reference" "node")) {
1816  pRefNode = pDM->ReadNode<const StructNode, Node::STRUCTURAL>(HP);
1817  }
1818 
1819  bool bLabels(false);
1820  unsigned uRRot = pRefNode ? MBC_ROT_MAT : MBC_ROT_NONE;
1821  bool bOutputAccelerations(false);
1822  bool bUseReferenceNodeForces(true);
1823  bool bRotateReferenceNodeForces(true);
1824 
1825  bool bGotLabels(false);
1826  bool bGotRot(false);
1827  bool bGotAccels(false);
1828  bool bGotUseRefForces(false);
1829 
1830  while (HP.IsArg()) {
1831  if (HP.IsKeyWord("no" "labels")) {
1832  silent_cerr("StructMappingExtForce(" << uLabel << "): "
1833  "use of \"no labels\" deprecated in favor of \"labels, { yes | no }\" at line "
1834  << HP.GetLineData() << std::endl);
1835 
1836  if (bGotLabels) {
1837  silent_cerr("StructMappingExtForce(" << uLabel << "): "
1838  "\"no labels\" already specified at line "
1839  << HP.GetLineData() << std::endl);
1840  throw ErrGeneric(MBDYN_EXCEPT_ARGS);
1841  }
1842 
1843  bLabels = false;
1844  bGotLabels = true;
1845 
1846  } else if (HP.IsKeyWord("labels")) {
1847  if (bGotLabels) {
1848  silent_cerr("StructMappingExtForce(" << uLabel << "): "
1849  "\"labels\" already specified at line "
1850  << HP.GetLineData() << std::endl);
1851  throw ErrGeneric(MBDYN_EXCEPT_ARGS);
1852  }
1853 
1854  if (!HP.GetYesNo(bLabels)) {
1855  silent_cerr("StructMappingExtForce(" << uLabel << "): "
1856  "\"labels\" must be either \"yes\" or \"no\" at line "
1857  << HP.GetLineData() << std::endl);
1858  throw ErrGeneric(MBDYN_EXCEPT_ARGS);
1859  }
1860  bGotLabels = true;
1861 
1862  } else if (HP.IsKeyWord("orientation")) {
1863  if (bGotRot) {
1864  silent_cerr("StructMappingExtForce(" << uLabel << "): "
1865  "\"orientation\" already specified at line "
1866  << HP.GetLineData() << std::endl);
1867  throw ErrGeneric(MBDYN_EXCEPT_ARGS);
1868  }
1869 
1870  if (HP.IsKeyWord("none")) {
1871  uRRot = MBC_ROT_NONE;
1872 
1873  } else if (HP.IsKeyWord("orientation" "vector")) {
1874  uRRot = MBC_ROT_THETA;
1875 
1876  } else if (HP.IsKeyWord("orientation" "matrix")) {
1877  uRRot = MBC_ROT_MAT;
1878 
1879  } else if (HP.IsKeyWord("euler" "123")) {
1880  uRRot = MBC_ROT_EULER_123;
1881 
1882  } else {
1883  silent_cerr("StructMappingExtForce(" << uLabel << "): "
1884  "unknown \"orientation\" format at line "
1885  << HP.GetLineData() << std::endl);
1886  throw ErrGeneric(MBDYN_EXCEPT_ARGS);
1887  }
1888 
1889  bGotRot = true;
1890 
1891  } else if (HP.IsKeyWord("accelerations")) {
1892  if (bGotAccels) {
1893  silent_cerr("StructMappingExtForce(" << uLabel << "): "
1894  "\"accelerations\" already specified at line "
1895  << HP.GetLineData() << std::endl);
1896  throw ErrGeneric(MBDYN_EXCEPT_ARGS);
1897  }
1898 
1899  if (!HP.GetYesNo(bOutputAccelerations)) {
1900  silent_cerr("StructMappingExtForce(" << uLabel << "): "
1901  "\"accelerations\" must be either \"yes\" or \"no\" at line "
1902  << HP.GetLineData() << std::endl);
1903  throw ErrGeneric(MBDYN_EXCEPT_ARGS);
1904  }
1905  bGotAccels = true;
1906 
1907  } else if (HP.IsKeyWord("use" "reference" "node" "forces")) {
1908  if (pRefNode == 0) {
1909  silent_cerr("StructMappingExtForce(" << uLabel << "): "
1910  "\"use reference node forces\" only meaningful when reference node is used at line "
1911  << HP.GetLineData() << std::endl);
1912  throw ErrGeneric(MBDYN_EXCEPT_ARGS);
1913  }
1914 
1915  if (bGotUseRefForces) {
1916  silent_cerr("StructMappingExtForce(" << uLabel << "): "
1917  "\"use reference node forces\" already specified at line "
1918  << HP.GetLineData() << std::endl);
1919  throw ErrGeneric(MBDYN_EXCEPT_ARGS);
1920  }
1921 
1922  if (!HP.GetYesNo(bUseReferenceNodeForces)) {
1923  silent_cerr("StructMappingExtForce(" << uLabel << "): "
1924  "\"use reference node forces\" must be either \"yes\" or \"no\" at line "
1925  << HP.GetLineData() << std::endl);
1926  throw ErrGeneric(MBDYN_EXCEPT_ARGS);
1927  }
1928  bGotUseRefForces = true;
1929 
1930  if (bUseReferenceNodeForces && HP.IsKeyWord("rotate" "reference" "node" "forces")) {
1931  if (!HP.GetYesNo(bRotateReferenceNodeForces)) {
1932  silent_cerr("StructMappingExtForce(" << uLabel << "): "
1933  "\"rotate reference node forces\" must be either \"yes\" or \"no\" at line "
1934  << HP.GetLineData() << std::endl);
1935  throw ErrGeneric(MBDYN_EXCEPT_ARGS);
1936  }
1937  }
1938 
1939  } else {
1940  break;
1941  }
1942  }
1943 
1944  if (!HP.IsKeyWord("points" "number")) {
1945  silent_cerr("StructMappingExtForce(" << uLabel << "): "
1946  "\"points number\" keyword expected "
1947  "at line " << HP.GetLineData() << std::endl);
1948  throw ErrGeneric(MBDYN_EXCEPT_ARGS);
1949  }
1950 
1951  int nPoints = HP.GetInt();
1952  if (nPoints <= 0) {
1953  silent_cerr("StructMappingExtForce(" << uLabel << "): illegal points number " << nPoints <<
1954  " at line " << HP.GetLineData() << std::endl);
1955  throw ErrGeneric(MBDYN_EXCEPT_ARGS);
1956  }
1957 
1958  std::vector<const StructDispNode *> Nodes(nPoints);
1959  std::vector<Vec3> Offsets(nPoints, ::Zero3);
1960  std::vector<uint32_t> Labels;
1961  if (bLabels) {
1962  Labels.resize(nPoints);
1963  }
1964  bool bMembrane(false);
1965  std::vector<StructMembraneMappingExtForce::NodeConnData> NodesConn;
1966 
1967  std::map<unsigned, bool> Got;
1968 
1969  for (unsigned n = 0, p = 0; p < unsigned(nPoints); n++) {
1970  const StructDispNode *pNode = pDM->ReadNode<const StructDispNode, Node::STRUCTURAL>(HP);
1971  unsigned uL(pNode->GetLabel());
1972  if (Got[uL]) {
1973  silent_cerr("StructMappingExtForce(" << uLabel << "): "
1974  "StructNode(" << uL << ") out of order "
1975  "at line " << HP.GetLineData() << std::endl);
1976  throw ErrGeneric(MBDYN_EXCEPT_ARGS);
1977  }
1978  Got[uL] = true;
1979 
1980  StructMembraneMappingExtForce::NodeConnData ncd;
1981  ncd.pNode[0] = 0;
1982 
1983  ReferenceFrame RF(pNode);
1984  if (HP.IsKeyWord("membrane")) {
1985  bMembrane = true;
1986 
1987  for (unsigned n = 0; n < 4; n++) {
1988  const StructDispNode *pNn = pDM->ReadNode<const StructDispNode, Node::STRUCTURAL>(HP);
1989  if ((n%2) && pNn == ncd.pNode[n - 1]) {
1990  silent_cerr("StructMappingExtForce(" << uLabel << "): "
1991  "nodes #" << n << " and #" << n - 1 << " are the same in \"membrane\" mapping for StructNode(" << uL << ") at line " << HP.GetLineData() << std::endl);
1992  throw ErrGeneric(MBDYN_EXCEPT_ARGS);
1993  }
1994  ncd.pNode[n] = pNn;
1995  }
1996 
1997  // first node
1998  Nodes[p] = pNode;
1999  Offsets[p] = ::Zero3;
2000 
2001  doublereal h1 = HP.GetReal();
2002  if (h1 == 0.) {
2003  silent_cerr("StructMappingExtForce(" << uLabel << "): "
2004  "invalid h1 in \"membrane\" mapping for StructNode(" << uL << ") at line " << HP.GetLineData() << std::endl);
2005  throw ErrGeneric(MBDYN_EXCEPT_ARGS);
2006  }
2007  ncd.h1 = h1;
2008 
2009  if (bLabels) {
2010  int l = HP.GetInt();
2011  if (l < 0) {
2012  silent_cerr("StructMappingExtForce(" << uLabel << "): "
2013  "invalid (negative) point label " << l
2014  << " at line " << HP.GetLineData() << std::endl);
2015  throw ErrGeneric(MBDYN_EXCEPT_ARGS);
2016  }
2017  Labels[p] = l;
2018  }
2019 
2020  p++;
2021 
2022  if (p == unsigned(nPoints)) {
2023  silent_cerr("StructMappingExtForce(" << uLabel << "): "
2024  "second point in \"membrane\" mapping for StructNode(" << uL << ") exceeds points number " << nPoints << " at line " << HP.GetLineData() << std::endl);
2025  throw ErrGeneric(MBDYN_EXCEPT_ARGS);
2026  }
2027 
2028  // second node
2029  Nodes[p] = pNode;
2030  Offsets[p] = ::Zero3;
2031 
2032  doublereal h2 = HP.GetReal();
2033  if (h2 == 0. || h1*h2 > 0.) {
2034  silent_cerr("StructMappingExtForce(" << uLabel << "): "
2035  "invalid h2 in \"membrane\" mapping for StructNode(" << uL << ") at line " << HP.GetLineData() << std::endl);
2036  throw ErrGeneric(MBDYN_EXCEPT_ARGS);
2037  }
2038  ncd.h2 = h2;
2039 
2040  if (bLabels) {
2041  int l = HP.GetInt();
2042  if (l < 0) {
2043  silent_cerr("StructMappingExtForce(" << uLabel << "): "
2044  "invalid (negative) point label " << l
2045  << " at line " << HP.GetLineData() << std::endl);
2046  throw ErrGeneric(MBDYN_EXCEPT_ARGS);
2047  }
2048  Labels[p] = l;
2049  }
2050 
2051  p++;
2052 
2053  } else {
2054  while (HP.IsKeyWord("offset")) {
2055  if (p == unsigned(nPoints)) {
2056  silent_cerr("StructMappingExtForce(" << uLabel << "): "
2057  "point " << p << " offset from StructNode(" << pNode->GetLabel() << ") exceeds expected value " << nPoints
2058  << " at line " << HP.GetLineData() << std::endl);
2059  throw ErrGeneric(MBDYN_EXCEPT_ARGS);
2060  }
2061 
2062  if (bLabels) {
2063  int l = HP.GetInt();
2064  if (l < 0) {
2065  silent_cerr("StructMappingExtForce(" << uLabel << "): "
2066  "invalid (negative) point label " << l
2067  << " at line " << HP.GetLineData() << std::endl);
2068  throw ErrGeneric(MBDYN_EXCEPT_ARGS);
2069  }
2070  Labels[p] = l;
2071  }
2072 
2073  Nodes[p] = pNode;
2074  Offsets[p] = HP.GetPosRel(RF);
2075  p++;
2076  }
2077  }
2078 
2079  NodesConn.push_back(ncd);
2080  }
2081 
2082  if (HP.IsKeyWord("echo")) {
2083  const char *s = HP.GetFileName();
2084  if (s == NULL) {
2085  silent_cerr("StructMappingExtForce(" << uLabel << "): "
2086  "unable to parse echo file name "
2087  "at line " << HP.GetLineData()
2088  << std::endl);
2089  throw ErrGeneric(MBDYN_EXCEPT_ARGS);
2090  }
2091 
2092  std::ofstream out(s);
2093 
2094  out.setf(std::ios::scientific);
2095 
2096  bool bGotSurface(false);
2097  bool bGotOutput(false);
2098  bool bGotOrder(false);
2099  bool bGotBaseNode(false);
2100  bool bGotWeight(false);
2101 
2102  bool bGotPrecision(false);
2103 
2104  /*
2105  surface: basicgrid.dat
2106  output: blade1H.dat
2107  order: 2
2108  basenode: 12
2109  weight: 2
2110 
2111  */
2112 
2113  std::string surface;
2114  std::string output;
2115  int order;
2116  int basenode;
2117  int weight;
2118  bool bWeightInf(false);
2119 
2120  while (true) {
2121  if (HP.IsKeyWord("precision")) {
2122  if (bGotPrecision) {
2123  silent_cerr("StructMappingExtForce(" << uLabel << "): "
2124  "\"precision\" already specified "
2125  "at line " << HP.GetLineData() << std::endl);
2126  throw ErrGeneric(MBDYN_EXCEPT_ARGS);
2127  }
2128  bGotPrecision = true;
2129 
2130  int iPrecision = HP.GetInt();
2131  if (iPrecision <= 0) {
2132  silent_cerr("StructMappingExtForce(" << uLabel << "): "
2133  "invalid echo precision " << iPrecision
2134  << " at line " << HP.GetLineData()
2135  << std::endl);
2136  throw ErrGeneric(MBDYN_EXCEPT_ARGS);
2137  }
2138  out.precision(iPrecision);
2139 
2140  } else if (HP.IsKeyWord("surface")) {
2141  if (bGotSurface) {
2142  silent_cerr("StructMappingExtForce(" << uLabel << "): "
2143  "\"surface\" already specified "
2144  "at line " << HP.GetLineData() << std::endl);
2145  throw ErrGeneric(MBDYN_EXCEPT_ARGS);
2146  }
2147  bGotSurface = true;
2148 
2149  surface = HP.GetFileName();
2150  if (surface.empty()) {
2151  silent_cerr("StructMappingExtForce(" << uLabel << "): "
2152  "invalid \"surface\" "
2153  "at line " << HP.GetLineData() << std::endl);
2154  throw ErrGeneric(MBDYN_EXCEPT_ARGS);
2155  }
2156 
2157  } else if (HP.IsKeyWord("output")) {
2158  if (bGotOutput) {
2159  silent_cerr("StructMappingExtForce(" << uLabel << "): "
2160  "\"output\" already specified "
2161  "at line " << HP.GetLineData() << std::endl);
2162  throw ErrGeneric(MBDYN_EXCEPT_ARGS);
2163  }
2164  bGotOutput = true;
2165 
2166  output = HP.GetFileName();
2167  if (output.empty()) {
2168  silent_cerr("StructMappingExtForce(" << uLabel << "): "
2169  "invalid \"output\" "
2170  "at line " << HP.GetLineData() << std::endl);
2171  throw ErrGeneric(MBDYN_EXCEPT_ARGS);
2172  }
2173 
2174  } else if (HP.IsKeyWord("order")) {
2175  if (bGotOrder) {
2176  silent_cerr("StructMappingExtForce(" << uLabel << "): "
2177  "\"order\" already specified "
2178  "at line " << HP.GetLineData() << std::endl);
2179  throw ErrGeneric(MBDYN_EXCEPT_ARGS);
2180  }
2181  bGotOrder = true;
2182 
2183  order = HP.GetInt();
2184  if (order < 1 || order > 3) {
2185  silent_cerr("StructMappingExtForce(" << uLabel << "): "
2186  "invalid order=" << order << ", must be 1 <= order <= 3 "
2187  "at line " << HP.GetLineData() << std::endl);
2188  throw ErrGeneric(MBDYN_EXCEPT_ARGS);
2189  }
2190 
2191  } else if (HP.IsKeyWord("basenode")) {
2192  if (bGotBaseNode) {
2193  silent_cerr("StructMappingExtForce(" << uLabel << "): "
2194  "\"basenode\" already specified "
2195  "at line " << HP.GetLineData() << std::endl);
2196  throw ErrGeneric(MBDYN_EXCEPT_ARGS);
2197  }
2198  bGotBaseNode = true;
2199 
2200  basenode = HP.GetInt();
2201  if (basenode <= 0) {
2202  silent_cerr("StructMappingExtForce(" << uLabel << "): "
2203  "invalid basenode=" << basenode << ", must be > 0 "
2204  "at line " << HP.GetLineData() << std::endl);
2205  throw ErrGeneric(MBDYN_EXCEPT_ARGS);
2206  }
2207 
2208  } else if (HP.IsKeyWord("weight")) {
2209  if (bGotWeight) {
2210  silent_cerr("StructMappingExtForce(" << uLabel << "): "
2211  "\"weight\" already specified "
2212  "at line " << HP.GetLineData() << std::endl);
2213  throw ErrGeneric(MBDYN_EXCEPT_ARGS);
2214  }
2215  bGotWeight = true;
2216 
2217  if (HP.IsKeyWord("inf")) {
2218  bWeightInf = true;
2219 
2220  } else {
2221  weight = HP.GetInt();
2222  if (weight < -2) {
2223  silent_cerr("StructMappingExtForce(" << uLabel << "): "
2224  "invalid weight=" << weight << ", must be >= -2 or \"inf\" "
2225  "at line " << HP.GetLineData() << std::endl);
2226  throw ErrGeneric(MBDYN_EXCEPT_ARGS);
2227  }
2228  }
2229 
2230  } else {
2231  break;
2232  }
2233  }
2234 
2235  time_t t = std::time(NULL);
2236  const char *user = std::getenv("USER");
2237  const char *host = std::getenv("HOSTNAME");
2238  if (user == 0) user = "nobody";
2239  if (host == 0) host = "unknown";
2240 
2241  out
2242  << "# Generated by MBDyn StructMappingExtForce(" << uLabel << ")" << std::endl
2243  << "# " << user << "@" << host << std::endl
2244  << "# " << std::ctime(&t)
2245  << "# labels: " << (bLabels ? "on" : "off") << std::endl;
2246  Vec3 xRef(::Zero3);
2247  Mat3x3 RRef(::Eye3);
2248  if (pRefNode) {
2249  xRef = pRefNode->GetXCurr();
2250  RRef = pRefNode->GetRCurr();
2251 
2252  out
2253  << "# reference: " << pRefNode->GetLabel() << std::endl
2254  << "# position: " << xRef << std::endl
2255  << "# orientation: " << MatR2EulerAngles123(RRef)*dRaDegr << std::endl;
2256  }
2257 
2258  out
2259  << "# points: " << nPoints << std::endl;
2260 
2261  if (bGotSurface) {
2262  out << "# surface: " << surface << std::endl;
2263  }
2264 
2265  if (bGotOutput) {
2266  out << "# output: " << output << std::endl;
2267  }
2268 
2269  if (bGotOrder) {
2270  out << "# order: " << order << std::endl;
2271  }
2272 
2273  if (bGotBaseNode) {
2274  out << "# basenode: " << basenode << std::endl;
2275  }
2276 
2277  if (bGotWeight) {
2278  if (bWeightInf) {
2279  out << "# weight: inf" << std::endl;
2280  } else {
2281  out << "# weight: " << weight << std::endl;
2282  }
2283  }
2284 
2285  for (unsigned n = 0, p = 0; p < unsigned(nPoints); p++) {
2286  if (p > 0 && Nodes[p] != Nodes[p - 1]) {
2287  n++;
2288  }
2289 
2290  if (bLabels) {
2291  out << Labels[p] << " ";
2292  }
2293 
2294  Vec3 x;
2295  const StructNode *pNode(dynamic_cast<const StructNode *>(Nodes[p]));
2296  if (pNode != 0) {
2297  x = RRef.MulTV(pNode->GetXCurr() + pNode->GetRCurr()*Offsets[p] - xRef);
2298 
2299  } else {
2300  Vec3 h(::Zero3);
2301  if (NodesConn[n].pNode[0] != 0) {
2302  Vec3 e1(NodesConn[n].pNode[1]->GetXCurr() - NodesConn[n].pNode[0]->GetXCurr());
2303  Vec3 e2(NodesConn[n].pNode[3]->GetXCurr() - NodesConn[n].pNode[2]->GetXCurr());
2304  Vec3 e3(e1.Cross(e2));
2305  e3 /= e3.Norm();
2306 
2307  if (Nodes[p + 1] == Nodes[p]) {
2308  h = e3*NodesConn[n].h1;
2309 
2310  } else {
2311  h = e3*NodesConn[n].h2;
2312  }
2313  }
2314 
2315  x = RRef.MulTV(Nodes[p]->GetXCurr() + h - xRef);
2316  }
2317  out << x << std::endl;
2318  }
2319 
2320  if (HP.IsKeyWord("stop")) {
2321  throw NoErr(MBDYN_EXCEPT_ARGS);
2322  }
2323  }
2324 
2325  SpMapMatrixHandler *pH = 0;
2326  std::vector<uint32_t> MappedLabels;
2327  if (HP.IsKeyWord("mapped" "points" "number")) {
2328  int nMappedPoints = 0;
2329  if (HP.IsKeyWord("from" "file")) {
2330  nMappedPoints = -1;
2331 
2332  } else {
2333  nMappedPoints = HP.GetInt();
2334  if (nMappedPoints <= 0) {
2335  silent_cerr("StructMappingExtForce(" << uLabel << "): "
2336  "invalid mapped points number " << nMappedPoints
2337  << " at line " << HP.GetLineData() << std::endl);
2338  throw ErrGeneric(MBDYN_EXCEPT_ARGS);
2339  }
2340 
2341  nMappedPoints *= 3;
2342  }
2343 
2344  integer nCols = 3*nPoints;
2345  pH = ReadSparseMappingMatrix(HP, nMappedPoints, nCols);
2346  ASSERT((nMappedPoints%3) == 0);
2347  ASSERT(nCols == 3*nPoints);
2348  nMappedPoints /= 3;
2349 
2350  if (bLabels) {
2351  MappedLabels.resize(nMappedPoints);
2352  if (HP.IsKeyWord("mapped" "labels" "file")) {
2353  const char *sFileName = HP.GetFileName();
2354  if (sFileName == 0) {
2355  silent_cerr("StructMappingExtForce(" << uLabel << "): "
2356  "unable to read mapped labels file name "
2357  "at line " << HP.GetLineData() << std::endl);
2358  throw ErrGeneric(MBDYN_EXCEPT_ARGS);
2359  }
2360 
2361  std::ifstream in(sFileName);
2362  if (!in) {
2363  silent_cerr("StructMappingExtForce(" << uLabel << "): "
2364  "unable to open mapped labels file "
2365  "\"" << sFileName << "\" "
2366  "at line " << HP.GetLineData() << std::endl);
2367  throw ErrGeneric(MBDYN_EXCEPT_ARGS);
2368  }
2369 
2370  char c = in.get();
2371  while (c == '#') {
2372  do {
2373  c = in.get();
2374  } while (c != '\n');
2375  c = in.get();
2376  }
2377  in.putback(c);
2378 
2379  for (unsigned l = 0; l < unsigned(nMappedPoints); l++) {
2380  int i;
2381  in >> i;
2382  if (!in) {
2383  silent_cerr("StructMappingExtForce(" << uLabel << "): "
2384  "unable to read mapped label #" << l << "/" << nMappedPoints
2385  << " from mapped labels file \"" << sFileName << "\"" << std::endl);
2386  throw ErrGeneric(MBDYN_EXCEPT_ARGS);
2387  }
2388  if (i < 0) {
2389  silent_cerr("StructMappingExtForce(" << uLabel << "): "
2390  "invalid (negative) mapped label #" << l << "/" << nMappedPoints
2391  << " from mapped labels file \"" << sFileName << "\"" << std::endl);
2392  throw ErrGeneric(MBDYN_EXCEPT_ARGS);
2393  }
2394  MappedLabels[l] = i;
2395  }
2396 
2397  } else {
2398  for (unsigned l = 0; l < unsigned(nMappedPoints); l++) {
2399  int i = HP.GetInt();
2400  if (i < 0) {
2401  silent_cerr("StructMappingExtForce(" << uLabel << "): "
2402  "invalid (negative) mapped label #" << l << "/" << nMappedPoints
2403  << std::endl);
2404  throw ErrGeneric(MBDYN_EXCEPT_ARGS);
2405  }
2406  MappedLabels[l] = i;
2407  }
2408  }
2409 
2410  int duplicate = 0;
2411  for (unsigned l = 1; l < unsigned(nMappedPoints); l++) {
2412  for (unsigned c = 0; c < l; c++) {
2413  if (MappedLabels[l] == MappedLabels[c]) {
2414  duplicate++;
2415  silent_cerr("StructMappingExtForce(" << uLabel << "): "
2416  "duplicate mapped label " << MappedLabels[l] << ": "
2417  "#" << l << "==#" << c << std::endl);
2418  }
2419  }
2420  }
2421 
2422  if (duplicate) {
2423  silent_cerr("StructMappingExtForce(" << uLabel << "): "
2424  << duplicate << " duplicate mapped labels"
2425  << std::endl);
2426  throw ErrGeneric(MBDYN_EXCEPT_ARGS);
2427  }
2428  }
2429  }
2430 
2431  flag fOut = pDM->fReadOutput(HP, Elem::FORCE);
2432  Elem *pEl = 0;
2433  if (bMembrane) {
2434  SAFENEWWITHCONSTRUCTOR(pEl, StructMembraneMappingExtForce,
2435  StructMembraneMappingExtForce(uLabel, pDM, pRefNode,
2436  bUseReferenceNodeForces, bRotateReferenceNodeForces,
2437  Nodes, Offsets, Labels, NodesConn,
2438  pH,
2439  MappedLabels,
2440  bLabels, bOutputAccelerations, uRRot,
2441  pEFH, bSendAfterPredict, iCoupling, fOut));
2442 
2443  } else {
2444  SAFENEWWITHCONSTRUCTOR(pEl, StructMappingExtForce,
2445  StructMappingExtForce(uLabel, pDM, pRefNode,
2446  bUseReferenceNodeForces, bRotateReferenceNodeForces,
2447  Nodes, Offsets, Labels,
2448  pH,
2449  MappedLabels,
2450  bLabels, bOutputAccelerations, uRRot,
2451  pEFH, bSendAfterPredict, iCoupling, fOut));
2452  }
2453 
2454  return pEl;
2455 }
DataManager::fReadOutput
flag fReadOutput(MBDynParser &HP, const T &t) const
Definition: dataman.h:1064
Zero3
const Vec3 Zero3(0., 0., 0.)
flag
long int flag
Definition: mbdyn.h:43
output
static void output(const LoadableElem *pEl, OutputHandler &OH)
Definition: module-template.cc:83
MBDYN_EXCEPT_ARGS
#define MBDYN_EXCEPT_ARGS
Definition: except.h:63
Vec3
Definition: matvec3.h:98
HighParser::GetInt
virtual integer GetInt(integer iDefval=0)
Definition: parser.cc:1050
Vec3::Norm
doublereal Norm(void) const
Definition: matvec3.h:263
Eye3
const Mat3x3 Eye3(1., 0., 0., 0., 1., 0., 0., 0., 1.)
IncludeParser::GetFileName
virtual const char * GetFileName(enum Delims Del=DEFAULTDELIM)
Definition: parsinc.cc:673
order
enum @55 order
MBDynParser::GetPosRel
Vec3 GetPosRel(const ReferenceFrame &rf)
Definition: mbpar.cc:1331
HighParser::IsKeyWord
virtual bool IsKeyWord(const char *sKeyWord)
Definition: parser.cc:910
host
const char * host
Definition: autopilot.c:142
MatR2EulerAngles123
Vec3 MatR2EulerAngles123(const Mat3x3 &R)
Definition: matvec3.cc:893
dRaDegr
const doublereal dRaDegr
Definition: matvec3.cc:884
ASSERT
#define ASSERT(expression)
Definition: colamd.c:977
SAFENEWWITHCONSTRUCTOR
#define SAFENEWWITHCONSTRUCTOR(pnt, item, constructor)
Definition: mynewmem.h:698
StructDispNode::GetXCurr
virtual const Vec3 & GetXCurr(void) const
Definition: strnode.h:310
NoErr
Definition: except.h:79
c
static std::stack< cleanup * > c
Definition: cleanup.cc:59
HighParser::GetYesNo
virtual bool GetYesNo(bool &bRet)
Definition: parser.cc:1022
HighParser::IsArg
virtual bool IsArg(void)
Definition: parser.cc:807
Elem
Definition: elem.h:75
doublereal
double doublereal
Definition: colamd.c:52
integer
long int integer
Definition: colamd.c:51
IncludeParser::GetLineData
virtual HighParser::ErrOut GetLineData(void) const
Definition: parsinc.cc:697
WithLabel::GetLabel
unsigned int GetLabel(void) const
Definition: withlab.cc:62
DataManager::ReadNode
Node * ReadNode(MBDynParser &HP, Node::Type type) const
Definition: dataman3.cc:2309
ReadExtForce
void ReadExtForce(DataManager *pDM, MBDynParser &HP, unsigned int uLabel, ExtFileHandlerBase *&pEFH, bool &bSendAfterPredict, int &iCoupling)
Definition: extforce.cc:1141
ReadSparseMappingMatrix
SpMapMatrixHandler * ReadSparseMappingMatrix(MBDynParser &HP, integer &nRows, integer &nCols)
Definition: modalmappingext.cc:402
HighParser::GetReal
virtual doublereal GetReal(const doublereal &dDefval=0.0)
Definition: parser.cc:1056

Here is the call graph for this function: