Xyce  6.1
N_DEV_ArtificialParameters.C
Go to the documentation of this file.
1 //-----------------------------------------------------------------------------
2 // Copyright Notice
3 //
4 // Copyright 2002 Sandia Corporation. Under the terms
5 // of Contract DE-AC04-94AL85000 with Sandia Corporation, the U.S.
6 // Government retains certain rights in this software.
7 //
8 // Xyce(TM) Parallel Electrical Simulator
9 // Copyright (C) 2002-2015 Sandia Corporation
10 //
11 // This program is free software: you can redistribute it and/or modify
12 // it 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.
15 //
16 // This program is distributed in the hope that it will be useful,
17 // but WITHOUT ANY WARRANTY; without even the implied warranty of
18 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 // GNU General Public License for more details.
20 //
21 // You should have received a copy of the GNU General Public License
22 // along with this program. If not, see <http://www.gnu.org/licenses/>.
23 //-----------------------------------------------------------------------------
24 
25 //-------------------------------------------------------------------------
26 // Filename : $RCSfile: N_DEV_ArtificialParameters.C,v $
27 //
28 // Purpose : Implement the MOSFET Level 1 static model
29 //
30 // Special Notes :
31 //
32 // Creator : Eric R. Keiter, SNL, Parallel Computational Sciences
33 //
34 // Creation Date : 02/28/00
35 //
36 // Revision Information:
37 // ---------------------
38 //
39 // Revision Number: $Revision: 1.2.2.1 $
40 //
41 // Revision Date : $Date: 2015/04/02 18:20:11 $
42 //
43 // Current Owner : $Author: tvrusso $
44 //-------------------------------------------------------------------------
45 #include <Xyce_config.h>
46 
48 #include <N_DEV_Const.h>
49 #include <N_DEV_DeviceMgr.h>
50 #include <N_ERH_Message.h>
51 
52 #include <N_DEV_MOSFET1.h>
53 #include <N_DEV_BJT.h>
54 #include <N_DEV_Diode.h>
55 #include <N_DEV_Vsrc.h>
56 
57 namespace Xyce {
58 namespace Device {
59 namespace ArtificialParameters {
60 
61 SolverState &
63 {
64  return device_manager.solState_;
65 }
66 
67 const SolverState &
68 ArtificialParameter::getSolverState(const DeviceMgr &device_manager) const
69 {
70  return device_manager.solState_;
71 }
72 
75 {
76  return device_manager.devOptions_;
77 }
78 
79 const DeviceOptions &
81 {
82  return device_manager.devOptions_;
83 }
84 
85 
88 {
89  return device_manager.modelGroupInstanceVector_;
90 }
91 
94 {
95  return device_manager.modelGroupInstanceVector_;
96 }
97 
100 {
101  return device_manager.instancePtrVec_;
102 }
103 
104 const InstanceVector &
106 {
107  return device_manager.instancePtrVec_;
108 }
109 
110 bool MOSFETGainScaleParam::setValue(DeviceMgr &device_manager, double value)
111 {
112  getSolverState(device_manager).gainScale[0] = value;
113  getSolverState(device_manager).artParameterFlag = true;
114  return true;
115 }
116 
117 double MOSFETGainScaleParam::getValue(const DeviceMgr &device_manager) const
118 {
119  return getSolverState(device_manager).gainScale[0];
120 }
121 
122 bool MOSFETNLTermScaleParam::setValue(DeviceMgr &device_manager, double value)
123 {
124  getSolverState(device_manager).nltermScale = value;
125  getSolverState(device_manager).artParameterFlag = true;
126  return true;
127 }
128 
129 double MOSFETNLTermScaleParam::getValue(const DeviceMgr &device_manager) const
130 {
131  return getSolverState(device_manager).nltermScale;
132 }
133 
134 bool MOSFETLParam::setValue(DeviceMgr &device_manager, double value)
135 {
136  bool success = true;
137 
138  getSolverState(device_manager).sizeParameterFlag = true;
139 
140  // now loop over all the mosfet instances, and change the l.
141  DeviceMgr::ModelTypeInstanceVectorMap::const_iterator model_group_it = getModelTypeInstanceVectorMap(device_manager).find(MOSFET1::Traits::modelGroup());
142  if (model_group_it != getModelTypeInstanceVectorMap(device_manager).end()) {
143  for (InstanceVector::const_iterator it = (*model_group_it).second.begin(); it != (*model_group_it).second.end(); ++it)
144  {
145  success = (*it)->setParam("l", value);
146  success = success && (*it)->processParams ();
147  }
148  }
149 
150  // getDeviceOptions(device_manager).defl = value; // Shouldn't this be set?
151 
152  return success;
153 }
154 
155 double MOSFETLParam::getValue(const DeviceMgr &device_manager) const
156 {
157  return getDeviceOptions(device_manager).defl;
158 }
159 
160 bool MOSFETWParam::setValue(DeviceMgr &device_manager, double value)
161 {
162  bool success = true;
163 
164  getSolverState(device_manager).sizeParameterFlag = true;
165 
166  // now loop over all the mosfet instances, and change the w.
167  DeviceMgr::ModelTypeInstanceVectorMap::const_iterator model_group_it = getModelTypeInstanceVectorMap(device_manager).find(MOSFET1::Traits::modelGroup());
168  if (model_group_it != getModelTypeInstanceVectorMap(device_manager).end()) {
169  for (InstanceVector::const_iterator it = (*model_group_it).second.begin(); it != (*model_group_it).second.end(); ++it)
170  {
171  success = (*it)->setParam("w", value);
172  success = success && (*it)->processParams ();
173  }
174  }
175 
176  // getDeviceOptions(device_manager).defw = value; // Shouldn't this be set?
177 
178  return success;
179 }
180 
181 double MOSFETWParam::getValue(const DeviceMgr &device_manager) const
182 {
183  return getDeviceOptions(device_manager).defw;
184 }
185 
186 bool MOSFETSizeScaleParam::setValue(DeviceMgr &device_manager, double value)
187 {
188  bool success = true;
189 
190  getSolverState(device_manager).sizeParameterFlag = true;
191  getSolverState(device_manager).sizeScale = value;
192 
193  // What we want at val = 0.0. For all the lengths and widths to have a
194  // ratio of: L=5u W=175u or L=5u W=270u. Compromise. L/W = 5/200,
195  // with L actually being 5u.
196 
197  double length0 = getDeviceOptions(device_manager).length0;
198  double width0 = getDeviceOptions(device_manager).width0;
199 
200  DeviceMgr::ModelTypeInstanceVectorMap::const_iterator model_group_it = getModelTypeInstanceVectorMap(device_manager).find(MOSFET1::Traits::modelGroup());
201  if (model_group_it != getModelTypeInstanceVectorMap(device_manager).end()) {
202  for (InstanceVector::const_iterator it = (*model_group_it).second.begin(); it != (*model_group_it).second.end(); ++it)
203  {
204  success = (*it)->scaleParam("l", value, length0);
205  success = success || (*it)->scaleParam("w", value, width0);
206  success = success && (*it)->processParams();
207  }
208  }
209 
210  return success;
211 }
212 
213 double MOSFETSizeScaleParam::getValue(const DeviceMgr &device_manager) const
214 {
215  return 0.0;
216 }
217 
218 bool MOSFETTOXParam::setValue(DeviceMgr &device_manager, double value)
219 {
220  bool success = true;
221 
222  getSolverState(device_manager).sizeParameterFlag = true;
223  getSolverState(device_manager).sizeScale = value;
224 
225  // What we want at val = 0.0. For all the lengths and widths to have a
226  // ratio of: L=5u W=175u or L=5u W=270u. Compromise. L/W = 5/200,
227  // with L actually being 5u.
228 
229  double tox0 = getDeviceOptions(device_manager).tox0;
230 
231  DeviceMgr::ModelTypeInstanceVectorMap::const_iterator model_group_it = getModelTypeInstanceVectorMap(device_manager).find(MOSFET1::Traits::modelGroup());
232  if (model_group_it != getModelTypeInstanceVectorMap(device_manager).end()) {
233  for (InstanceVector::const_iterator it = (*model_group_it).second.begin(); it != (*model_group_it).second.end(); ++it)
234  {
235  success = (*it)->scaleParam("tox", value, tox0);
236  success = success && (*it)->processParams();
237  success = success && (*it)->processInstanceParams();
238  }
239  }
240 
241  return success;
242 }
243 
244 double MOSFETTOXParam::getValue(const DeviceMgr &device_manager) const
245 {
246  return 0.0;
247 }
248 
249 bool BJTBFParam::setValue(DeviceMgr &device_manager, double value)
250 {
251  bool success = true;
252 
253  DeviceMgr::ModelTypeInstanceVectorMap::const_iterator model_group_it = getModelTypeInstanceVectorMap(device_manager).find(BJT::Traits::modelGroup());
254  if (model_group_it != getModelTypeInstanceVectorMap(device_manager).end()) {
255  for (InstanceVector::const_iterator it = (*model_group_it).second.begin(); it != (*model_group_it).second.end(); ++it)
256  {
257  success = (*it)->scaleParam("bf", value, 0.0);
258  success = success && (*it)->processParams();
259  success = success && (*it)->processInstanceParams();
260  }
261  }
262 
263  return success;
264 }
265 
266 double BJTBFParam::getValue(const DeviceMgr &device_manager) const
267 {
268  return 0.0;
269 }
270 
271 bool BJTNFParam::setValue(DeviceMgr &device_manager, double value)
272 {
273  bool success = true;
274 
275  DeviceMgr::ModelTypeInstanceVectorMap::const_iterator model_group_it = getModelTypeInstanceVectorMap(device_manager).find(BJT::Traits::modelGroup());
276  if (model_group_it != getModelTypeInstanceVectorMap(device_manager).end()) {
277  for (InstanceVector::const_iterator it = (*model_group_it).second.begin(); it != (*model_group_it).second.end(); ++it)
278  {
279  success = (*it)->scaleParam("nf", value, 0.0);
280  success = success && (*it)->processParams();
281  success = success && (*it)->processInstanceParams();
282  }
283  }
284 
285  return success;
286 }
287 
288 double BJTNFParam::getValue(const DeviceMgr &device_manager) const
289 {
290  return 0.0;
291 }
292 
293 bool BJTNRParam::setValue(DeviceMgr &device_manager, double value)
294 {
295  bool success = true;
296 
297  DeviceMgr::ModelTypeInstanceVectorMap::const_iterator model_group_it = getModelTypeInstanceVectorMap(device_manager).find(BJT::Traits::modelGroup());
298  if (model_group_it != getModelTypeInstanceVectorMap(device_manager).end()) {
299  for (InstanceVector::const_iterator it = (*model_group_it).second.begin(); it != (*model_group_it).second.end(); ++it)
300  {
301  success = (*it)->scaleParam("nr", value, 0.0);
302  success = success && (*it)->processParams();
303  success = success && (*it)->processInstanceParams();
304  }
305  }
306 
307  return success;
308 }
309 
310 double BJTNRParam::getValue(const DeviceMgr &device_manager) const
311 {
312  return 0.0;
313 }
314 
315 bool BJTExpOrdParam::setValue(DeviceMgr &device_manager, double value)
316 {
317  getDeviceOptions(device_manager).exp_order = value;
318  getSolverState(device_manager).bjtArtParameterFlag = true;
319  return true;
320 }
321 
322 double BJTExpOrdParam::getValue(const DeviceMgr &device_manager) const
323 {
324  return 0.0;
325 }
326 
327 bool DiodeNParam::setValue(DeviceMgr &device_manager, double value)
328 {
329  bool success = true;
330 
331  DeviceMgr::ModelTypeInstanceVectorMap::const_iterator model_group_it = getModelTypeInstanceVectorMap(device_manager).find(Diode::Traits::modelGroup());
332  if (model_group_it != getModelTypeInstanceVectorMap(device_manager).end()) {
333  for (InstanceVector::const_iterator it = (*model_group_it).second.begin(); it != (*model_group_it).second.end(); ++it)
334  {
335  success = (*it)->scaleParam("n", value, 10.0);
336  success = success && (*it)->processParams();
337  success = success && (*it)->processInstanceParams();
338  }
339  }
340 
341  return success;
342 }
343 
344 double DiodeNParam::getValue(const DeviceMgr &device_manager) const
345 {
346  return getDeviceOptions(device_manager).defw;
347 }
348 
349 bool VsrcScaleParam::setValue(DeviceMgr &device_manager, double value)
350 {
351  bool success = true;
352 
353  DeviceMgr::ModelTypeInstanceVectorMap::const_iterator model_group_it = getModelTypeInstanceVectorMap(device_manager).find(Vsrc::Traits::modelGroup());
354  if (model_group_it != getModelTypeInstanceVectorMap(device_manager).end()) {
355  for (InstanceVector::const_iterator it = (*model_group_it).second.begin(); it != (*model_group_it).second.end(); ++it)
356  {
357  success = (*it)->scaleDefaultParam(value);
358  success = (*it)->processParams();
359  }
360  }
361 
362  return success;
363 }
364 
365 double VsrcScaleParam::getValue(const DeviceMgr &device_manager) const
366 {
367  return getDeviceOptions(device_manager).defw;
368 }
369 
370 bool PDEAlphaParam::setValue(DeviceMgr &device_manager, double value)
371 {
372  getSolverState(device_manager).pdeAlpha = value; // not important - part of planned refactor.
373 
374  if (!getSolverState(device_manager).PDEcontinuationFlag)
375  {
376  Report::DevelFatal().in("DeviceMgr::setParam") << "Tried to set pdeAlpha without first calling enablePDEContinuation";
377  }
378 
379  for (InstanceVector::const_iterator it = getInstanceVector(device_manager).begin(), end = getInstanceVector(device_manager).end(); it != end; ++it)
380  {
381  (*it)->setPDEContinuationAlpha(value);
382  }
383 
384  return true;
385 }
386 
387 double PDEAlphaParam::getValue(const DeviceMgr &device_manager) const
388 {
389  return getSolverState(device_manager).pdeAlpha;
390 }
391 
392 bool PDEBetaParam::setValue(DeviceMgr &device_manager, double value)
393 {
394  getSolverState(device_manager).PDEcontinuationFlag = true;
395 
396  for (InstanceVector::const_iterator it = getInstanceVector(device_manager).begin(), end = getInstanceVector(device_manager).end(); it != end; ++it)
397  {
398  (*it)->setPDEContinuationBeta(value);
399  }
400 
401  return true;
402 }
403 
404 double PDEBetaParam::getValue(const DeviceMgr &device_manager) const
405 {
406  return 0.0;
407 }
408 
409 bool PDEChargeAlphaParam::setValue(DeviceMgr &device_manager, double value)
410 {
411  getSolverState(device_manager).chargeAlpha = value;
412  getSolverState(device_manager).chargeHomotopy = true;
413 
414  return true;
415 }
416 
417 double PDEChargeAlphaParam::getValue(const DeviceMgr &device_manager) const
418 {
419  return getSolverState(device_manager).chargeAlpha;
420 }
421 
422 bool GSteppingParam::setValue(DeviceMgr &device_manager, double value)
423 {
424  return true;
425 }
426 
427 double GSteppingParam::getValue(const DeviceMgr &device_manager) const
428 {
429  return getSolverState(device_manager).chargeAlpha;
430 }
431 
432 bool GMinParam::setValue(DeviceMgr &device_manager, double value)
433 {
434  getDeviceOptions(device_manager).gmin = getDeviceOptions(device_manager).gmin_orig*value + getDeviceOptions(device_manager).gmin_init*(1.0 - value);
435 
436  return true;
437 }
438 
439 double GMinParam::getValue(const DeviceMgr &device_manager) const
440 {
441  return getDeviceOptions(device_manager).gmin;
442 }
443 
444 bool TempParam::setValue(DeviceMgr &device_manager, double value)
445 {
446  device_manager.updateTemperature(value);
447 
448  return true;
449 }
450 
451 double TempParam::getValue(const DeviceMgr &device_manager) const
452 {
453  return getDeviceOptions(device_manager).temp.getImmutableValue<double>() - CONSTCtoK;
454 }
455 
456 } // namespace ArtificialParameters
457 } // namespace Device
458 } // namespace Xyce
virtual bool setValue(DeviceMgr &device_manager, double value)
virtual bool setValue(DeviceMgr &device_manager, double value)
virtual double getValue(const DeviceMgr &device_manager) const
std::vector< DeviceInstance * > InstanceVector
virtual double getValue(const DeviceMgr &device_manager) const
virtual double getValue(const DeviceMgr &device_manager) const
virtual double getValue(const DeviceMgr &device_manager) const
virtual bool setValue(DeviceMgr &device_manager, double value)
#define CONSTCtoK
Definition: N_DEV_Const.h:52
virtual double getValue(const DeviceMgr &device_manager) const
virtual bool setValue(DeviceMgr &device_manager, double value)
InstanceVector instancePtrVec_
Pure virtual class to augment a linear system.
virtual double getValue(const DeviceMgr &device_manager) const
virtual bool setValue(DeviceMgr &device_manager, double value)
virtual bool setValue(DeviceMgr &device_manager, double value)
virtual double getValue(const DeviceMgr &device_manager) const
std::vector< double > gainScale
ModelTypeInstanceVectorMap & getModelTypeInstanceVectorMap(DeviceMgr &device_manager)
virtual bool setValue(DeviceMgr &device_manager, double value)
const T & value(const ParameterBase &entity, const Descriptor &descriptor)
Returns the value of the parameter for the entity.
Definition: N_DEV_Pars.h:1224
virtual bool setValue(DeviceMgr &device_manager, double value)
virtual double getValue(const DeviceMgr &device_manager) const
virtual bool setValue(DeviceMgr &device_manager, double value)
virtual double getValue(const DeviceMgr &device_manager) const
virtual bool setValue(DeviceMgr &device_manager, double value)
virtual double getValue(const DeviceMgr &device_manager) const
DeviceOptions & getDeviceOptions(DeviceMgr &device_manager)
virtual double getValue(const DeviceMgr &device_manager) const
std::map< ModelTypeId, InstanceVector > ModelTypeInstanceVectorMap
virtual double getValue(const DeviceMgr &device_manager) const
virtual double getValue(const DeviceMgr &device_manager) const
virtual bool setValue(DeviceMgr &device_manager, double value)
virtual bool setValue(DeviceMgr &device_manager, double value)
virtual double getValue(const DeviceMgr &device_manager) const
InstanceVector & getInstanceVector(DeviceMgr &device_manager)
virtual bool setValue(DeviceMgr &device_manager, double value)
static const ModelTypeId modelGroup()
Returns the model group identifier.
DeviceOptions devOptions_
user-defined options:
SolverState solState_
real time solver data:
virtual bool setValue(DeviceMgr &device_manager, double value)
virtual bool setValue(DeviceMgr &device_manager, double value)
bool updateTemperature(double val)
virtual double getValue(const DeviceMgr &device_manager) const
virtual bool setValue(DeviceMgr &device_manager, double value)
virtual double getValue(const DeviceMgr &device_manager) const
virtual bool setValue(DeviceMgr &device_manager, double value)
virtual double getValue(const DeviceMgr &device_manager) const
ModelTypeInstanceVectorMap modelGroupInstanceVector_
virtual bool setValue(DeviceMgr &device_manager, double value)
virtual double getValue(const DeviceMgr &device_manager) const