Commit 89a31988 authored by hrchilds's avatar hrchilds
Browse files

Merge avtStreamlineWrapper into avtStreamline. avtStreamlineFilter now...

Merge avtStreamlineWrapper into avtStreamline.  avtStreamlineFilter now operates directly on avtStreamlines.


git-svn-id: http://visit.ilight.com/svn/visit/trunk/src@11574 18c085ea-50e0-402c-830e-de6fd14e8384
parent 4b690075
......@@ -36,6 +36,9 @@
#
# Modifications:
#
# Hank Childs, Fri Jun 4 17:03:43 CDT 2010
# Remove avtStreamlineWrapper.
#
#****************************************************************************/
SET(AVTFILTERS_SOURCES
......@@ -76,7 +79,6 @@ avtSLAlgorithm.C
avtSmoothPolyDataFilter.C
avtStreamlineFilter.C
avtStreamlinePolyDataFilter.C
avtStreamlineWrapper.C
avtSummationFilter.C
avtSurfaceFilter.C
avtTiledImageCompositor.C
......
......@@ -239,10 +239,13 @@ avtMasterSlaveSLAlgorithm::~avtMasterSlaveSLAlgorithm()
// Dave Pugmire, Wed Apr 1 11:21:05 EDT 2009
// Message size and number of receives put in Initialize().
//
// Hank Childs, Fri Jun 4 19:58:30 CDT 2010
// Use avtStreamlines, not avtStreamlineWrappers.
//
// ****************************************************************************
void
avtMasterSlaveSLAlgorithm::Initialize(std::vector<avtStreamlineWrapper *> &seedPts)
avtMasterSlaveSLAlgorithm::Initialize(std::vector<avtStreamline *> &seedPts)
{
int numRecvs = nProcs-1;
if (numRecvs > 64)
......@@ -258,7 +261,7 @@ avtMasterSlaveSLAlgorithm::ResetStreamlinesForContinueExecute()
}
void
avtMasterSlaveSLAlgorithm::AddStreamlines(std::vector<avtStreamlineWrapper*> &sls)
avtMasterSlaveSLAlgorithm::AddStreamlines(std::vector<avtStreamline*> &sls)
{
EXCEPTION0(ImproperUseException);
}
......@@ -495,10 +498,13 @@ avtMasterSLAlgorithm::~avtMasterSLAlgorithm()
// Dave Pugmire, Fri Feb 12 09:30:27 EST 2010
// Wrong initial sizes for status and prevStatus.
//
// Hank Childs, Fri Jun 4 19:58:30 CDT 2010
// Use avtStreamlines, not avtStreamlineWrappers.
//
// ****************************************************************************
void
avtMasterSLAlgorithm::Initialize(std::vector<avtStreamlineWrapper *> &seedPts)
avtMasterSLAlgorithm::Initialize(std::vector<avtStreamline *> &seedPts)
{
SortStreamlines(seedPts);
avtMasterSlaveSLAlgorithm::Initialize(seedPts);
......@@ -1156,12 +1162,17 @@ avtMasterSLAlgorithm::ProcessOffloadSL(vector<int> &status)
// Programmer: Dave Pugmire
// Creation: March 18, 2009
//
// Modifications:
//
// Hank Childs, Fri Jun 4 19:58:30 CDT 2010
// Use avtStreamlines, not avtStreamlineWrappers.
//
// ****************************************************************************
void
avtMasterSLAlgorithm::ProcessNewStreamlines()
{
list<avtStreamlineWrapper*> newSLs;
list<avtStreamline*> newSLs;
RecvSLs(newSLs);
if (!newSLs.empty())
{
......@@ -1199,7 +1210,7 @@ avtMasterSLAlgorithm::ManageWorkgroup()
domLoaded[i] = 0;
}
list<avtStreamlineWrapper *>::const_iterator s;
list<avtStreamline *>::const_iterator s;
for (s = activeSLs.begin(); s != activeSLs.end(); ++s)
slDomCnts[DomToIdx( (*s)->domain )] ++;
......@@ -1463,6 +1474,9 @@ avtMasterSLAlgorithm::FindSlackers(int oobFactor,
// Dave Pugmire, Sat Mar 28 10:04:01 EDT 2009
// Bug fix. Case1 never happened. forgot the "not" empty.
//
// Hank Childs, Fri Jun 4 19:58:30 CDT 2010
// Use avtStreamlines, not avtStreamlineWrappers.
//
// ****************************************************************************
void
......@@ -1473,7 +1487,7 @@ avtMasterSLAlgorithm::Case1(int &counter)
FindSlackers();
vector< vector< avtStreamlineWrapper *> > distributeSLs(nProcs);
vector< vector< avtStreamline *> > distributeSLs(nProcs);
bool streamlinesToSend = false;
for (int i = 0; i < slackers.size(); i++)
......@@ -1483,7 +1497,7 @@ avtMasterSLAlgorithm::Case1(int &counter)
int cnt = 0;
int slackerRank = slaveInfo[slackers[i]].rank;
list<avtStreamlineWrapper *>::iterator s = activeSLs.begin();
list<avtStreamline *>::iterator s = activeSLs.begin();
while ( !activeSLs.empty() && cnt < maxCnt)
{
......@@ -1540,6 +1554,9 @@ avtMasterSLAlgorithm::Case1(int &counter)
// Dave Pugmire, Fri Feb 12 09:30:27 EST 2010
// Fix memory leak of domCnts.
//
// Hank Childs, Fri Jun 4 19:58:30 CDT 2010
// Use avtStreamlines, not avtStreamlineWrappers.
//
// ****************************************************************************
static bool domCntCompare( const int *a, const int *b) { return a[1] > b[1]; }
......@@ -1552,7 +1569,7 @@ avtMasterSLAlgorithm::Case2(int &counter)
FindSlackers();
vector< vector< avtStreamlineWrapper *> > distributeSLs(nProcs);
vector< vector< avtStreamline *> > distributeSLs(nProcs);
bool streamlinesToSend = false;
for (int s = 0; s < slackers.size(); s++)
......@@ -1607,7 +1624,7 @@ avtMasterSLAlgorithm::Case2(int &counter)
int cnt = 0;
list<avtStreamlineWrapper *>::iterator sl = activeSLs.begin();
list<avtStreamline *>::iterator sl = activeSLs.begin();
while ( !activeSLs.empty() && cnt < maxCnt)
{
......@@ -2052,10 +2069,13 @@ avtSlaveSLAlgorithm::HandleLatencyTimer(int activeSLCnt, bool checkMaxLatency)
// Dave Pugmire, Tue Mar 10 12:41:11 EDT 2009
// Generalized domain to include domain/time. Pathine cleanup.
//
// Hank Childs, Fri Jun 4 19:58:30 CDT 2010
// Use avtStreamlines, not avtStreamlineWrappers.
//
// ****************************************************************************
void
avtSlaveSLAlgorithm::Initialize(std::vector<avtStreamlineWrapper *> &seedPts)
avtSlaveSLAlgorithm::Initialize(std::vector<avtStreamline *> &seedPts)
{
avtMasterSlaveSLAlgorithm::Initialize(seedPts);
status.resize(NUM_DOMAINS,0);
......@@ -2074,6 +2094,11 @@ avtSlaveSLAlgorithm::Initialize(std::vector<avtStreamlineWrapper *> &seedPts)
// Programmer: Dave Pugmire
// Creation: January 27, 2009
//
// Modifications:
//
// Hank Childs, Fri Jun 4 19:58:30 CDT 2010
// Use avtStreamlines, not avtStreamlineWrappers.
//
// ****************************************************************************
void
......@@ -2090,7 +2115,7 @@ avtSlaveSLAlgorithm::UpdateStatus()
}
//Increment/decrement all the streamlines we have.
list<avtStreamlineWrapper *>::const_iterator s;
list<avtStreamline *>::const_iterator s;
bool prevWorkToDo = workToDo;
workToDo = false;
......@@ -2196,12 +2221,12 @@ avtSlaveSLAlgorithm::SendStatus(bool forceSend)
// Enable latency.
//
// Dave Pugmire, Sat Mar 28 10:04:01 EDT 2009
// Resend status if getting no work from master. This is related to the tmp fix
// above in the master.
// Resend status if getting no work from master. This is related to the tmp
// fix above in the master.
//
// Dave Pugmire, Wed Apr 1 11:21:05 EDT 2009
// Latency time was not always being reported accurately. Only send the latency
// saving status update once.
// Latency time was not always being reported accurately. Only send the
// latency saving status update once.
//
// Dave Pugmire, Thu Sep 24 13:52:59 EDT 2009
// Change Execute to RunAlgorithm.
......@@ -2209,12 +2234,15 @@ avtSlaveSLAlgorithm::SendStatus(bool forceSend)
// Dave Pugmire, Fri Sep 25 15:35:32 EDT 2009
// Add auto-load code for slaves.
//
// Hank Childs, Fri Jun 4 19:58:30 CDT 2010
// Use avtStreamlines, not avtStreamlineWrappers.
//
// ****************************************************************************
void
avtSlaveSLAlgorithm::RunAlgorithm()
{
list<avtStreamlineWrapper *>::const_iterator si;
list<avtStreamline *>::const_iterator si;
int timer = visitTimer->StartTimer();
//Send initial status.
......@@ -2225,7 +2253,7 @@ avtSlaveSLAlgorithm::RunAlgorithm()
while (1)
{
//Fill oobSLs list.
list<avtStreamlineWrapper *>::iterator si = activeSLs.begin();
list<avtStreamline *>::iterator si = activeSLs.begin();
while (si != activeSLs.end())
{
if (!DomainLoaded((*si)->domain))
......@@ -2270,7 +2298,7 @@ avtSlaveSLAlgorithm::RunAlgorithm()
HandleLatencyTimer(activeSLs.size());
while (!activeSLs.empty() && !done)
{
avtStreamlineWrapper *s = activeSLs.front();
avtStreamline *s = activeSLs.front();
forceSend = false;
if (activeSLs.size() <= LATENCY_SEND_CNT)
......@@ -2290,7 +2318,7 @@ avtSlaveSLAlgorithm::RunAlgorithm()
activeSLs.pop_front();
debug1<<"Integrate "<<s->domain<<".....";
IntegrateStreamline(s);
if (s->status == avtStreamlineWrapper::TERMINATE)
if (s->status == avtStreamline::STATUS_TERMINATE)
{
terminatedSLs.push_back(s);
numTerminated++;
......@@ -2375,6 +2403,9 @@ avtSlaveSLAlgorithm::RunAlgorithm()
// Dave Pugmire, Sat Mar 28 10:04:01 EDT 2009
// Handle streamline offloading (case5).
//
// Hank Childs, Fri Jun 4 19:58:30 CDT 2010
// Use avtStreamlines, not avtStreamlineWrappers.
//
// ****************************************************************************
void
......@@ -2421,14 +2452,14 @@ avtSlaveSLAlgorithm::ProcessMessages(bool &done, bool &newMsgs)
else
num = maxCnt;
vector< avtStreamlineWrapper *> sendSLs;
vector< avtStreamline *> sendSLs;
for (int d = 0; d < numDoms; d++)
{
int domIdx = msg[4+d];
DomainType dom = IdxToDom(domIdx);
list<avtStreamlineWrapper *>::iterator s = activeSLs.begin();
list<avtStreamline *>::iterator s = activeSLs.begin();
while (s != activeSLs.end() &&
sendSLs.size() < num)
{
......@@ -2473,8 +2504,8 @@ avtSlaveSLAlgorithm::ProcessMessages(bool &done, bool &newMsgs)
int num = msg[4];
debug1<<"MSG: Send "<<num<<" x dom= "<<dom<<" to "<<dst;
list<avtStreamlineWrapper *>::iterator s = activeSLs.begin();
vector< avtStreamlineWrapper *> sendSLs;
list<avtStreamline *>::iterator s = activeSLs.begin();
vector< avtStreamline *> sendSLs;
while (s != activeSLs.end() &&
sendSLs.size() < num)
{
......
......@@ -72,6 +72,9 @@ class SlaveInfo;
// Dave Pugmire, Fri Sep 25 15:35:32 EDT 2009
// New counters.
//
// Hank Childs, Fri Jun 4 19:58:30 CDT 2010
// Use avtStreamlines, not avtStreamlineWrappers.
//
// ****************************************************************************
class avtMasterSlaveSLAlgorithm : public avtParSLAlgorithm
......@@ -81,11 +84,11 @@ class avtMasterSlaveSLAlgorithm : public avtParSLAlgorithm
int maxCount);
virtual ~avtMasterSlaveSLAlgorithm();
virtual void Initialize(std::vector<avtStreamlineWrapper *> &);
virtual void Initialize(std::vector<avtStreamline *> &);
virtual const char* AlgoName() const {return "MasterSlave";}
virtual void ResetStreamlinesForContinueExecute();
virtual void AddStreamlines(std::vector<avtStreamlineWrapper*> &sls);
virtual void AddStreamlines(std::vector<avtStreamline*> &sls);
static avtMasterSlaveSLAlgorithm* Create(avtStreamlineFilter *slFilter,
int maxCount,
......@@ -166,7 +169,7 @@ class avtMasterSLAlgorithm : public avtMasterSlaveSLAlgorithm
virtual ~avtMasterSLAlgorithm();
virtual const char* AlgoName() const {return "MasterSlave";}
virtual void Initialize(std::vector<avtStreamlineWrapper *> &);
virtual void Initialize(std::vector<avtStreamline *> &);
protected:
virtual void RunAlgorithm();
......@@ -193,7 +196,7 @@ class avtMasterSLAlgorithm : public avtMasterSlaveSLAlgorithm
int master;
std::vector<SlaveInfo> slaveInfo, masterInfo;
std::vector<int> slDomCnts, domLoaded, slackers;
std::list<avtStreamlineWrapper *> activeSLs;
std::list<avtStreamline *> activeSLs;
void SendAllSlavesMsg(int msg);
void SendAllSlavesMsg(std::vector<int> &msg);
......@@ -247,7 +250,7 @@ class avtSlaveSLAlgorithm : public avtMasterSlaveSLAlgorithm
int masterRank);
virtual ~avtSlaveSLAlgorithm();
virtual void Initialize(std::vector<avtStreamlineWrapper *> &);
virtual void Initialize(std::vector<avtStreamline *> &);
virtual void SendStatus(bool forceSend=false);
virtual void UpdateStatus();
......@@ -257,7 +260,7 @@ class avtSlaveSLAlgorithm : public avtMasterSlaveSLAlgorithm
int master, numTerminated, timeout;
bool workToDo;
std::vector<int> status, prevStatus;
std::list<avtStreamlineWrapper *> activeSLs, oobSLs;
std::list<avtStreamline *> activeSLs, oobSLs;
void ProcessMessages(bool &done, bool &newMsg);
void HandleLatencyTimer(int activeSLCnt,
......
......@@ -114,10 +114,13 @@ avtParDomSLAlgorithm::~avtParDomSLAlgorithm()
// Establish how many streamlines there are once each proc determines if a
// seed is in the domain.
//
// Hank Childs, Fri Jun 4 19:58:30 CDT 2010
// Use avtStreamlines, not avtStreamlineWrappers.
//
// ****************************************************************************
void
avtParDomSLAlgorithm::Initialize(vector<avtStreamlineWrapper *> &seedPts)
avtParDomSLAlgorithm::Initialize(vector<avtStreamline *> &seedPts)
{
int numRecvs = nProcs-1;
if (numRecvs > 64)
......@@ -139,19 +142,22 @@ avtParDomSLAlgorithm::Initialize(vector<avtStreamlineWrapper *> &seedPts)
//
// Modifications:
//
// Hank Childs, Fri Jun 4 19:58:30 CDT 2010
// Use avtStreamlines, not avtStreamlineWrappers.
//
// ****************************************************************************
void
avtParDomSLAlgorithm::AddStreamlines(std::vector<avtStreamlineWrapper*> &sls)
avtParDomSLAlgorithm::AddStreamlines(std::vector<avtStreamline*> &sls)
{
//Get the SLs that I own.
for (int i = 0; i < sls.size(); i++)
{
avtStreamlineWrapper *s = sls[i];
avtStreamline *s = sls[i];
if (OwnDomain(s->domain))
{
avtVector endPt;
s->GetCurrentLocation(endPt);
s->CurrentLocation(endPt);
if (PointInDomain(endPt, s->domain))
activeSLs.push_back(s);
......@@ -168,7 +174,7 @@ avtParDomSLAlgorithm::AddStreamlines(std::vector<avtStreamlineWrapper*> &sls)
for (int i = 0; i < numSeedPoints; i++)
idBuffer[i] = 0;
list<avtStreamlineWrapper *>::iterator s;
list<avtStreamline *>::iterator s;
for (s = activeSLs.begin(); s != activeSLs.end(); ++s)
idBuffer[(*s)->id]++;
......@@ -191,7 +197,7 @@ avtParDomSLAlgorithm::AddStreamlines(std::vector<avtStreamlineWrapper*> &sls)
/*
debug5<<"Init_totalNumStreamlines= "<<totalNumStreamlines<<endl;
debug5<<"My SLs: "<<endl;
list<avtStreamlineWrapper *>::iterator s;
list<avtStreamline *>::iterator s;
for (s = activeSLs.begin(); s != activeSLs.end(); ++s)
debug5<<"ID "<<(*s)->id<<" dom= "<<(*s)->domain<<endl;
*/
......@@ -293,6 +299,9 @@ avtParDomSLAlgorithm::PreRunAlgorithm()
// Dave Pugmire, Thu Sep 24 13:52:59 EDT 2009
// Replace Execute() with RunAlgorithm().
//
// Hank Childs, Fri Jun 4 19:58:30 CDT 2010
// Use avtStreamlines, not avtStreamlineWrappers.
//
// ****************************************************************************
void
......@@ -304,15 +313,15 @@ avtParDomSLAlgorithm::RunAlgorithm()
while (totalNumStreamlines > 0)
{
//Integrate upto maxCnt streamlines.
list<avtStreamlineWrapper *>::iterator s;
list<avtStreamline *>::iterator s;
int cnt = 0;
while (cnt < maxCnt && !activeSLs.empty())
{
avtStreamlineWrapper *s = activeSLs.front();
avtStreamline *s = activeSLs.front();
activeSLs.pop_front();
IntegrateStreamline(s);
if (s->status == avtStreamlineWrapper::TERMINATE)
if (s->status == avtStreamline::STATUS_TERMINATE)
{
debug5<<"TerminatedSL: "<<s->id<<endl;
terminatedSLs.push_back(s);
......@@ -362,10 +371,13 @@ avtParDomSLAlgorithm::RunAlgorithm()
// Dave Pugmire, Tue Nov 3 09:15:41 EST 2009
// Bug fix. Set the new domain before communicating SL.
//
// Hank Childs, Fri Jun 4 19:58:30 CDT 2010
// Use avtStreamlines, not avtStreamlineWrappers.
//
// ****************************************************************************
void
avtParDomSLAlgorithm::HandleOOBSL(avtStreamlineWrapper *s)
avtParDomSLAlgorithm::HandleOOBSL(avtStreamline *s)
{
// The integrated streamline could lie in multiple domains.
// Duplicate the SL and send to the proper owner.
......@@ -384,7 +396,7 @@ avtParDomSLAlgorithm::HandleOOBSL(avtStreamlineWrapper *s)
}
else
{
vector<avtStreamlineWrapper *> sls;
vector<avtStreamline *> sls;
sls.push_back(s);
SendSLs(domRank, sls);
//debug5<<"Handle OOB: id= "<<s->id<<" "<<s->domain<<" --> "<<domRank<<endl;
......@@ -403,6 +415,8 @@ avtParDomSLAlgorithm::HandleOOBSL(avtStreamlineWrapper *s)
//
// Modifications:
//
// Hank Childs, Fri Jun 4 19:58:30 CDT 2010
// Use avtStreamlines, not avtStreamlineWrappers.
//
// ****************************************************************************
......@@ -411,7 +425,7 @@ avtParDomSLAlgorithm::ResetStreamlinesForContinueExecute()
{
while (! terminatedSLs.empty())
{
avtStreamlineWrapper *s = terminatedSLs.front();
avtStreamline *s = terminatedSLs.front();
terminatedSLs.pop_front();
activeSLs.push_back(s);
......
......@@ -77,6 +77,9 @@
// Hank Childs, Fri Feb 19 16:20:45 CST 2010
// Add PreRunAlgorithm.
//
// Hank Childs, Fri Jun 4 19:58:30 CDT 2010
// Use avtStreamlines, not avtStreamlineWrappers.
//
// ****************************************************************************
class avtParDomSLAlgorithm : public avtParSLAlgorithm
......@@ -85,8 +88,8 @@ class avtParDomSLAlgorithm : public avtParSLAlgorithm
avtParDomSLAlgorithm(avtStreamlineFilter *slFilter, int maxCount);
virtual ~avtParDomSLAlgorithm();
virtual void Initialize(std::vector<avtStreamlineWrapper *> &);
virtual void AddStreamlines(std::vector<avtStreamlineWrapper*> &sls);
virtual void Initialize(std::vector<avtStreamline *> &);
virtual void AddStreamlines(std::vector<avtStreamline*> &sls);
virtual void ResetStreamlinesForContinueExecute();
virtual const char* AlgoName() const {return "ParallelStaticDomains";}
......@@ -94,11 +97,11 @@ class avtParDomSLAlgorithm : public avtParSLAlgorithm
virtual void RunAlgorithm();
virtual void PreRunAlgorithm();
void ExchangeTermination();
void HandleOOBSL(avtStreamlineWrapper *s);
void HandleOOBSL(avtStreamline *s);
int numSLChange, totalNumStreamlines;
std::list<avtStreamlineWrapper *> activeSLs;
std::list<avtStreamline *> activeSLs;
int maxCnt;
};
......
......@@ -108,10 +108,13 @@ avtParSLAlgorithm::~avtParSLAlgorithm()
// Dave Pugmire, Wed Apr 1 11:21:05 EDT 2009
// Limit the number of async recvs outstanding.
//
// Hank Childs, Fri Jun 4 19:58:30 CDT 2010
// Use avtStreamlines, not avtStreamlineWrappers.
//
// ****************************************************************************
void
avtParSLAlgorithm::Initialize(vector<avtStreamlineWrapper *> &seedPts,
avtParSLAlgorithm::Initialize(vector<avtStreamline *> &seedPts,
int msgSz,
int numRecvs)
{
......@@ -174,6 +177,9 @@ avtParSLAlgorithm::PostExecute()
// Dave Pugmire, Wed Apr 1 11:21:05 EDT 2009
// Limit the number of async recvs outstanding.
//
// Hank Childs, Fri Jun 4 19:58:30 CDT 2010
// Use avtStreamlines, not avtStreamlineWrappers.
//
// ****************************************************************************
void
......@@ -191,10 +197,10 @@ avtParSLAlgorithm::InitRequests()
}
static int
CountIDs(list<avtStreamlineWrapper *> &l, int id)
CountIDs(list<avtStreamline *> &l, int id)
{
int cnt = 0;
list<avtStreamlineWrapper*>::const_iterator si = l.begin();
list<avtStreamline*>::const_iterator si = l.begin();
for (si = l.begin(); si != l.end(); si++)
{
if ((*si)->id == id)
......@@ -216,6 +222,11 @@ CountIDs(list<avtStreamlineWrapper *> &l, int id)
// Programmer: Dave Pugmire
// Creation: September 21, 2009
//
// Modifications:
//
// Hank Childs, Fri Jun 4 19:58:30 CDT 2010
// Use avtStreamlines, not avtStreamlineWrappers.
//
// ****************************************************************************
void
......@@ -235,10 +246,10 @@ avtParSLAlgorithm::ExchangeSLSteps()
long *idBuffer = new long[2*N], *myIDs = new long[2*N];
//Sort the terminated/communicated SLs by id.
terminatedSLs.sort(avtStreamlineWrapper::IdSeqCompare);
communicatedSLs.sort(avtStreamlineWrapper::IdSeqCompare);
terminatedSLs.sort(avtStreamline::IdSeqCompare);
communicatedSLs.sort(avtStreamline::IdSeqCompare);
vector<vector<avtStreamlineWrapper *> >sendSLs(N);
vector<vector<avtStreamline *> >sendSLs(N);
vector<int> owners(N);
int minId = 0;
......@@ -261,7 +272,7 @@ avtParSLAlgorithm::ExchangeSLSteps()
//Set array for SLs that terminated here. Update sequence counts for communicated
//SLs.
list<avtStreamlineWrapper*>::iterator t = terminatedSLs.begin();
list<avtStreamline*>::iterator t = terminatedSLs.begin();
while (t != terminatedSLs.end() && (*t)->id <= maxId)
{
if ((*t)->id >= minId)
......@@ -275,7 +286,7 @@ avtParSLAlgorithm::ExchangeSLSteps()
t++;
}
list<avtStreamlineWrapper*>::const_iterator c = communicatedSLs.begin();
list<avtStreamline*>::const_iterator c = communicatedSLs.begin();
while (c != communicatedSLs.end() && (*c)->id <= maxId)
{
if ((*c)->id >= minId)
......@@ -301,7 +312,7 @@ avtParSLAlgorithm::ExchangeSLSteps()
//Send communicatedSLs to the owners.
while (!communicatedSLs.empty())
{
avtStreamlineWrapper *s = communicatedSLs.front();
avtStreamline *s = communicatedSLs.front();
if (s->id <= maxId)
{
int idx = s->id%N;
......@@ -310,7 +321,7 @@ avtParSLAlgorithm::ExchangeSLSteps()
terminatedSLs.push_back(s);
else
{
s->serializeFlags = avtStreamlineWrapper::SERIALIZE_STEPS; //Write SL steps.
s->serializeFlags = avtStreamline::SERIALIZE_STEPS; //Write SL steps.
sendSLs[idx].push_back(s);
owners[idx] = owner;
}
......@@ -339,7 +350,7 @@ avtParSLAlgorithm::ExchangeSLSteps()
RecvSLs(terminatedSLs);
//See if we have all the sequences we need.
terminatedSLs.sort(avtStreamlineWrapper::IdSeqCompare);
terminatedSLs.sort(avtStreamline::IdSeqCompare);
bool needMore = false;
for (int i = 0; i < N && !needMore; i++)
if (idBuffer[i] == rank)
......@@ -370,26 +381,31 @@ avtParSLAlgorithm::ExchangeSLSteps()
// Programmer: Dave Pugmire
// Creation: Sept 21, 2009
//
// Modifications:
//
// Hank Childs, Fri Jun 4 19:58:30 CDT 2010
// Use avtStreamlines, not avtStreamlineWrappers.
//
// ****************************************************************************
void
avtParSLAlgorithm::MergeTerminatedSLSequences()
{
//Sort them by id and sequence so we can process them one at a time.
terminatedSLs.sort(avtStreamlineWrapper::IdSeqCompare);
terminatedSLs.sort(avtStreamline::IdSeqCompare);
//Split them up into sequences.
vector<vector<avtStreamlineWrapper *> > seqs;
vector<vector<avtStreamline *> > seqs;
while (!terminatedSLs.empty())
{
avtStreamlineWrapper *s = terminatedSLs.front();
avtStreamline *s = terminatedSLs.front();
terminatedSLs.pop_front();
//Empty or new ID, add a new entry.
if (seqs.size() == 0 ||
seqs[seqs.size()-1][0]->id != s->id)
{