46 #include <Xyce_config.h>
52 #include <N_ERH_ErrorMgr.h>
53 #include <N_PDS_Comm.h>
54 #include <N_UTL_FeatureTest.h>
86 netlistLocation_(right.netlistLocation_),
135 std::vector<Param>::const_iterator it_pL, end_pL;
137 os <<
"Model Block" << std::endl;
138 os <<
"Model: " << mb.
name_ << std::endl;
139 os <<
" type: " << mb.
type_ << std::endl;
140 os <<
" Level: " << mb.
level_ << std::endl;
142 os <<
" Tagged Params" << std::endl;
143 os <<
" -------------" << std::endl;
147 for ( ; it_pL != end_pL; ++it_pL)
149 os << it_pL->tag() <<
"\t" << it_pL->stringValue() << std::endl;
152 os <<
" -------------" << std::endl;
208 : name_ (right.name_),
209 modelName_(right.modelName_),
210 iNumNodes (right.iNumNodes),
211 numIntVars(right.numIntVars),
212 numExtVars(right.numExtVars),
213 numStateVars(right.numStateVars),
214 modelFlag (right.modelFlag),
215 sourceFlag(right.sourceFlag),
216 bsourceFlag(right.bsourceFlag),
217 offFlag (right.offFlag),
219 netlistLocation_(right.netlistLocation_),
220 params (right.params)
301 std::vector<Param>::const_iterator it_tpL, end_tpL;
303 os <<
"Instance Block" << std::endl;
304 os <<
"Name: " << ib.
name_ << std::endl;
306 os <<
" # Nodes: " << ib.
iNumNodes << std::endl;
307 os <<
" # Int Vars: " << ib.
numIntVars << std::endl;
308 os <<
" # Ext Vars: " << ib.
numExtVars << std::endl;
309 os <<
" # State Vars: " << ib.
numStateVars << std::endl;
310 os <<
" modelFlag: " << ib.
modelFlag << std::endl;
311 os <<
" sourceFlag: " << ib.
sourceFlag << std::endl;
312 os <<
" bsourceFlag: " << ib.
bsourceFlag << std::endl;
313 os <<
" offFlag: " << ib.
offFlag << std::endl;
314 os <<
" off: " << ib.
off << std::endl;
316 os <<
" Tagged Params" << std::endl;
317 os <<
" -------------" << std::endl;
321 for ( ; it_tpL != end_tpL; ++it_tpL)
323 os << it_tpL->tag() <<
"\t" << it_tpL->stringValue() << std::endl;
326 os <<
" -------------" << std::endl;
344 Pack<Device::ModelBlock>::packedByteCount(
const Device::ModelBlock &model_block)
352 length = model_block.name_.length();
353 byteCount +=
sizeof(int);
357 length = model_block.type_.length();
358 byteCount +=
sizeof(int);
362 byteCount +=
sizeof(int);
365 size = model_block.params.size();
366 byteCount +=
sizeof(int);
367 std::vector<Device::Param>::const_iterator it_tpL = model_block.params.begin();
368 for (i = 0; i < size; ++i, ++it_tpL)
370 byteCount += Pack<Device::Param>::packedByteCount(*it_tpL);
374 length = model_block.netlistLocation_.getFilename().length();
375 byteCount +=
sizeof(int);
379 byteCount +=
sizeof(int);
395 Pack<Device::ModelBlock>::pack(
const Device::ModelBlock &model_block,
char * buf,
int bsize,
int & pos, N_PDS_Comm * comm)
400 #ifdef Xyce_COUNT_PACKED_BYTES
401 int predictedPos = pos+packedByteCount();
405 length = model_block.name_.length();
406 comm->pack(&length, 1, buf, bsize, pos );
407 comm->pack( model_block.name_.c_str(), length, buf, bsize, pos );
410 length = model_block.type_.length();
411 comm->pack(&length, 1, buf, bsize, pos );
412 comm->pack( model_block.type_.c_str(), length, buf, bsize, pos );
415 comm->pack(&model_block.level_, 1, buf, bsize, pos );
418 size = model_block.params.size();
419 comm->pack(&size, 1, buf, bsize, pos );
420 std::vector<Device::Param>::const_iterator it_tpL = model_block.params.begin();
421 for (i = 0; i < size; ++i, ++it_tpL)
423 Pack<Device::Param>::pack(*it_tpL, buf, bsize, pos, comm );
427 length = model_block.netlistLocation_.getFilename().length();
428 comm->pack(&length, 1, buf, bsize, pos );
429 comm->pack( model_block.netlistLocation_.getFilename().c_str(), length, buf, bsize, pos );
432 int line_number = model_block.netlistLocation_.getLineNumber();
433 comm->pack(&line_number, 1, buf, bsize, pos );
436 Xyce::dout() <<
"Packed " << pos <<
" bytes for ModelBlock: " << model_block.name_ << std::endl;
438 #ifdef Xyce_COUNT_PACKED_BYTES
439 if (pos != predictedPos)
441 DevelFatal(*
this,
"ModelBlock::pack") <<
"Predicted pos does not match actual pos";
457 Pack<Device::ModelBlock>::unpack(Device::ModelBlock &model_block,
char * pB,
int bsize,
int & pos, N_PDS_Comm * comm)
464 comm->unpack( pB, bsize, pos, &length, 1 );
465 model_block.name_ = std::string( (pB+pos), length);
469 comm->unpack( pB, bsize, pos, &length, 1 );
470 model_block.type_ = std::string( (pB+pos), length);
474 comm->unpack( pB, bsize, pos, &model_block.level_, 1 );
477 comm->unpack( pB, bsize, pos, &size, 1 );
478 model_block.params.clear();
480 for( i = 0; i < size; ++i )
482 Pack<Device::Param>::unpack(dp, pB, bsize, pos, comm );
483 model_block.params.push_back( dp );
487 comm->unpack( pB, bsize, pos, &length, 1 );
488 model_block.netlistLocation_.setFilename(std::string( (pB+pos), length));
493 comm->unpack( pB, bsize, pos, &line_number, 1 );
494 model_block.netlistLocation_.setLineNumber(line_number);
497 Xyce::dout() <<
"Unpacked " << pos <<
" bytes for ModelBlock: " << model_block.name_ << std::endl;
510 Pack<Device::InstanceBlock>::packedByteCount(
const Device::InstanceBlock &instance_block)
518 const std::string &name = instance_block.getInstanceName().getEncodedName();
519 length = name.length();
520 byteCount +=
sizeof(int);
521 byteCount += length *
sizeof(char);
524 length = instance_block.getModelName().length();
525 byteCount +=
sizeof(int);
526 byteCount += length *
sizeof(char);
529 size = instance_block.params.size();
530 byteCount +=
sizeof(int);
532 std::vector<Device::Param>::const_iterator it_tpL = instance_block.params.begin();
533 for (i = 0; i < size; ++i, ++it_tpL)
535 byteCount += Pack<Device::Param>::packedByteCount(*it_tpL);
539 byteCount +=
sizeof(int);
542 byteCount +=
sizeof(int);
545 byteCount +=
sizeof(int);
548 byteCount +=
sizeof(int);
551 byteCount +=
sizeof(int);
554 byteCount +=
sizeof(int);
557 byteCount +=
sizeof(int);
560 byteCount +=
sizeof(int);
563 byteCount +=
sizeof(int);
566 length = instance_block.netlistLocation_.getFilename().length();
567 byteCount +=
sizeof(int);
568 byteCount += length *
sizeof(char);
571 byteCount +=
sizeof(int);
587 Pack<Device::InstanceBlock>::pack(
const Device::InstanceBlock &instance_block,
char * buf,
int bsize,
int & pos, N_PDS_Comm * comm)
592 #ifdef Xyce_COUNT_PACKED_BYTES
593 int predictedPos = pos+packedByteCount();
597 const std::string &name = instance_block.getInstanceName().getEncodedName();
598 length = name.length();
599 comm->pack(&length, 1, buf, bsize, pos);
600 comm->pack(name.c_str(), length, buf, bsize, pos);
603 length = instance_block.getModelName().length();
604 comm->pack(&length, 1, buf, bsize, pos );
605 comm->pack( instance_block.getModelName().c_str(), length, buf, bsize, pos );
608 size = instance_block.params.size();
609 comm->pack(&size, 1, buf, bsize, pos );
610 std::vector<Device::Param>::const_iterator it_tpL = instance_block.params.begin();
611 for (i = 0; i < size; ++i, ++it_tpL)
613 Pack<Device::Param>::pack(*it_tpL, buf, bsize, pos, comm );
617 comm->pack(&instance_block.iNumNodes, 1, buf, bsize, pos );
620 comm->pack(&instance_block.numIntVars, 1, buf, bsize, pos );
623 comm->pack(&instance_block.numExtVars, 1, buf, bsize, pos );
626 comm->pack(&instance_block.numStateVars, 1, buf, bsize, pos );
629 i = instance_block.modelFlag;
630 comm->pack(&i, 1, buf, bsize, pos );
633 i = instance_block.sourceFlag;
634 comm->pack(&i, 1, buf, bsize, pos );
637 i = instance_block.bsourceFlag;
638 comm->pack(&i, 1, buf, bsize, pos );
641 i = instance_block.offFlag;
642 comm->pack(&i, 1, buf, bsize, pos );
645 i = instance_block.off;
646 comm->pack(&i, 1, buf, bsize, pos );
649 length = instance_block.netlistLocation_.getFilename().length();
650 comm->pack(&length, 1, buf, bsize, pos );
651 comm->pack( instance_block.netlistLocation_.getFilename().c_str(), length, buf, bsize, pos );
654 int line_number = instance_block.netlistLocation_.getLineNumber();
655 comm->pack(&line_number, 1, buf, bsize, pos );
658 Xyce::dout() <<
"Packed " << pos <<
" bytes for InstanceBlock: " << instance_block.getInstanceName() << std::endl;
660 #ifdef Xyce_COUNT_PACKED_BYTES
661 if (pos != predictedPos)
663 DevelFatal(*
this,
"InstanceBlock::pack") <<
"Predicted pos does not match actual pos";
678 Pack<Device::InstanceBlock>::unpack(Device::InstanceBlock &instance_block,
char * pB,
int bsize,
int & pos, N_PDS_Comm * comm)
685 comm->unpack( pB, bsize, pos, &length, 1 );
686 instance_block.name_ = Device::InstanceName(std::string( (pB+pos), length));
690 comm->unpack( pB, bsize, pos, &length, 1 );
691 instance_block.modelName_ = std::string( (pB+pos), length);
695 comm->unpack( pB, bsize, pos, &size, 1 );
696 instance_block.params.clear();
698 for( i = 0; i < size; ++i )
700 Pack<Device::Param>::unpack(dp, pB, bsize, pos, comm );
701 instance_block.params.push_back( dp );
705 comm->unpack( pB, bsize, pos, &instance_block.iNumNodes, 1 );
708 comm->unpack( pB, bsize, pos, &instance_block.numIntVars, 1 );
711 comm->unpack( pB, bsize, pos, &instance_block.numExtVars, 1 );
714 comm->unpack( pB, bsize, pos, &instance_block.numStateVars, 1 );
717 comm->unpack( pB, bsize, pos, &i, 1 );
718 instance_block.modelFlag = ( i != 0 );
721 comm->unpack( pB, bsize, pos, &i, 1 );
722 instance_block.sourceFlag = ( i != 0 );
725 comm->unpack( pB, bsize, pos, &i, 1 );
726 instance_block.bsourceFlag = ( i != 0 );
729 comm->unpack( pB, bsize, pos, &i, 1 );
730 instance_block.offFlag = ( i != 0 );
733 comm->unpack( pB, bsize, pos, &i, 1 );
734 instance_block.off = ( i != 0 );
737 comm->unpack( pB, bsize, pos, &length, 1 );
738 instance_block.netlistLocation_.setFilename(std::string( (pB+pos), length));
743 comm->unpack( pB, bsize, pos, &line_number, 1 );
744 instance_block.netlistLocation_.setLineNumber(line_number);
747 Xyce::dout() <<
"Unpacked " << pos <<
" bytes for InstanceBlock: " << instance_block.getInstanceName() << std::endl;
ModelBlock(const std::string &name="", const std::string &type="", int level=1)
Pure virtual class to augment a linear system.
Devices and models are each named.
NetlistLocation netlistLocation_
Path and line number of .MODEL command.
ModelName name_
Model name.
std::vector< Param > params
Parameters from the line.
InstanceBlock(const std::string &name=std::string())
ModelBlock & operator=(const ModelBlock &right)
std::string type_
Model type.
const ModelName & getModelName() const
InstanceName name_
Device instance name.
InstanceBlock & operator=(const InstanceBlock &right)
ModelBlock represents a .MODEL line from the netlist.
NetlistLocation netlistLocation_
Path and line number of .MODEL command.
InstanceBlock represent a device instance line from the netlist.
std::vector< Param > params
std::ostream & operator<<(std::ostream &os, const Configuration &configuration)
ModelName modelName_
Model name if provided.