Arcane  4.2.1.0
Documentation développeur
Chargement...
Recherche...
Aucune correspondance
StandardCaseFunction.cc
1// -*- tab-width: 2; indent-tabs-mode: nil; coding: utf-8-with-signature -*-
2//-----------------------------------------------------------------------------
3// Copyright 2000-2022 CEA (www.cea.fr) IFPEN (www.ifpenergiesnouvelles.com)
4// See the top-level COPYRIGHT file for details.
5// SPDX-License-Identifier: Apache-2.0
6//-----------------------------------------------------------------------------
7/*---------------------------------------------------------------------------*/
8/* StandardCaseFunction.cc (C) 2000-2016 */
9/* */
10/* Classe gérant une fonction standard du jeu de données. */
11/*---------------------------------------------------------------------------*/
12/*---------------------------------------------------------------------------*/
13
14#include "arcane/utils/ArcanePrecomp.h"
15
16#include "arcane/utils/NotImplementedException.h"
17#include "arcane/utils/TraceInfo.h"
18#include "arcane/utils/Real3.h"
19#include "arcane/StandardCaseFunction.h"
20
21/*---------------------------------------------------------------------------*/
22/*---------------------------------------------------------------------------*/
23
24ARCANE_BEGIN_NAMESPACE
25
26/*---------------------------------------------------------------------------*/
27/*---------------------------------------------------------------------------*/
28
29StandardCaseFunction::
30StandardCaseFunction(const CaseFunctionBuildInfo& info)
31: CaseFunction(info)
32{
33}
34
35/*---------------------------------------------------------------------------*/
36/*---------------------------------------------------------------------------*/
37
38StandardCaseFunction::
39~StandardCaseFunction()
40{
41}
42
43/*---------------------------------------------------------------------------*/
44/*---------------------------------------------------------------------------*/
45
46void StandardCaseFunction::
47value(Real param,Real& v) const
48{
49 ARCANE_UNUSED(param);
50 ARCANE_UNUSED(v);
51 throw NotImplementedException(A_FUNCINFO);
52}
53
54/*---------------------------------------------------------------------------*/
55/*---------------------------------------------------------------------------*/
56
57void StandardCaseFunction::
58value(Real param,Integer& v) const
59{
60 ARCANE_UNUSED(param);
61 ARCANE_UNUSED(v);
62 throw NotImplementedException(A_FUNCINFO);
63}
64
65/*---------------------------------------------------------------------------*/
66/*---------------------------------------------------------------------------*/
67
68void StandardCaseFunction::
69value(Real param,bool& v) const
70{
71 ARCANE_UNUSED(param);
72 ARCANE_UNUSED(v);
73 throw NotImplementedException(A_FUNCINFO);
74}
75
76/*---------------------------------------------------------------------------*/
77/*---------------------------------------------------------------------------*/
78
79void StandardCaseFunction::
80value(Real param,String& v) const
81{
82 ARCANE_UNUSED(param);
83 ARCANE_UNUSED(v);
84 throw NotImplementedException(A_FUNCINFO);
85}
86
87/*---------------------------------------------------------------------------*/
88/*---------------------------------------------------------------------------*/
89
90void StandardCaseFunction::
91value(Real param,Real3& v) const
92{
93 ARCANE_UNUSED(param);
94 ARCANE_UNUSED(v);
95 throw NotImplementedException(A_FUNCINFO);
96}
97
98/*---------------------------------------------------------------------------*/
99/*---------------------------------------------------------------------------*/
100
101void StandardCaseFunction::
102value(Integer param,Real& v) const
103{
104 ARCANE_UNUSED(param);
105 ARCANE_UNUSED(v);
106 throw NotImplementedException(A_FUNCINFO);
107}
108
109/*---------------------------------------------------------------------------*/
110/*---------------------------------------------------------------------------*/
111
112void StandardCaseFunction::
113value(Integer param,Integer& v) const
114{
115 ARCANE_UNUSED(param);
116 ARCANE_UNUSED(v);
117 throw NotImplementedException(A_FUNCINFO);
118}
119
120/*---------------------------------------------------------------------------*/
121/*---------------------------------------------------------------------------*/
122
123void StandardCaseFunction::
124value(Integer param,bool& v) const
125{
126 ARCANE_UNUSED(param);
127 ARCANE_UNUSED(v);
128 throw NotImplementedException(A_FUNCINFO);
129}
130
131/*---------------------------------------------------------------------------*/
132/*---------------------------------------------------------------------------*/
133
134void StandardCaseFunction::
135value(Integer param,String& v) const
136{
137 ARCANE_UNUSED(param);
138 ARCANE_UNUSED(v);
139 throw NotImplementedException(A_FUNCINFO);
140}
141
142/*---------------------------------------------------------------------------*/
143/*---------------------------------------------------------------------------*/
144
145void StandardCaseFunction::
146value(Integer param,Real3& v) const
147{
148 ARCANE_UNUSED(param);
149 ARCANE_UNUSED(v);
150 throw NotImplementedException(A_FUNCINFO);
151}
152
153/*---------------------------------------------------------------------------*/
154/*---------------------------------------------------------------------------*/
155
156IBinaryMathFunctor<Real,Real,Real>* StandardCaseFunction::
157getFunctorRealRealToReal()
158{
159 return 0;
160}
161
162/*---------------------------------------------------------------------------*/
163/*---------------------------------------------------------------------------*/
164
165IBinaryMathFunctor<Real,Real3,Real>* StandardCaseFunction::
166getFunctorRealReal3ToReal()
167{
168 return 0;
169}
170
171/*---------------------------------------------------------------------------*/
172/*---------------------------------------------------------------------------*/
173
174IBinaryMathFunctor<Real,Real,Real3>* StandardCaseFunction::
175getFunctorRealRealToReal3()
176{
177 return 0;
178}
179
180/*---------------------------------------------------------------------------*/
181/*---------------------------------------------------------------------------*/
182
183IBinaryMathFunctor<Real,Real3,Real3>* StandardCaseFunction::
184getFunctorRealReal3ToReal3()
185{
186 return 0;
187}
188
189/*---------------------------------------------------------------------------*/
190/*---------------------------------------------------------------------------*/
191
192ARCANE_END_NAMESPACE
193
194/*---------------------------------------------------------------------------*/
195/*---------------------------------------------------------------------------*/
196
Arcane::CaseFunctionBuildInfo
Informations pour construire une instance de CaseFunction.
Definition CaseFunction.h:42
Arcane::CaseFunction::CaseFunction
CaseFunction(const CaseFunctionBuildInfo &info)
Construit une fonction du jeu de données.
Definition CaseFunction.cc:46
Arcane::IBinaryMathFunctor
Interface d'une fonction mathématique binaire.
Definition IMathFunctor.h:31
Arcane::NotImplementedException
Exception lorsqu'une fonction n'est pas implémentée.
Definition arccore/src/base/arccore/base/NotImplementedException.h:33
Arcane::Real3
Classe gérant un vecteur réel de 3 dimensions.
Definition arccore/src/base/arccore/base/Real3.h:128
Arcane::StandardCaseFunction::value
void value(Real param, Real &v) const override
Valeur v de l'option pour le paramètre param.
Definition StandardCaseFunction.cc:47
Arcane::String
Chaîne de caractères unicode.
Definition arccore/src/base/arccore/base/String.h:70
Arcane::Integer
Int32 Integer
Type représentant un entier.
Definition ArccoreGlobal.h:293
Arcane::Real
double Real
Type représentant un réel.
Definition ArccoreGlobal.h:275