Xyce  6.1
N_ANP_OutputMgrAdapter.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_ANP_OutputMgrAdapter.C,v $
27 //
28 // Purpose :
29 //
30 // Special Notes :
31 //
32 // Creator : Richard Schiek, SNL, Electrical and Microsystem Modeling
33 //
34 // Creation Date : 01/24/08
35 //
36 // Revision Information:
37 // ---------------------
38 //
39 // Revision Number: $Revision: 1.48.2.1 $
40 //
41 // Revision Date : $Date: 2015/04/02 18:20:07 $
42 //
43 // Current Owner : $Author: tvrusso $
44 //-----------------------------------------------------------------------------
45 #include <Xyce_config.h>
46 
47 #include <N_ANP_OutputMgrAdapter.h>
48 
49 #include <N_ANP_NoiseData.h>
50 
51 #include <N_DEV_DeviceMgr.h>
52 #include <N_IO_FourierMgr.h>
53 #include <N_IO_InitialConditions.h>
54 #include <N_IO_MeasureManager.h>
55 #include <N_IO_Objective.h>
56 #include <N_IO_OutputMgr.h>
57 #include <N_IO_OutputROM.h>
58 #include <N_IO_OutputMOR.h>
59 #include <N_IO_OutputResults.h>
60 #include <N_IO_OutputResponse.h>
61 #include <N_IO_RestartMgr.h>
62 #include <N_TOP_Topology.h>
63 
64 
65 namespace Xyce {
66 namespace Analysis {
67 
68 //-----------------------------------------------------------------------------
69 // Function : OutputMgrAdapter::OutputMgrAdapter( )
70 // Purpose : constructor
71 // Special Notes :
72 // Scope : public
73 // Creator :
74 // Creation Date :
75 //-----------------------------------------------------------------------------
77  Parallel::Machine comm,
78  IO::OutputMgr & output_manager,
79  IO::Measure::Manager & measure_manager,
80  IO::FourierMgr & fourier_manager,
81  IO::ObjectiveManager & objective_manager,
82  IO::InitialConditionsManager & initial_conditions_manager,
83  Device::DeviceMgr & device_manager,
84  Topo::Topology & topology,
85  IO::RestartMgr & restart_manager)
86  : comm_(comm),
87  outputManager_(output_manager),
88  measureManager_(measure_manager),
89  fourierManager_(fourier_manager),
90  objectiveManager_(objective_manager),
91  initialConditionsManager_(initial_conditions_manager),
92  deviceManager_(device_manager),
93  topology_(topology),
94  restartManager_(restart_manager),
95  outputMOR_(0),
96  outputResults_(0),
97  outputResponse_(0),
98  stepSweepVector_(),
99  dcSweepVector_(),
100  stepAnalysisStepNumber_(0),
101  stepAnalysisMaxSteps_(0),
102  dcAnalysisStepNumber_(0),
103  dcAnalysisMaxSteps_(0)
104 {}
105 
107 {
108  delete outputMOR_;
109  delete outputResults_;
110 }
111 
112 
113 void
115  const StepEvent & event)
116 {
117  if (event.state_ == StepEvent::STEP_STARTED)
118  stepAnalysisStepNumber_ = event.count_;
119  else if (event.state_ == StepEvent::INITIALIZE)
120  stepAnalysisMaxSteps_ = event.count_;
121 }
122 
123 
124 void OutputMgrAdapter::addOutputResults(const Util::OptionBlock & option_block)
125 {
126  if (!outputResults_)
127  outputResults_ = new IO::OutputResults(outputManager_.getNetlistFilename());
128 
129  outputResults_->addResultParams(option_block);
130 }
131 
132 void OutputMgrAdapter::addOutputResponse(const Util::OptionBlock & option_block)
133 {
134  if (!outputResponse_)
135  outputResponse_ = new IO::OutputResponse();
136 }
137 
138 void
140  const Analysis::SweepVector & sweep_vector)
141 {
142  stepSweepVector_ = sweep_vector;
143 }
144 
145 void
147  const Analysis::SweepVector & sweep_vector)
148 {
149  dcSweepVector_ = sweep_vector;
150 }
151 
152 bool
154 {
155  return restartManager_.isRestart();
156 }
157 
158 void
159 OutputMgrAdapter::dumpRestart(Parallel::Communicator &parallel_communicator, Analysis::AnalysisManager &analysis_manager, double current_time) const
160 {
161  IO::dumpRestartData(
162  parallel_communicator,
163  topology_,
164  analysis_manager,
166  restartManager_.getJobName(),
167  restartManager_.getPack(),
168  current_time);
169 }
170 
171 
172 void
174  double time,
175  Linear::Vector & currSolutionPtr,
176  Linear::Vector & stateVecPtr,
177  Linear::Vector & storeVecPtr,
178  Linear::Vector & lead_current_vector,
179  Linear::Vector & junction_voltage_vector,
180  std::vector<double> & objectiveVec_,
181  std::vector<double> & dOdpVec_,
182  std::vector<double> & dOdpAdjVec_,
183  std::vector<double> & scaled_dOdpVec_,
184  std::vector<double> & scaled_dOdpAdjVec_,
185  bool skipPrintLineOutput)
186 {
187  fourierManager_.updateFourierData(comm_, time, &currSolutionPtr);
188 
189  measureManager_.updateTranMeasures(comm_, time, &currSolutionPtr, &stateVecPtr, &storeVecPtr);
190 
191  outputManager_.output(
194  currSolutionPtr, stateVecPtr, storeVecPtr, lead_current_vector, junction_voltage_vector, objectiveVec_,
195  dOdpVec_, dOdpAdjVec_, scaled_dOdpVec_, scaled_dOdpAdjVec_,
196  skipPrintLineOutput);
197 
198  if (outputResponse_) {
199  outputResponse_->saveResponseVarValues(comm_, time, currSolutionPtr);
200  outputResponse_->send(comm_,
201  &currSolutionPtr, 0, &stateVecPtr, &storeVecPtr,
202  &objectiveVec_, &dOdpVec_, &dOdpAdjVec_, &scaled_dOdpVec_, &scaled_dOdpAdjVec_);
203  }
204 
205  // transient values for the objective function call.
206  double arg1 = time;
207  double arg2 = 0.0;
208 
209  objectiveManager_.outputObjective(comm_, outputManager_.getOpBuilderManager(), outputManager_, outputManager_.getCircuitTime(), arg1, arg2, currSolutionPtr, stateVecPtr, storeVecPtr);
210 }
211 
212 void
214  int dcStepNumber,
215  Linear::Vector & currSolutionPtr,
216  Linear::Vector & stateVecPtr,
217  Linear::Vector & storeVecPtr,
218  Linear::Vector & lead_current_vector,
219  Linear::Vector & junction_voltage_vector,
220  std::vector<double> & objectiveVec_,
221  std::vector<double> & dOdpVec_,
222  std::vector<double> & dOdpAdjVec_,
223  std::vector<double> & scaled_dOdpVec_,
224  std::vector<double> & scaled_dOdpAdjVec_)
225 {
226  measureManager_.updateDCMeasures(comm_, dcSweepVector_, &currSolutionPtr, &stateVecPtr, &storeVecPtr);
227 
228  outputManager_.output(
229  comm_, 0.0, deviceManager_.getParamAndReduce("TEMP"),
231  dcStepNumber, dcAnalysisMaxSteps_, dcSweepVector_,
232  currSolutionPtr, stateVecPtr, storeVecPtr, lead_current_vector, junction_voltage_vector, objectiveVec_,
233  dOdpVec_, dOdpAdjVec_, scaled_dOdpVec_, scaled_dOdpAdjVec_);
234 
235  if (outputResponse_)
236  outputResponse_->saveResponseVarValues(comm_, 0.0, currSolutionPtr);
237 
238  // dc values for the objective function call.
239  double arg1 = 0.0;
240  double arg2 = 0.0;
241 
242  if (dcSweepVector_.size() > 0)
243  arg1 = dcSweepVector_[0].currentVal;
244  if (dcSweepVector_.size() > 1)
245  arg2 = dcSweepVector_[1].currentVal;
246 
247  objectiveManager_.outputObjective(comm_, outputManager_.getOpBuilderManager(), outputManager_, outputManager_.getCircuitTime(), arg1, arg2, currSolutionPtr, stateVecPtr, storeVecPtr);
248 }
249 
250 
251 void
253  const Linear::Vector & currSolutionPtr,
254  const Linear::Vector & currStatePtr,
255  const Linear::Vector & currStorePtr,
256  const Linear::Vector & lead_current_vector,
257  const Linear::Vector & junction_voltage_vector)
258 {
259  if (!outputResults_)
260  outputResults_ = new IO::OutputResults(outputManager_.getNetlistFilename());
261 
262  outputResults_->output(comm_, outputManager_, outputManager_.getCircuitTime(), stepSweepVector_, stepAnalysisStepNumber_, currSolutionPtr, currStatePtr, currStorePtr, lead_current_vector, junction_voltage_vector);
263 }
264 
265 void
267 {
268  outputManager_.steppingComplete();
269  if (outputResults_)
270  outputResults_->steppingComplete();
271 }
272 
273 void
275 {
276  outputManager_.finishOutput();
277 }
278 
279 bool
281  Linear::Vector & solnVec,
282  Linear::Vector & flagVec)
283 {
284  return initialConditionsManager_.setupInitialConditions(comm_, getAllNodes(), solnVec, flagVec);
285 }
286 
287 void
289  const Linear::Vector & solution)
290 {
291  initialConditionsManager_.outputDCOP(comm_, topology_.getSolutionNodeNameMap(), solution);
292 }
293 
294 
295 void
297  double time,
298  const std::vector<double> & fast_time_points,
299  const Linear::BlockVector & solution_vector)
300 {
301  outputManager_.outputMPDE(comm_, time, fast_time_points, solution_vector);
302 }
303 
304 void
306  const std::vector< double > & timePoints,
307  const std::vector< double > & freqPoints,
308  const Linear::BlockVector & timeDomainSolutionVec,
309  const Linear::BlockVector & freqDomainSolutionVecReal,
310  const Linear::BlockVector & freqDomainSolutionVecImaginary,
311  const Linear::BlockVector & timeDomainStoreVec,
312  const Linear::BlockVector & freqDomainStoreVecReal,
313  const Linear::BlockVector & freqDomainStoreVecImaginary,
314  const Linear::BlockVector & timeDomainLeadCurrentVec,
315  const Linear::BlockVector & freqDomainLeadCurrentVecReal,
316  const Linear::BlockVector & freqDomainLeadCurrentVecImaginary,
317  const Linear::BlockVector & timeDomainJunctionVoltageVec,
318  const Linear::BlockVector & freqDomainJunctionVoltageVecReal,
319  const Linear::BlockVector & freqDomainJunctionVoltageVecImaginary )
320 
321 {
322  outputManager_.outputHB(
323  comm_,
325  timePoints, freqPoints,
326  timeDomainSolutionVec, freqDomainSolutionVecReal, freqDomainSolutionVecImaginary,
327  timeDomainStoreVec, freqDomainStoreVecReal, freqDomainStoreVecImaginary,
328  timeDomainLeadCurrentVec, freqDomainLeadCurrentVecReal, freqDomainLeadCurrentVecImaginary,
329  timeDomainJunctionVoltageVec, freqDomainJunctionVoltageVecReal, freqDomainJunctionVoltageVecImaginary );
330 }
331 
332 void
334  double frequency,
335  const Linear::Vector & solnVecRealPtr,
336  const Linear::Vector & solnVecImaginaryPtr)
337 {
338  measureManager_.updateACMeasures(comm_, frequency, &solnVecRealPtr, &solnVecImaginaryPtr);
339 
340  outputManager_.outputAC(comm_, frequency, solnVecRealPtr, solnVecImaginaryPtr);
341 
342 }
343 void
345  double frequency,
346  double totalOutputNoiseDens_, double totalInputNoiseDens_,
347  const std::vector<Xyce::Analysis::NoiseData*> & noiseDataVec_)
348 {
349 
350  outputManager_.outputNoise(comm_, frequency,
351  totalOutputNoiseDens_, totalInputNoiseDens_, noiseDataVec_);
352 }
353 
354 void
356  bool origSys,
357  double freq,
358  const Teuchos::SerialDenseMatrix<int, std::complex<double> >& H )
359 {
360  if (!outputMOR_)
361  outputMOR_ = new IO::OutputMOR(outputManager_.getNetlistFilename());
362 
363  outputMOR_->output(comm_, origSys, freq, H );
364 }
365 
366 void
368 {
369  if (!outputMOR_)
370  outputMOR_ = new IO::OutputMOR(outputManager_.getNetlistFilename());
371 
372  outputMOR_->reset();
373 }
374 
375 void
377  const Teuchos::SerialDenseMatrix<int, double> & Ghat,
378  const Teuchos::SerialDenseMatrix<int, double> & Chat,
379  const Teuchos::SerialDenseMatrix<int, double> & Bhat,
380  const Teuchos::SerialDenseMatrix<int, double> & Lhat )
381 {
382  IO::outputROM(comm_, outputManager_.getNetlistFilename(), Ghat, Chat, Bhat, Lhat );
383 }
384 
385 void
387  const Linear::Matrix & Ghat,
388  const Linear::Matrix & Chat,
389  const Teuchos::SerialDenseMatrix<int, double> & Bhat,
390  const Teuchos::SerialDenseMatrix<int, double> & Lhat )
391 {
392  IO::outputROM(comm_, outputManager_.getNetlistFilename(), Ghat, Chat, Bhat, Lhat );
393 }
394 
395 double
397 {
398  return outputManager_.getInitialOutputInterval();
399 }
400 
401 const IO::IntervalVector &
403 {
404  return outputManager_.getOutputIntervals();
405 }
406 
407 void
409  const std::vector<std::string> & paramNames,
410  const std::vector<double> & paramVals,
411  Linear::Vector & solnVecPtr )
412 {
413  outputManager_.outputHomotopy (comm_, paramNames, paramVals, solnVecPtr);
414 }
415 
416 const Xyce::NodeNameMap &
418 {
419  return topology_.getSolutionNodeNameMap();
420 }
421 
422 } // namespace Analysis
423 } // namespace Xyce
void outputResult(const Linear::Vector &currSolutionPtr, const Linear::Vector &currStatePtr, const Linear::Vector &currStorePtr, const Linear::Vector &lead_current_vector, const Linear::Vector &junction_voltage_vector)
IO::InitialConditionsManager & initialConditionsManager_
void outputAC(double freq, const Linear::Vector &solnVecRealPtr, const Linear::Vector &solnVecImaginaryPtr)
Pure virtual class to augment a linear system.
void dcOutput(int dcStepNumber, Linear::Vector &currSolutionPtr, Linear::Vector &stateVecPtr, Linear::Vector &storeVecPtr, Linear::Vector &lead_current_vector, Linear::Vector &junction_voltage_vector, std::vector< double > &objectiveVec_, std::vector< double > &dOdpVec_, std::vector< double > &dOdpAdjVec_, std::vector< double > &scaled_dOdpVec_, std::vector< double > &scaled_dOdpAdjVec_)
Topo::Topology & topology_
Definition: N_ANP_AC.C:968
bool setupInitialConditions(Linear::Vector &solnVec, Linear::Vector &flagVec)
void outputHomotopy(const std::vector< std::string > &paramNames, const std::vector< double > &paramVals, Linear::Vector &solnVecPtr)
void setStepSweepVector(const Analysis::SweepVector &sweep_vector)
void dumpRestart(Parallel::Communicator &parallel_communicator, Analysis::AnalysisManager &analysis_manager, double current_time) const
void outputMPDE(double time, const std::vector< double > &fast_time_points, const Linear::BlockVector &solution_vector)
OutputMgrAdapter(Parallel::Machine comm, IO::OutputMgr &output_manager, IO::Measure::Manager &measure_manager, IO::FourierMgr &fourier_manager, IO::ObjectiveManager &objective_manager, IO::InitialConditionsManager &initial_conditions_manager, Device::DeviceMgr &device_manager, Topo::Topology &topology, IO::RestartMgr &restart_manager)
const Xyce::NodeNameMap & getAllNodes() const
Device::DeviceMgr & deviceManager_
Definition: N_ANP_HB.C:2068
void notify(const StepEvent &event)
void setDCSweepVector(const Analysis::SweepVector &sweep_vector)
void tranOutput(double time, Linear::Vector &currSolutionPtr, Linear::Vector &stateVecPtr, Linear::Vector &storeVecPtr, Linear::Vector &lead_current_vector, Linear::Vector &junction_voltage_vector, std::vector< double > &objectiveVec_, std::vector< double > &dOdpVec_, std::vector< double > &dOdpAdjVec_, std::vector< double > &scaled_dOdpVec_, std::vector< double > &scaled_dOdpAdjVec_, bool skipPrintLineOutput=false)
void outputMORTF(bool origSys, double freq, const Teuchos::SerialDenseMatrix< int, std::complex< double > > &H)
void addOutputResults(const Util::OptionBlock &option_block)
std::vector< SweepParam > SweepVector
Definition: N_ANP_fwd.h:85
const IO::IntervalVector & getOutputIntervals() const
void outputROM(const Teuchos::SerialDenseMatrix< int, double > &Ghat, const Teuchos::SerialDenseMatrix< int, double > &Chat, const Teuchos::SerialDenseMatrix< int, double > &Bhat, const Teuchos::SerialDenseMatrix< int, double > &Lhat)
void outputNoise(double freq, double totalOutputNoiseDens_, double totalInputNoiseDens_, const std::vector< Xyce::Analysis::NoiseData * > &noiseDataVec_)
double getParamAndReduce(const std::string &name) const
void outputDCOP(const Linear::Vector &solution)
void outputHB(const std::vector< double > &timePoints, const std::vector< double > &freqPoints, const Linear::BlockVector &timeDomainSolnVec, const Linear::BlockVector &freqDomainSolnVecReal, const Linear::BlockVector &freqDomainSolnVecImaginary, const Linear::BlockVector &timeDomainStoreVec, const Linear::BlockVector &freqDomainStoreVecReal, const Linear::BlockVector &freqDomainStoreVecImaginary, const Linear::BlockVector &timeDomainLeadCurrentVec, const Linear::BlockVector &freqDomainLeadCurrentVecReal, const Linear::BlockVector &freqDomainLeadCurrentVecImaginary, const Linear::BlockVector &timeDomainJunctionVoltageVec, const Linear::BlockVector &freqDomainJunctionVoltageVecReal, const Linear::BlockVector &freqDomainJunctionVoltageVecImaginary)
void addOutputResponse(const Util::OptionBlock &option_block)