//==== Load Parm Vec, Find Groups And Sort ====//
void ParmContainer::LoadGroupParmVec( vector< string > & parm_vec, bool displaynames )
{
m_GroupNames.clear();
m_GroupParmMap.clear();
//==== Map Parms To Group Names ====//
for ( int i = 0 ; i < ( int )parm_vec.size() ; i++ )
{
string pid = parm_vec[i];
Parm* p = ParmMgr.FindParm( pid );
if ( p )
{
string group_name;
if( displaynames )
{
group_name = p->GetDisplayGroupName();
}
else
{
group_name = p->GetGroupName();
}
m_GroupParmMap[group_name].push_back( pid );
}
}
map< string, vector< string > >::iterator iter;
for ( iter = m_GroupParmMap.begin() ; iter != m_GroupParmMap.end() ; iter++ )
{
m_GroupNames.push_back( iter->first );
sort( iter->second.begin(), iter->second.end(), ParmNameCompare );
}
}
//==== Add New Link ====//
bool LinkMgrSingleton::AddLink( const string& pidA, const string& pidB )
{
//==== Make Sure Parm Are Not Already Linked ====//
for ( int i = 0 ; i < ( int )m_LinkVec.size() ; i++ )
{
if ( m_LinkVec[i]->GetParmA() == pidA && m_LinkVec[i]->GetParmB() == pidB )
{
return false;
}
}
//==== Check If ParmIDs Are Valid ====//
Parm* pA = ParmMgr.FindParm( pidA );
Parm* pB = ParmMgr.FindParm( pidB );
if ( pA == NULL || pB == NULL )
{
return false;
}
Link* pl = new Link();
pl->SetParmA( pidA );
pl->SetParmB( pidB );
pl->SetOffsetFlag( true );
pl->m_Offset.Set( pB->Get() - pA->Get() );
pl->SetScaleFlag( false );
pl->m_Scale.Set( 1.0 );
m_LinkVec.push_back( pl );
m_CurrLinkIndex = ( int )m_LinkVec.size() - 1;
return true;
}
//==== Encode Data Into XML Data Struct ====//
xmlNodePtr ParmContainer::EncodeXml( xmlNodePtr & node )
{
xmlNodePtr parmcontain_node = xmlNewChild( node, NULL, BAD_CAST "ParmContainer", NULL );
if ( parmcontain_node )
{
XmlUtil::AddStringNode( parmcontain_node, "ID", m_ID );
XmlUtil::AddStringNode( parmcontain_node, "Name", m_Name );
}
xmlNodePtr gnode;
LoadGroupParmVec( m_ParmVec, false );
map< string, vector< string > >::iterator groupIter;
for ( groupIter = m_GroupParmMap.begin() ; groupIter != m_GroupParmMap.end() ; groupIter++ )
{
string name = groupIter->first;
gnode = xmlNewChild( parmcontain_node, NULL, BAD_CAST name.c_str(), NULL );
if ( gnode )
{
vector< string >::iterator parmIter;
for ( parmIter = groupIter->second.begin(); parmIter != groupIter->second.end(); parmIter++ )
{
Parm* p = ParmMgr.FindParm( ( *parmIter ) );
p->EncodeXml( gnode );
}
}
}
return parmcontain_node;
}
void ParmLinkMgr::LoadAllParms()
{
//==== Clear All Existing Parms ====//
map< GeomBase*, map< string, vector< Parm* > > >::iterator g;
map< string, vector<Parm*> >::iterator itr;
for ( g = m_ParmMap.begin() ; g != m_ParmMap.end() ; g++ )
{
for ( itr = g->second.begin() ; itr != g->second.end() ; itr++ )
{
itr->second.clear();
}
g->second.clear();
}
m_ParmMap.clear();
if ( aircraftPtr == NULL )
return;
//==== Loop Thru All Geoms ====//
vector< Geom* > geomVec = aircraftPtr->getGeomVec();
geomVec.push_back( aircraftPtr->getUserGeom() );
for ( int i = 0 ; i < (int)geomVec.size() ; i++ )
{
vector < Parm* > parmVec;
geomVec[i]->LoadLinkableParms( parmVec );
for ( int j = 0 ; j < (int)parmVec.size() ; j++ )
{
Parm* p = parmVec[j];
p->set_linked_flag( false );
Register( p, p->get_geom_base(), p->get_group_name().get_char_star() );
}
}
}
void FitModelScreen::RebuildAdjustTab()
{
m_FitScrollGroup->clear();
m_FitVarScrollLayout.SetGroup( m_FitScrollGroup );
m_FitVarScrollLayout.InitWidthHeightVals();
m_ParmSliderVec.clear();
int num_vars = FitModelMgr.GetNumVars();
m_ParmSliderVec.resize( num_vars );
string lastContID;
for ( int i = 0 ; i < num_vars ; i++ )
{
string pID = FitModelMgr.GetVar( i );
Parm* p = ParmMgr.FindParm( pID );
string contID = p->GetContainerID();
if ( contID.compare( lastContID ) != 0 )
{
lastContID = contID;
m_FitVarScrollLayout.AddDividerBox( ParmMgr.FindParmContainer( contID )->GetName() );
}
m_FitVarScrollLayout.AddSlider( m_ParmSliderVec[i], "AUTO_UPDATE", 10, "%7.3f" );
m_ParmSliderVec[i].Update( pID );
}
m_NVarLast = num_vars;
}
//==== Get Container Name Vec And Find Match Index For Parm_ID ====//
int LinkMgrSingleton::GetCurrContainerVec( const string& parm_id, vector< string > & idVec )
{
int index = 0;
BuildLinkableParmData();
//==== Find Container ID ====//
string curr_container_id;
Parm* p = ParmMgr.FindParm( parm_id );
if ( p )
{
curr_container_id = p->GetLinkContainerID();
}
//==== Find Index And Load Container Names ===//
for ( int i = 0 ; i < ( int )m_LinkableContainers.size() ; i++ )
{
if ( m_LinkableContainers[i] == curr_container_id )
{
index = i;
}
ParmContainer* pc = ParmMgr.FindParmContainer( m_LinkableContainers[i] );
string name;
if ( pc )
{
name = pc->GetName();
}
idVec.push_back( name );
}
return index;
}
//==== Get Vector Parm IDs And Index For Given Parm ID ====//
int ParmContainer::GetParmIDs( string parm_id, vector< string > & parm_ids )
{
int index = 0;
string group_name;
Parm* p = ParmMgr.FindParm( parm_id );
if ( p )
{
group_name = p->GetDisplayGroupName();
}
map< string, vector< string > >::iterator iter = m_GroupParmMap.find( group_name );
if ( iter == m_GroupParmMap.end() )
{
return index;
}
for ( int i = 0 ; i < ( int )iter->second.size() ; i++ )
{
if ( parm_id == iter->second[i] )
{
index = parm_ids.size();
}
parm_ids.push_back( iter->second[i] );
}
return index;
}
void PHolderListMgr::ReadPHolderListDES( char *newfile )
{
FILE *fp;
fp = fopen( newfile, "r" );
char temp[255];
fgets( temp, 255, fp );
Stringc line = temp;
int nparm = line.convert_to_integer();
if( nparm > 0 )
{
pHolderListMgrPtr->DelAllPHolders();
vector< Geom* > gVec = aircraftPtr->getGeomVec();
gVec.push_back( aircraftPtr->getUserGeom() );
for ( int i = 0 ; i < nparm ; i++ )
{
fgets( temp, 255, fp );
line = temp;
int istart = 0;
int iend = line.search_for_substring(':');
int id = line.get_range( istart, iend-1 ).convert_to_integer();
istart = iend + 1;
iend = line.search_for_substring( istart, ':' );
istart = iend + 1;
iend = line.search_for_substring( istart, ':' );
Stringc group = line.get_range( istart, iend-1 );
istart = iend + 1;
iend = line.search_for_substring( istart, ':' );
Stringc parm = line.get_range( istart, iend-1 );
istart = iend + 1;
iend = line.get_length();
double val = line.get_range( istart, iend-1 ).convert_to_double();
Parm* p = parmMgrPtr->FindParm( gVec, id, group, parm );
if ( p )
{
p->set_from_link( val );
p->get_geom()->parm_changed( p );
ParmHolder* ph = new ParmHolder();
ph->setParm( p );
m_PHolderVec.push_back( ph );
m_CurrPHolderIndex = (int)m_PHolderVec.size() - 1;
}
}
}
fclose( fp );
}
//==== Name Compare ====//
bool ParmNameCompare( const string a, const string b )
{
Parm* pA = ParmMgr.FindParm( a );
Parm* pB = ParmMgr.FindParm( b );
if ( pA && pB )
{
return ( pA->GetName() < pB->GetName() );
}
return ( false );
}
void ParmLinkScreen::RemoveAllRefs( GeomBase* gPtr )
{
vector< ParmButton* > tempVec;
for ( int i = 0 ; i < (int)m_ParmButtonVec.size() ; i++ )
{
Parm* p = m_ParmButtonVec[i]->get_parm_ptr();
if ( p && p->get_geom_base() != gPtr )
tempVec.push_back( m_ParmButtonVec[i] );
}
m_ParmButtonVec = tempVec;
}
void SubSurface::SetDisplaySuffix( int num )
{
for ( int i = 0 ; i < ( int )m_ParmVec.size() ; i++ )
{
Parm* p = ParmMgr.FindParm( m_ParmVec[i] );
if ( p )
{
p->SetGroupDisplaySuffix( num );
}
}
}
//==== Add User Defined Parm ====//
string UserParmContainer::AddParm(int type, const string & name, const string & group )
{
Parm* p = ParmMgr.CreateParm( type );
if ( p )
{
p->Init( name, group, this, 0.0, -1.0e6, 1.0e6, true );
p->SetDescript( "User Parm Descript" );
m_UserParmVec.push_back( p );
return p->GetID();
}
return string();
}
//==== Get Latest Change Cnt ====//
int ParmContainer::GetLatestChangeCnt()
{
int cnt = 0;
for ( int i = 0 ; i < ( int )m_ParmVec.size() ; i++ )
{
string pid = m_ParmVec[i];
Parm* p = ParmMgr.FindParm( pid );
if ( p && p->GetChangeCnt() > cnt )
{
cnt = p->GetChangeCnt();
}
}
return cnt;
}
void ParmLinkMgr::SwapGeom( Geom* gOld, Geom* gNew )
{
for ( int i = 0 ; i < (int)m_ParmLinkVec.size() ; i++ )
{
Parm* pA = m_ParmLinkVec[i]->GetParmA();
if ( pA->get_geom_base() == gOld )
{
Stringc group_name = pA->get_group_name();
Stringc parm_name = pA->get_name();
Parm* p = FindParm( gNew, group_name, parm_name );
if ( p )
m_ParmLinkVec[i]->SetParmA( p );
}
Parm* pB = m_ParmLinkVec[i]->GetParmB();
if ( pB->get_geom_base() == gOld )
{
Stringc group_name = pB->get_group_name();
Stringc parm_name = pB->get_name();
Parm* p = FindParm( gNew, group_name, parm_name );
if ( p )
m_ParmLinkVec[i]->SetParmB( p );
}
m_ParmLinkVec[i]->GetParmA()->set_linked_flag( true );
m_ParmLinkVec[i]->GetParmB()->set_linked_flag( true );
}
}
string LinkMgrSingleton::AddUserParm(int type, const string & name, const string & group )
{
//==== Check For Duplicate ====//
int num_parms = GetNumUserParms() - GetNumPredefinedUserParms();
for ( int i = 0 ; i < num_parms ; i++ )
{
string pid = LinkMgr.GetUserParmId( i + GetNumPredefinedUserParms() );
Parm* pptr = ParmMgr.FindParm( pid );
if ( pptr && pptr->GetName() == name && pptr->GetGroupName() == group )
{
return string();
}
}
return m_UserParms.AddParm( type, name, group );
}
//==== Decode Data From XML Data Struct ====//
xmlNodePtr UserParmContainer::DecodeXml( xmlNodePtr & node )
{
int num_curr_custom = m_UserParmVec.size() - m_NumPredefined;
xmlNodePtr child_node = XmlUtil::GetNode( node, "UserParmContainer", 0 );
if ( child_node )
{
int num_user = XmlUtil::FindInt( child_node, "NumUserParms", 0 );
//==== Decode All User Parms ====//
if ( num_curr_custom == 0 )
{
Renew( num_user );
for ( int i = 0; i < static_cast<int>( m_UserParmVec.size() ); i++ )
{
xmlNodePtr pnode = XmlUtil::GetNode( child_node, "UserParm", i );
if ( pnode && m_UserParmVec[i] )
{
m_UserParmVec[i]->DecodeXml( pnode, true );
}
}
}
else
{
//==== Decode Predefined ====//
for ( int i = 0; i < m_NumPredefined ; i++ )
{
xmlNodePtr pnode = XmlUtil::GetNode( child_node, "UserParm", i );
if ( pnode && m_UserParmVec[i] )
{
m_UserParmVec[i]->DecodeXml( pnode, true );
}
}
//==== Append New Custom ====//
int num_new_custom = num_user - m_NumPredefined;
for ( int i = 0 ; i < num_new_custom ; i++ )
{
xmlNodePtr pnode = XmlUtil::GetNode( child_node, "UserParm", i + m_NumPredefined );
Parm* p = new Parm();
p->Init( "Temp", "User_Group", this, 0.0, -1.0e12, 1.0e12 );
p->DecodeXml( pnode, true );
m_UserParmVec.push_back( p );
}
}
}
return child_node;
}
//==== Look Though All Parms and Load Linkable Ones ===//
void ParmContainer::AddLinkableParms( vector< string > & linkable_parm_vec, const string & link_container_id )
{
for ( int i = 0 ; i < ( int )m_ParmVec.size() ; i++ )
{
Parm* p = ParmMgr.FindParm( m_ParmVec[i] );
if ( p && p->IsLinkable() )
{
if ( link_container_id.size() )
{
p->SetLinkContainerID( link_container_id );
}
linkable_parm_vec.push_back( p->GetID() );
}
}
}
void PHolderListMgr::WritePHolderListDES( char *newfile )
{
FILE *fp;
fp = fopen( newfile, "w" );
fprintf( fp, "%d\n", (int)m_PHolderVec.size() );
for ( int i = 0 ; i < (int)m_PHolderVec.size() ; i++ )
{
Parm *p = m_PHolderVec[i]->getParm();
fprintf( fp, "%d:%s:%s:%s: %g\n", ((Geom*)p->get_geom_base())->getPtrID(), p->get_geom_base()->getName().get_char_star(), p->get_group_name().get_char_star(), p->get_name().get_char_star(), p->get() );
}
fclose( fp );
}
//==== Find Parm ID Given Parm Name ====//
string ParmContainer::FindParm( const string& parm_name )
{
//==== Look Thru All Parms And Return First Name Match ====//
for ( int i = 0 ; i < ( int )m_ParmVec.size() ; i++ )
{
Parm* p = ParmMgr.FindParm( m_ParmVec[i] );
if ( p )
{
if ( p->GetName() == parm_name )
{
return p->GetID();
}
}
}
return string();
}
//==== Encode Data Into XML Data Struct ====//
xmlNodePtr UserParmContainer::EncodeXml( xmlNodePtr & node )
{
xmlNodePtr userparmcontain_node = xmlNewChild( node, NULL, BAD_CAST "UserParmContainer", NULL );
if ( userparmcontain_node )
{
XmlUtil::AddIntNode( userparmcontain_node, "NumUserParms", (int)m_UserParmVec.size() );
for ( int i = 0; i < static_cast<int>( m_UserParmVec.size() ); i++ )
{
Parm* p = m_UserParmVec[i];
if ( p )
{
p->EncodeXml( userparmcontain_node, true );
}
}
}
return userparmcontain_node;
}
void print(const Parm &c)
{
typename Parm::size_type index = 0;
while (index!=c.size())
{
cout << c[index] << " ";
++index;
}
}
//==== Link All Parms In A Container (Component) ====//
bool LinkMgrSingleton::LinkAllComp()
{
Parm* pA = ParmMgr.FindParm( m_WorkingLink->GetParmA() );
Parm* pB = ParmMgr.FindParm( m_WorkingLink->GetParmB() );
ParmContainer* pcA = pA->GetLinkContainer();
ParmContainer* pcB = pB->GetLinkContainer();
if ( !pcA || !pcB )
{
return false;
}
if ( pcA == pcB )
{
return false;
}
vector< string > parmAVec, parmBVec;
pcA->AddLinkableParms( parmAVec, pcA->GetID() );
pcB->AddLinkableParms( parmBVec, pcB->GetID() );
for ( int k = 0 ; k < ( int )parmAVec.size() ; k++ )
{
for ( int n = 0 ; n < ( int )parmBVec.size() ; n++ )
{
Parm* parmA = ParmMgr.FindParm( parmAVec[k] );
Parm* parmB = ParmMgr.FindParm( parmBVec[n] );
if ( parmA && parmB )
{
if ( parmA->GetName() == parmB->GetName() &&
parmA->GetDisplayGroupName() == parmB->GetDisplayGroupName() )
{
AddLink( parmAVec[k], parmBVec[n] );
}
}
}
}
return true;
}
//==== Find Parm ID Given GroupName and Parm Name ====//
string ParmContainer::FindParm( const string& parm_name, const string& group_name )
{
string id;
map< string, vector< string > >::iterator iter;
iter = m_GroupParmMap.find( group_name );
if ( iter != m_GroupParmMap.end() )
{
//==== Look For Parm Name ====//
vector< string > pid_vec = iter->second;
for ( int i = 0 ; i < (int)pid_vec.size() ; i++ )
{
Parm* p = ParmMgr.FindParm( pid_vec[i] );
if ( p->GetName() == parm_name )
return pid_vec[i];
}
}
//==== Look Thru All Parms And Return First Name Match ====//
for ( int i = 0 ; i < ( int )m_ParmVec.size() ; i++ )
{
Parm* p = ParmMgr.FindParm( m_ParmVec[i] );
if ( p )
{
if ( p->GetName() == parm_name && p->GetGroupName() == group_name )
{
return p->GetID();
}
}
}
return id;
}
//==== Decode Data From XML Data Struct ====//
xmlNodePtr ParmContainer::DecodeXml( xmlNodePtr & node )
{
xmlNodePtr child_node = XmlUtil::GetNode( node, "ParmContainer", 0 );
if ( child_node )
{
string oldID = XmlUtil::FindString( child_node, "ID", m_ID );
string newID = ParmMgr.RemapID( oldID, m_ID );
if( newID.compare( m_ID ) != 0 ) // they differ
{
ChangeID( newID );
}
SetName( XmlUtil::FindString( child_node, "Name", m_Name ) );
}
xmlNodePtr gnode;
LoadGroupParmVec( m_ParmVec, false );
map< string, vector< string > >::iterator groupIter;
for ( groupIter = m_GroupParmMap.begin() ; groupIter != m_GroupParmMap.end() ; groupIter++ )
{
string name = groupIter->first;
gnode = XmlUtil::GetNode( child_node, name.c_str(), 0 );
if ( gnode )
{
vector< string >::iterator parmIter;
for ( parmIter = groupIter->second.begin(); parmIter != groupIter->second.end(); parmIter++ )
{
Parm* p = ParmMgr.FindParm( ( *parmIter ) );
p->DecodeXml( gnode );
}
}
}
return child_node;
}
//==== Get Vector of Group Names And Index For Given Parm ID ====//
int ParmContainer::GetGroupNames( string parm_id, vector< string > & group_names )
{
int index = 0;
string group_name;
Parm* p = ParmMgr.FindParm( parm_id );
if ( p )
{
group_name = p->GetDisplayGroupName();
}
map< string, vector< string > >::iterator iter;
for ( iter = m_GroupParmMap.begin() ; iter != m_GroupParmMap.end() ; iter++ )
{
string name = iter->first;
if ( name == group_name )
{
index = group_names.size();
}
group_names.push_back( name );
}
return index;
}
//==== Get Parm ID Vec And Find Match Index For Parm_ID ====//
int LinkMgrSingleton::GetCurrParmIDVec( const string& parm_id, vector< string > & idVec )
{
int index = 0;
BuildLinkableParmData();
if ( m_LinkableContainers.size() == 0 )
{
return index;
}
string group_name;
Parm* p = ParmMgr.FindParm( parm_id );
if ( p )
{
ParmContainer* pc = p->GetLinkContainer();
if ( pc )
{
return pc->GetParmIDs( parm_id, idVec );
}
}
return index;
}
void ParmContainer::ChangeID( string id )
{
ParmMgr.RemoveParmContainer( this );
if( LinkMgr.CheckContainerRegistered( m_ID ) )
{
LinkMgr.UnRegisterContainer( m_ID );
LinkMgr.RegisterContainer( id );
}
m_ID = id;
for ( int i = 0 ; i < ( int )m_ParmVec.size() ; i++ )
{
string pid = m_ParmVec[i];
Parm* p = ParmMgr.FindParm( pid );
if ( p )
{
p->ReSetLinkContainerID();
}
}
ParmMgr.AddParmContainer( this );
}
void Mcmc::printChainState(int n, double lnL) {
if (n == 1)
{
std::string pHeaderStr = "";
std::string tHeaderStr = "";
for (int i=0; i<modelPtr->getNumParameters(); i++)
{
Parm* p = modelPtr->getParameter(i);
Tree* derivedPtr = dynamic_cast<Tree*> (p);
if (derivedPtr != 0)
tHeaderStr += p->getParameterHeader();
else
pHeaderStr += p->getParameterHeader();
}
treeFileStrm << tHeaderStr;
parmFileStrm << "Cycle\tlnL\t" << pHeaderStr << std::endl;
}
std::string pStr = "";
std::string tStr = "";
for (int i=0; i<modelPtr->getNumParameters(); i++)
{
Parm* p = modelPtr->getParameter(i);
Tree* derivedPtr = dynamic_cast<Tree*> (p);
if (derivedPtr != 0)
tStr += p->getParameterStr();
else
pStr += p->getParameterStr();
}
treeFileStrm << " tree_" << n << " = " << tStr << ";" << std::endl;
parmFileStrm << n << '\t' << std::fixed << std::setprecision(2) << lnL << '\t' << pStr << std::endl;
if (n == numCycles)
{
treeFileStrm << "end;" << std::endl;
}
if (n != 1)
treeSummary->addState(n);
}
void PHolderListMgr::WritePHolderListXDDM( char *newfile )
{
xmlDocPtr doc = xmlNewDoc((const xmlChar *)"1.0");
xmlNodePtr model_node = xmlNewNode(NULL,(const xmlChar *)"Model");
xmlDocSetRootElement(doc, model_node);
xmlSetProp( model_node, (const xmlChar *)"ID", (const xmlChar *)aircraftPtr->getFileName().get_char_star() );
xmlSetProp( model_node, (const xmlChar *)"Modeler", (const xmlChar *)"OpenVSP" );
xmlSetProp( model_node, (const xmlChar *)"Wrapper", (const xmlChar *)"wrap_vsp.csh" );
for ( int i = 0 ; i < (int)m_PHolderVec.size() ; i++ )
{
Parm* p = m_PHolderVec[i]->getParm();
xmlNodePtr var_node;
if( m_PHolderVec[i]->getDesType() == XDDM_VAR )
var_node = xmlNewChild( model_node, NULL, (const xmlChar *)"Variable", NULL );
else
var_node = xmlNewChild( model_node, NULL, (const xmlChar *)"Constant", NULL );
char varname[255];
sprintf( varname, "%d:%s:%s:%s", ((Geom*)p->get_geom_base())->getPtrID(), p->get_geom_base()->getName().get_char_star(), p->get_group_name().get_char_star(), p->get_name().get_char_star() );
xmlSetProp( var_node, (const xmlChar *)"ID", (const xmlChar *)varname );
xmlSetDoubleProp( var_node, "Value", p->get() );
xmlSetDoubleProp( var_node, "Min", p->get_lower() );
xmlSetDoubleProp( var_node, "Max", p->get_upper() );
xmlSetProp( var_node, (const xmlChar *)"VSPVarName", (const xmlChar *)varname );
}
//===== Save XML Tree and Free Doc =====//
xmlSaveFormatFile((const char *)newfile, doc, 1);
xmlFreeDoc( doc );
}
void WingDriverGroup::UpdateGroup( vector< string > parmIDs )
{
Parm* AR = ParmMgr.FindParm( parmIDs[AR_WSECT_DRIVER] );
Parm* span = ParmMgr.FindParm( parmIDs[SPAN_WSECT_DRIVER] );
Parm* area = ParmMgr.FindParm( parmIDs[AREA_WSECT_DRIVER] );
Parm* taper = ParmMgr.FindParm( parmIDs[TAPER_WSECT_DRIVER] );
Parm* aveC = ParmMgr.FindParm( parmIDs[AVEC_WSECT_DRIVER] );
Parm* rootC = ParmMgr.FindParm( parmIDs[ROOTC_WSECT_DRIVER] );
Parm* tipC = ParmMgr.FindParm( parmIDs[TIPC_WSECT_DRIVER] );
Parm* secsw = ParmMgr.FindParm( parmIDs[SECSWEEP_WSECT_DRIVER] );
Parm* sweep = ParmMgr.FindParm( parmIDs[SWEEP_WSECT_DRIVER] );
Parm* sweeploc = ParmMgr.FindParm( parmIDs[SWEEPLOC_WSECT_DRIVER] );
Parm* secswloc = ParmMgr.FindParm( parmIDs[SECSWEEPLOC_WSECT_DRIVER] );
vector< bool > uptodate;
uptodate.resize( m_Nvar );
for( int i = 0; i < m_Nvar; i++ )
{
uptodate[i] = false;
}
for( int i = 0; i < m_Nchoice; i++ )
{
uptodate[m_CurrChoices[i]] = true;
}
bool parallel = false;
if( vector_contains_val( m_CurrChoices, ( int ) SECSWEEP_WSECT_DRIVER ) )
{
if ( sweep->Get() == secsw->Get() )
{
parallel = true;
}
}
if( vector_contains_val( m_CurrChoices, ( int ) TAPER_WSECT_DRIVER ) ){
if ( taper->Get() == 1.0 )
{
parallel = true;
}
}
if( vector_contains_val( m_CurrChoices, ( int ) TIPC_WSECT_DRIVER ) &&
vector_contains_val( m_CurrChoices, ( int ) ROOTC_WSECT_DRIVER ) )
{
if ( tipC->Get() == rootC->Get() )
{
parallel = true;
}
}
if( vector_contains_val( m_CurrChoices, ( int ) AVEC_WSECT_DRIVER ) &&
vector_contains_val( m_CurrChoices, ( int ) ROOTC_WSECT_DRIVER ) )
{
if ( aveC->Get() == rootC->Get() )
{
parallel = true;
}
}
if( vector_contains_val( m_CurrChoices, ( int ) TIPC_WSECT_DRIVER ) &&
vector_contains_val( m_CurrChoices, ( int ) AVEC_WSECT_DRIVER ) )
{
if ( tipC->Get() == aveC->Get() )
{
parallel = true;
}
}
if( parallel )
{
taper->Set( 1.0 );
uptodate[TAPER_WSECT_DRIVER] = true;
secsw->Set( sweep->Get() );
uptodate[SECSWEEP_WSECT_DRIVER] = true;
if( vector_contains_val( m_CurrChoices, ( int ) ROOTC_WSECT_DRIVER ) )
{
tipC->Set( rootC->Get() );
uptodate[TIPC_WSECT_DRIVER] = true;
aveC->Set( rootC->Get() );
uptodate[AVEC_WSECT_DRIVER] = true;
}
else if( vector_contains_val( m_CurrChoices, ( int ) TIPC_WSECT_DRIVER ) )
{
rootC->Set( tipC->Get() );
uptodate[ROOTC_WSECT_DRIVER] = true;
aveC->Set( tipC->Get() );
uptodate[AVEC_WSECT_DRIVER] = true;
}
else if( vector_contains_val( m_CurrChoices, ( int ) AVEC_WSECT_DRIVER ) )
{
tipC->Set( aveC->Get() );
uptodate[TIPC_WSECT_DRIVER] = true;
rootC->Set( aveC->Get() );
uptodate[ROOTC_WSECT_DRIVER] = true;
}
}
int niter = 0;
while( vector_contains_val( uptodate, false ) )
{
if( !uptodate[AR_WSECT_DRIVER] )
{
if( uptodate[SPAN_WSECT_DRIVER] && uptodate[AREA_WSECT_DRIVER] )
{
AR->Set( span->Get() * span->Get() / area->Get() );
uptodate[AR_WSECT_DRIVER] = true;
}
else if( uptodate[SPAN_WSECT_DRIVER] && uptodate[AVEC_WSECT_DRIVER] )
{
AR->Set( span->Get() / aveC->Get() );
uptodate[AR_WSECT_DRIVER] = true;
}
else if( uptodate[AREA_WSECT_DRIVER] && uptodate[AVEC_WSECT_DRIVER] )
{
AR->Set( area->Get() / ( aveC->Get() * aveC->Get() ) );
uptodate[AR_WSECT_DRIVER] = true;
}
else if( uptodate[SECSWEEP_WSECT_DRIVER] && uptodate[TAPER_WSECT_DRIVER] && !parallel)
{
double tan1 = tan( sweep->Get() * DEG_2_RAD );
double tan2 = tan( secsw->Get() * DEG_2_RAD );
AR->Set( -2.0 * ( ( 1.0 - taper->Get() ) / ( 1.0 + taper->Get() )) * ( sweeploc->Get() - secswloc->Get() ) / ( tan1 - tan2 ) );
uptodate[AR_WSECT_DRIVER] = true;
}
}
if( !uptodate[SPAN_WSECT_DRIVER] )
{
if( uptodate[AVEC_WSECT_DRIVER] && uptodate[AREA_WSECT_DRIVER] )
{
span->Set( area->Get() / aveC->Get() );
uptodate[SPAN_WSECT_DRIVER] = true;
}
else if( uptodate[AR_WSECT_DRIVER] && uptodate[AREA_WSECT_DRIVER] )
{
span->Set( sqrt( AR->Get() * area->Get() ) );
uptodate[SPAN_WSECT_DRIVER] = true;
}
else if( uptodate[AR_WSECT_DRIVER] && uptodate[AVEC_WSECT_DRIVER] )
{
span->Set( AR->Get() * aveC->Get() );
uptodate[SPAN_WSECT_DRIVER] = true;
}
else if( uptodate[SECSWEEP_WSECT_DRIVER] && uptodate[ROOTC_WSECT_DRIVER] && uptodate[TIPC_WSECT_DRIVER] && !parallel)
{
double tan1 = tan( sweep->Get() * DEG_2_RAD );
double tan2 = tan( secsw->Get() * DEG_2_RAD );
span->Set( ( rootC->Get() - tipC->Get() ) * ( sweeploc->Get() - secswloc->Get() ) / ( tan2 - tan1 ) );
uptodate[SPAN_WSECT_DRIVER] = true;
}
}
if( !uptodate[AREA_WSECT_DRIVER] )
{
if( uptodate[SPAN_WSECT_DRIVER] && uptodate[AVEC_WSECT_DRIVER] )
{
area->Set( span->Get() * aveC->Get() );
uptodate[AREA_WSECT_DRIVER] = true;
}
else if( uptodate[SPAN_WSECT_DRIVER] && uptodate[AR_WSECT_DRIVER] )
{
area->Set( span->Get() * span->Get() / AR->Get() );
uptodate[AREA_WSECT_DRIVER] = true;
}
else if( uptodate[AR_WSECT_DRIVER] && uptodate[AVEC_WSECT_DRIVER] )
{
area->Set( AR->Get() * aveC->Get() * aveC->Get() );
uptodate[AREA_WSECT_DRIVER] = true;
}
}
if( !uptodate[AVEC_WSECT_DRIVER] )
{
if( uptodate[TIPC_WSECT_DRIVER] && uptodate[ROOTC_WSECT_DRIVER] )
{
aveC->Set( ( tipC->Get() + rootC->Get() ) / 2.0 );
uptodate[AVEC_WSECT_DRIVER] = true;
}
else if( uptodate[SPAN_WSECT_DRIVER] && uptodate[AREA_WSECT_DRIVER] )
{
aveC->Set( area->Get() / span->Get() );
uptodate[AVEC_WSECT_DRIVER] = true;
}
else if( uptodate[SECSWEEP_WSECT_DRIVER] && uptodate[TAPER_WSECT_DRIVER] && uptodate[SPAN_WSECT_DRIVER] && !parallel)
{
double tan1 = tan( sweep->Get() * DEG_2_RAD );
double tan2 = tan( secsw->Get() * DEG_2_RAD );
aveC->Set( -span->Get() * ( tan1 - tan2 ) * ( 1.0 + taper->Get() ) / ( 2.0 * ( sweeploc->Get() - secswloc->Get() ) * ( 1 - taper->Get() ) ) );
uptodate[AVEC_WSECT_DRIVER] = true;
}
}
if( !uptodate[TIPC_WSECT_DRIVER] )
{
if( uptodate[TAPER_WSECT_DRIVER] && uptodate[ROOTC_WSECT_DRIVER] )
{
tipC->Set( taper->Get() * rootC->Get() );
uptodate[TIPC_WSECT_DRIVER] = true;
}
else if( uptodate[TAPER_WSECT_DRIVER] && uptodate[AVEC_WSECT_DRIVER] )
{
tipC->Set( 2.0 * aveC->Get() / ( 1.0 + ( 1.0 / taper->Get() ) ) );
uptodate[TIPC_WSECT_DRIVER] = true;
}
else if( uptodate[ROOTC_WSECT_DRIVER] && uptodate[AVEC_WSECT_DRIVER] )
{
tipC->Set( 2.0 * aveC->Get() - rootC->Get() );
uptodate[TIPC_WSECT_DRIVER] = true;
}
else if( uptodate[SECSWEEP_WSECT_DRIVER] && uptodate[ROOTC_WSECT_DRIVER] && uptodate[SPAN_WSECT_DRIVER] )
{
double tan1 = tan( sweep->Get() * DEG_2_RAD );
double tan2 = tan( secsw->Get() * DEG_2_RAD );
tipC->Set( rootC->Get() + span->Get() * ( tan1 - tan2 ) / ( sweeploc->Get() - secswloc->Get() ) );
uptodate[TIPC_WSECT_DRIVER] = true;
}
else if( uptodate[SECSWEEP_WSECT_DRIVER] && uptodate[ROOTC_WSECT_DRIVER] && uptodate[AREA_WSECT_DRIVER] )
{
double tan1 = tan( sweep->Get() * DEG_2_RAD );
double tan2 = tan( secsw->Get() * DEG_2_RAD );
double coeff = 2.0 * area->Get() * ( tan1 - tan2 ) / ( sweeploc->Get() - secswloc->Get() );
tipC->Set( sqrt( -1.0 * ( rootC->Get() * rootC->Get() + coeff ) ) );
uptodate[TIPC_WSECT_DRIVER] = true;
}
}
if( !uptodate[ROOTC_WSECT_DRIVER] )
{
if( uptodate[TAPER_WSECT_DRIVER] && uptodate[TIPC_WSECT_DRIVER] )
{
rootC->Set( tipC->Get() / taper->Get() );
uptodate[ROOTC_WSECT_DRIVER] = true;
}
else if( uptodate[TAPER_WSECT_DRIVER] && uptodate[AVEC_WSECT_DRIVER] )
{
rootC->Set( 2.0 * aveC->Get() / ( 1.0 + taper->Get() ) );
uptodate[ROOTC_WSECT_DRIVER] = true;
}
else if( uptodate[TIPC_WSECT_DRIVER] && uptodate[AVEC_WSECT_DRIVER] )
{
rootC->Set( 2.0 * aveC->Get() - tipC->Get() );
uptodate[ROOTC_WSECT_DRIVER] = true;
}
else if( uptodate[SECSWEEP_WSECT_DRIVER] && uptodate[TIPC_WSECT_DRIVER] && uptodate[SPAN_WSECT_DRIVER] )
{
double tan1 = tan( sweep->Get() * DEG_2_RAD );
double tan2 = tan( secsw->Get() * DEG_2_RAD );
rootC->Set( tipC->Get() - span->Get() * ( tan1 - tan2 ) / ( sweeploc->Get() - secswloc->Get() ) );
uptodate[ROOTC_WSECT_DRIVER] = true;
}
else if( uptodate[SECSWEEP_WSECT_DRIVER] && uptodate[TIPC_WSECT_DRIVER] && uptodate[AREA_WSECT_DRIVER] )
{
double tan1 = tan( sweep->Get() * DEG_2_RAD );
double tan2 = tan( secsw->Get() * DEG_2_RAD );
double coeff = 2.0 * area->Get() * ( tan1 - tan2 ) / ( sweeploc->Get() - secswloc->Get() );
rootC->Set( sqrt( tipC->Get() * tipC->Get() - coeff ) );
uptodate[ROOTC_WSECT_DRIVER] = true;
}
}
if( !uptodate[TAPER_WSECT_DRIVER] )
{
if( uptodate[TIPC_WSECT_DRIVER] && uptodate[ROOTC_WSECT_DRIVER] )
{
if ( rootC->Get() == 0.0 )
{
if ( tipC->Get() == 0.0 )
{
taper->Set( 1.0 );
}
else
{
taper->Set( taper->GetUpperLimit() );
}
}
else
{
taper->Set( tipC->Get() / rootC->Get() );
}
uptodate[TAPER_WSECT_DRIVER] = true;
}
else if( uptodate[SECSWEEP_WSECT_DRIVER] && uptodate[AR_WSECT_DRIVER] )
{
double tan1 = tan( sweep->Get() * DEG_2_RAD );
double tan2 = tan( secsw->Get() * DEG_2_RAD );
double coeff = AR->Get() * ( tan1 - tan2 ) / ( 2.0 * ( sweeploc->Get() - secswloc->Get() ) );
taper->Set( ( 1.0 + coeff ) / ( 1.0 - coeff ) );
uptodate[TAPER_WSECT_DRIVER] = true;
}
}
if( !uptodate[SECSWEEP_WSECT_DRIVER] )
{
if( uptodate[TAPER_WSECT_DRIVER] && uptodate[AR_WSECT_DRIVER] )
{
double tan2 = CalcTanSweepAt( secswloc->Get(), sweep->Get(), sweeploc->Get(), AR->Get(), taper->Get() );
secsw->Set( atan( tan2 ) * RAD_2_DEG );
uptodate[SECSWEEP_WSECT_DRIVER] = true;
}
else if( uptodate[ROOTC_WSECT_DRIVER] && uptodate[TIPC_WSECT_DRIVER] && uptodate[SPAN_WSECT_DRIVER] )
{
double tan1 = tan( sweep->Get() * DEG_2_RAD );
double tan2 = tan1 + ( rootC->Get() - tipC->Get() ) * ( sweeploc->Get() - secswloc->Get() ) / span->Get();
secsw->Set( atan( tan2 ) * RAD_2_DEG );
uptodate[SECSWEEP_WSECT_DRIVER] = true;
}
}
// Each pass through the loop should update at least one variable.
// With m_Nvar variables and m_Nchoice initially known, all should
// be updated in ( m_Nvar - m_Nchoice ) iterations. If not, we're
// in an infinite loop.
assert( niter < ( m_Nvar - m_Nchoice ) );
niter++;
}
}
