Bool CDynamicStringArray::AddString(const String &str)
{
String* pStr = GetNextObject();
if (!pStr)
return false;
*pStr = str;
return true;
}
Bool CDynamicFilenameArray::AddFilename(const Filename &fn)
{
Filename* pFn = GetNextObject();
if (!pFn)
return false;
*pFn = fn;
return true;
}
void CImage::EditApplyAll( BOOL fApplyData, BOOL fApplyAlpha )
{
LPOBJECT lpObject;
lpObject = NULL;
while ( lpObject = GetNextObject(lpObject, YES, NO) )
ObjEditApply( lpObject, fApplyData, fApplyAlpha, NO );
}
int CImage::CountObjects()
{
LPOBJECT lpObject = NULL;
int nCount = 0;
while (lpObject = GetNextObject(lpObject, YES, NO))
++nCount;
return(nCount);
}
void CImage::InvertSelection()
{
LPOBJECT lpObject;
lpObject = GetBase();
while (lpObject = GetNextObject(lpObject, YES, NO))
ObjSelectObject((LPPRIMOBJECT)lpObject, !lpObject->fSelected);
SetupMiniViews(NULL, YES);
}
// set propagate and alternate propagate
MaterialBase *MaterialBase::SetFinalPropagate(void)
{ int i;
for(i=0;i<=1;i++)
{ if(criterion[i]==UNSPECIFIED) criterion[i]=fmobj->propagate[i];
if(matPropagateDirection[i]==UNSPECIFIED) matPropagateDirection[i]=fmobj->propagateDirection[i];
if(tractionMat[i]<=0) tractionMat[i]=fmobj->propagateMat[i];
}
return (MaterialBase *)GetNextObject();
}
void CImage::KeepFrameTempObjects()
{
LPOBJECT lpObject = NULL;
while (lpObject = GetNextObject(lpObject, YES, NO))
{
if ( lpObject->StorageType == ST_TEMPORARY &&
lpObject->ObjectType == OT_FRAME )
lpObject->StorageType = ST_PERMANENT;
}
}
WORD CImage::GetNextGroupID()
{
LPOBJECT lpObject = NULL;
WORD wGroupID = 0;
while (lpObject = GetNextObject(lpObject, YES, NO))
{
if (lpObject->wGroupID > wGroupID)
wGroupID = lpObject->wGroupID;
}
return(wGroupID+1);
}
BOOL CImage::MultipleObjects()
{
LPOBJECT lpObject = NULL;
int nCount = 0;
while (lpObject = GetNextObject(lpObject, YES, NO))
{
++nCount;
if (nCount > 1)
return(TRUE);
}
return(FALSE);
}
// hold active linear loads at current values. Leave rest alone
// input is analysis time in seconds
MatPtLoadBC *MatPtLoadBC::MakeConstantLoad(double bctime)
{
switch(style)
{ case LINEAR_VALUE:
if(bctime>=GetBCFirstTime())
{ style=CONSTANT_VALUE;
SetBCValueCU(BCValue(bctime));
}
break;
default:
break;
}
return (MatPtLoadBC *)GetNextObject();
}
OGRFeature* OGRGeoJSONSeqLayer::GetNextFeature()
{
while( true )
{
auto poObject = GetNextObject();
if( !poObject )
return nullptr;
OGRFeature* poFeature;
auto type = OGRGeoJSONGetType(poObject);
if( type == GeoJSONObject::eFeature )
{
poFeature = m_oReader.ReadFeature(
this, poObject, m_osFeatureBuffer.c_str() );
json_object_put(poObject);
}
else if( type == GeoJSONObject::eFeatureCollection ||
type == GeoJSONObject::eUnknown )
{
json_object_put(poObject);
continue;
}
else
{
OGRGeometry* poGeom = m_oReader.ReadGeometry(poObject,
GetSpatialRef());
json_object_put(poObject);
if( !poGeom )
{
continue;
}
poFeature = new OGRFeature(m_poFeatureDefn);
poFeature->SetGeometryDirectly(poGeom);
}
if( poFeature->GetFID() == OGRNullFID )
{
poFeature->SetFID(m_nNextFID);
m_nNextFID ++;
}
if( (m_poFilterGeom == nullptr ||
FilterGeometry(poFeature->GetGeomFieldRef(m_iGeomFieldFilter)) )
&& (m_poAttrQuery == nullptr ||
m_poAttrQuery->Evaluate(poFeature)) )
{
return poFeature;
}
delete poFeature;
}
}
// print to output
BoundaryCondition *MatPtFluxBC::PrintBC(ostream &os)
{
char nline[200];
sprintf(nline,"%7d %2d %2d %2d %15.7e %15.7e",ptNum,direction,face,style,
UnitsController::Scaling(1.e3)*GetBCValueOut(),GetBCFirstTimeOut());
os << nline;
PrintFunction(os);
// for function input scale for Legacy units
if(style==FUNCTION_VALUE)
scale = UnitsController::Scaling(1.e-3);
return (BoundaryCondition *)GetNextObject();
}
// hold active linear loads at current values. Leave rest alone
// input is analysis time in seconds
MatPtLoadBC *MatPtLoadBC::MakeConstantLoad(double bctime)
{
double mstime=1000.*bctime;
switch(style)
{ case LINEAR_VALUE:
if(mstime>=ftime)
{ style=CONSTANT_VALUE;
value=BCValue(mstime);
}
break;
default:
break;
}
return (MatPtLoadBC *)GetNextObject();
}
// print to output
BoundaryCondition *MatPtLoadBC::PrintBC(ostream &os)
{
char nline[200];
sprintf(nline,"%7d %2d %2d %15.7e %15.7e",ptNum,direction,style,
UnitsController::Scaling(1.e-6)*GetBCValueOut(),GetBCFirstTimeOut());
os << nline;
PrintFunction(os);
// initial value is F in N or N/numParticles if net, but if function
// initial value is 1 or 1/numParticles if net
// rescale ... for fuction value is 1 or 1/numParticles if net force
if(style==FUNCTION_VALUE)
scale = GetBCValue();
return (BoundaryCondition *)GetNextObject();
}
// reverse active linear loads. Leave rest alone
// input is analysis time in seconds
// if LINEAR_VALUE, set finalTime to time when load returns to zero
MatPtLoadBC *MatPtLoadBC::ReverseLinearLoad(double bctime,double *finalTime)
{
double mstime=1000.*bctime;
switch(style)
{ case LINEAR_VALUE:
if(mstime>=ftime)
{ offset=BCValue(mstime);
value=-value;
ftime=mstime;
// new BC is offset+value*(mstime-ftime), which is zero when mstime = ftime-offset/value
*finalTime = 0.001*(ftime - offset/value);
}
break;
default:
break;
}
return (MatPtLoadBC *)GetNextObject();
}
// print to output
BoundaryCondition *MatPtLoadBC::PrintBC(ostream &os)
{
char nline[200];
sprintf(nline,"%7d %2d %2d %15.7e %15.7e",ptNum,direction,style,value,ftime);
os << nline;
PrintFunction(os);
// initial value is F in N or N/numParticles if net, but if function
// initial value is 1 or 1/numParticles if net
// rescale
value*=1.e6; // Multiply by 1e6 to get N (kg-m/sec^2) to g-mm/sec^2
if(style==FUNCTION_VALUE)
scale=value; // ... value is now 1.e6 or 1.e6/numParticles if net force
else
scale*=1.e6; // ... same in case using a function
return (BoundaryCondition *)GetNextObject();
}
// increment external load on a particle
// input is analysis time in seconds
MatPtLoadBC *MatPtLoadBC::AddMPLoad(double bctime)
{
if(style!=SILENT)
{ double mstime=1000.*bctime;
Vector *pFext=mpm[ptNum-1]->GetPFext();
if(direction==X_DIRECTION)
pFext->x+=BCValue(mstime);
else if(direction==Y_DIRECTION)
pFext->y+=BCValue(mstime);
else
pFext->z+=BCValue(mstime);
}
else
{ double mp=mpm[ptNum-1]->mp; // in g
int matnum=mpm[ptNum-1]->MatID();
double cd=theMaterials[matnum]->WaveSpeed(FALSE,mpm[ptNum-1]); // in mm/sec (2D or isotropic only)
double cs=theMaterials[matnum]->ShearWaveSpeed(FALSE,mpm[ptNum-1]); // in mm/sec
Vector pVel=mpm[ptNum-1]->vel;
Vector *pFext=mpm[ptNum-1]->GetPFext();
// get forces in g-mm/sec^2
if(direction==X_DIRECTION)
{ pFext->x-=mp*cd*pVel.x/(2.*mpmgrid.partx);
pFext->y-=mp*cs*pVel.y/(2.*mpmgrid.partx);
pFext->z-=mp*cs*pVel.z/(2.*mpmgrid.partx);
}
else if(direction==Y_DIRECTION)
{ pFext->x-=mp*cs*pVel.x/(2.*mpmgrid.party);
pFext->y-=mp*cd*pVel.y/(2.*mpmgrid.party);
pFext->z-=mp*cs*pVel.z/(2.*mpmgrid.party);
}
else
{ pFext->x-=mp*cs*pVel.x/(2.*mpmgrid.partz);
pFext->y-=mp*cs*pVel.y/(2.*mpmgrid.partz);
pFext->z-=mp*cd*pVel.z/(2.*mpmgrid.partz);
}
}
return (MatPtLoadBC *)GetNextObject();
}
//----------------------------------------------------------------------------
void CDigitalTraineeStudioDoc::Serialize(CArchive& ar){
//----------------------------------------------------------------------------
PROC_TRACE;
// Alle Objecte Einlesen....eventuell sind auch ein
// paar ViewPoint darunter. Dise muessen dann `von Hand` mit
// dem OsziView verbunden werden
//
inherited::Serialize(ar);
if (ar.IsLoading()){
// den ersten View finden ....und den einzigsten
//
POSITION pos = GetFirstViewPosition();
if(pos != NULL){
CView* pView = GetNextView(pos);
if(pView && pView->IsKindOf(RUNTIME_CLASS(CDigitalTraineeStudioView))) {
CDigitalTraineeStudioView *dragDropView = (CDigitalTraineeStudioView *)pView;
// Alle OsziStrokes finden
//
POSITION objPos = GetFirstObjectPos();
while(objPos!= NULL){
DragDropObject* obj = (DragDropObject*)GetNextObject( objPos );
if(obj->IsKindOf(RUNTIME_CLASS(CElectricPortLink))){
CElectricPortLink* link = (CElectricPortLink*)obj;
COsziStroke* stroke = link->GetOsziStroke();
if(stroke !=NULL){
dragDropView->m_osziView->Add(stroke);
}
}
}
}
}
}
}
int CImage::GetDirtyState()
{
LPOBJECT lpObject = NULL;
int dirty = NO;
int ObjDirty;
while (lpObject = GetNextObject(lpObject, YES, NO))
{
if (Control.UndoObjects && !IsSelectedObject(lpObject))
continue;
if (lpObject->DataDirty)
ObjDirty = lpObject->DataDirty;
else if ((lpObject != GetBase()) && lpObject->lpAlpha &&
lpObject->AlphaDirty)
ObjDirty = lpObject->AlphaDirty;
else
continue;
if (!dirty)
dirty = ObjDirty;
else if (ObjDirty != dirty)
return(IDS_EDITS);
}
return(dirty);
}
BOOL CImage::GetUndoState()
{
LPOBJECT lpObject = NULL;
BOOL ObjUndoNotRedo;
int UndoNotRedo = -1;
while (lpObject = GetNextObject(lpObject, YES, NO))
{
if (Control.UndoObjects && !IsSelectedObject(lpObject))
continue;
if (lpObject->DataDirty)
ObjUndoNotRedo = lpObject->DataUndoNotRedo;
else if ((lpObject != GetBase()) && lpObject->lpAlpha &&
lpObject->AlphaDirty)
ObjUndoNotRedo = lpObject->AlphaUndoNotRedo;
else
continue;
if (UndoNotRedo < 0)
UndoNotRedo = ObjUndoNotRedo;
else if (ObjUndoNotRedo != UndoNotRedo)
return(TRUE);
}
return(UndoNotRedo);
}
void CImage::ObjEditApply(LPOBJECT lpObject,
BOOL fApplyData, BOOL fApplyAlpha,
BOOL fInitFrame)
{
LPALPHA lpAlpha;
LPOBJECT lpNext;
BOOL fInitingData, fInitingAlpha;
if (!fApplyData && !fApplyAlpha)
return;
lpObject->InitUndoType = 0;
fInitingAlpha = fInitFrame && fApplyAlpha;
fInitingData = fInitFrame && fApplyData;
lpAlpha = lpObject->lpAlpha;
if (fApplyData)
{
if (lpObject->fBothDirty)
fApplyAlpha = YES;
if (lpObject == GetBase())
{
PurgeObjects();
lpNext = lpObject;
while (lpNext = GetNextObject(lpNext, YES, NO, NO))
lpNext->fUndoDeleted = NO;
}
if (!fInitingData)
PixmapFreeUndo(&lpObject->Pixmap);
else
PixmapEditApply(&lpObject->Pixmap);
if (lpObject->lpUndoText)
{
delete lpObject->lpUndoText;
lpObject->lpUndoText = NULL;
}
if (lpObject->UndoColorMap)
{
FrameDestroyColorMap(lpObject->UndoColorMap);
lpObject->UndoColorMap = NULL;
}
lpObject->DataUndoType = 0;
lpObject->DataDirty = NO;
}
if (fApplyAlpha)
{
if (lpObject->lpUndoAlpha)
{
MaskClose(lpObject->lpUndoAlpha);
lpObject->lpUndoAlpha = NULL;
}
if (lpAlpha)
{
if (!fInitingAlpha)
PixmapFreeUndo(&lpAlpha->Pixmap);
else
PixmapEditApply(&lpAlpha->Pixmap);
}
lpObject->AlphaUndoType = 0;
lpObject->AlphaDirty = NO;
}
lpObject->fBothDirty = NO;
}
void CImage::ObjEditUndo(LPOBJECT lpObject, BOOL fUndoData, BOOL fUndoAlpha)
{
RECT rTemp;
BOOL fSelected, Resolution, fDeleted, fBase, bLocked;
LPALPHA lpAlpha, lpTemp;
LPOBJECT lpNext;
int XSize, YSize;
int tempDataType;
LPCOLORMAP lpColorMap;
int GroupID;
lpAlpha = lpObject->lpAlpha;
fBase = lpObject == GetBase();
if (fUndoData && lpObject->DataDirty)
{
if (lpObject->DataUndoType & UT_RESOLUTION)
Resolution = FrameResolution(lpObject->Pixmap.EditFrame);
if (lpObject->DataUndoType & UT_COLORMAP)
{
if (lpColorMap = FrameGetColorMap(ObjGetEditFrame(lpObject)))
lpColorMap = FrameCopyColorMap(lpColorMap);
else
lpColorMap = NULL;
}
if (lpObject->DataUndoType & (UT_DATA|UT_NEWDATA))
{
PixmapEditUndo(&lpObject->Pixmap);
if (fBase)
{
npix = FrameXSize(ObjGetEditFrame(lpObject));
nlin = FrameYSize(ObjGetEditFrame(lpObject));
if (lpObject->DataUndoType & UT_NEWDATA)
{
tempDataType = DataType;
DataType = UndoDataType;
UndoDataType = tempDataType;
}
}
}
if (lpObject->DataUndoType & UT_OBJECTRECT)
{
rTemp = lpObject->rObject;
lpObject->rObject = lpObject->rUndoObject;
lpObject->rUndoObject = rTemp;
}
if (lpObject->DataUndoType & UT_RESOLUTION)
{
FrameSetResolution( lpObject->Pixmap.EditFrame,
lpObject->UndoResolution);
lpObject->UndoResolution = Resolution;
}
if (lpObject->DataUndoType & UT_UNDOTEXTDATA)
{
if (lpObject->lpUndoText)
{
CTextObject *pTmp = lpObject->lpUndoText;
lpObject->lpUndoText = lpObject->lpText;
lpObject->lpText = pTmp;
}
}
if (lpObject->DataUndoType & UT_COLORMAP)
{
if (lpObject->UndoColorMap)
{
FrameSetColorMap( ObjGetEditFrame(lpObject), lpObject->UndoColorMap);
FrameDestroyColorMap(lpObject->UndoColorMap);
}
lpObject->UndoColorMap = lpColorMap;
}
if (lpObject->DataUndoType & UT_SELECTION)
{
fSelected = lpObject->fSelected;
lpObject->fSelected = lpObject->fUndoSelected;
lpObject->fUndoSelected = fSelected;
}
if (lpObject->DataUndoType & UT_LOCKOBJECTS)
{
bLocked = lpObject->bLocked;
lpObject->bLocked = lpObject->bUndoLocked;
lpObject->bUndoLocked = bLocked;
}
if (lpObject->DataUndoType & UT_GROUPOBJECTS)
{
GroupID = lpObject->wGroupID;
lpObject->wGroupID = lpObject->UndoGroupID;
lpObject->UndoGroupID = GroupID;
}
if (lpObject->DataUndoType & UT_DELETEOBJECTS)
{
lpNext = lpObject;
while (lpNext = GetNextObject(lpNext, YES, NO, YES))
{
if (lpNext->fUndoDeleted || lpNext->fDeleted)
{
fDeleted = lpNext->fDeleted;
lpNext->fDeleted = lpNext->fUndoDeleted;
lpNext->fUndoDeleted = fDeleted;
}
}
}
if (fBase && lpObject->DataUndoType & UT_MOVEOBJECTS)
{
lpNext = lpObject;
while (lpNext = GetNextObject(lpNext, YES, NO, NO))
{
rTemp = lpNext->rObject;
lpNext->rObject = lpNext->rUndoObject;
lpNext->rUndoObject = rTemp;
}
}
lpObject->DataUndoNotRedo = !lpObject->DataUndoNotRedo;
if (!fUndoAlpha)
fUndoAlpha = lpObject->fBothDirty;
}
else if (fUndoAlpha && lpObject->fBothDirty)
fUndoAlpha = NO;
if (fUndoAlpha && lpObject->AlphaDirty)
{
if (lpAlpha)
{
if (lpObject->AlphaUndoType & (UT_ALPHA|UT_NEWALPHA))
{
PixmapEditUndo(&lpAlpha->Pixmap);
rTemp = lpAlpha->rMask;
lpAlpha->rMask = lpAlpha->rUndoMask;
lpAlpha->rUndoMask = rTemp;
}
}
if (lpObject->AlphaUndoType & (UT_CREATEMASK|UT_DELETEMASK))
{
lpTemp = lpObject->lpAlpha;
lpObject->lpAlpha = lpObject->lpUndoAlpha;
lpObject->lpUndoAlpha = lpTemp;
}
lpObject->AlphaUndoNotRedo = !lpObject->AlphaUndoNotRedo;
}
lpAlpha = lpObject->lpAlpha;
// check to make sure the mask is still the same size
if (fUndoData && fBase && lpObject->Pixmap.fNewFrame)
{
// we just undid to a different size frame bag mask delete undo
if (lpObject->lpUndoAlpha && !lpObject->fBothDirty)
ObjEditApply(lpObject, NO, YES, NO);
if (lpAlpha)
{
XSize = FrameXSize(lpAlpha->Pixmap.EditFrame);
YSize = FrameYSize(lpAlpha->Pixmap.EditFrame);
if (XSize != FrameXSize(lpObject->Pixmap.EditFrame) ||
YSize != FrameYSize(lpObject->Pixmap.EditFrame))
{
ObjEditInit(lpObject, UT_DELETEMASK);
// dont free mask if it was stored for later undo/redo
if (!lpObject->lpUndoAlpha)
MaskClose(lpObject->lpAlpha);
lpObject->fBothDirty = YES;
lpObject->AlphaDirty = lpObject->DataDirty;
lpObject->lpAlpha = NULL;
}
}
}
}
BOOL CImage::ObjEditInit(LPOBJECT lpObject, UNDO_TYPE UndoType)
{
LPALPHA lpAlpha;
LPOBJECT lpNext;
BOOL fBase, fDataInit, fAlphaInit;
LPCOLORMAP lpColorMap;
// See if this objects the base, and get alpha channel of object
fBase = (lpObject == GetBase());
lpAlpha = lpObject->lpAlpha;
//
// HANDLE INITIALIZATION OF OBJECT DATA
//
fDataInit = (UndoType & UT_DATAUNDO) != 0;
if (fDataInit && !(Control.NoUndo || fDisableUndos))
{
// Apply any changes that have been made if in auto apply mode
// or if in manual apply mode and changes have been undone
// the init flag is set only if we are doing an edit in place change
// to the data so we get rid of any useless undo's
if (!Control.UseApply || ( Control.UseApply && !lpObject->DataUndoNotRedo ) )
ObjEditApply(lpObject, YES, !fBase, (UndoType & UT_DATA) != 0);
// Save undo information for the specific type of operation
if (UndoType & UT_UNDOTEXTDATA && !(lpObject->DataUndoType & UT_UNDOTEXTDATA))
lpObject->lpUndoText = new CTextObject(*lpObject->lpText);
if (UndoType & UT_OBJECTRECT && !(lpObject->DataUndoType & UT_OBJECTRECT))
lpObject->rUndoObject = lpObject->rObject;
if (UndoType & UT_RESOLUTION && !(lpObject->DataUndoType & UT_RESOLUTION))
lpObject->UndoResolution = FrameResolution(ObjGetEditFrame(lpObject));
if (UndoType & UT_COLORMAP && !(lpObject->DataUndoType & UT_COLORMAP))
{
if (lpColorMap = FrameGetColorMap(ObjGetEditFrame(lpObject)))
lpObject->UndoColorMap = FrameCopyColorMap(lpColorMap);
else
lpObject->UndoColorMap = NULL;
}
if (UndoType & UT_SELECTION && !(lpObject->DataUndoType & UT_SELECTION))
lpObject->fUndoSelected = lpObject->fSelected;
// Size base is a special case for the base and base only
if (UndoType & UT_DATA)
{
// init the data pixmap for editing
if (!lpObject->Pixmap.UndoFrame)
if (!PixmapInitUndo(&lpObject->Pixmap))
return(FALSE);
}
if (UndoType & UT_NEWDATA)
{
if (fBase)
UndoDataType = DataType;
}
if (fBase && UndoType & UT_MOVEOBJECTS &&
!(lpObject->DataUndoType & UT_MOVEOBJECTS))
{
lpNext = lpObject;
while (lpNext = GetNextObject(lpNext, YES, NO, NO))
{
ObjEditApply(lpNext, TRUE, TRUE, FALSE);
lpNext->rUndoObject = lpNext->rObject;
}
}
// Delete objects is a special case for the base and base only
if (fBase && UndoType & UT_DELETEOBJECTS &&
!(lpObject->DataUndoType & UT_DELETEOBJECTS))
{
lpNext = lpObject;
while (lpNext = GetNextObject(lpNext, YES, NO, YES))
lpNext->fUndoDeleted = NO;
}
if (UndoType & UT_GROUPOBJECTS && !(lpObject->DataUndoType & UT_GROUPOBJECTS))
lpObject->UndoGroupID = lpObject->wGroupID;
if (UndoType & UT_LOCKOBJECTS && !(lpObject->DataUndoType & UT_LOCKOBJECTS))
lpObject->bUndoLocked = lpObject->bLocked;
}
// now that we have successfully initialized everything set UndoTypes
if (fDataInit)
{
lpObject->DataUndoNotRedo = YES;
lpObject->DataUndoType |= (UndoType & UT_DATAUNDO);
}
//
// HANDLE INITIALIZATION OF OBJECT ALPHA
//
fAlphaInit = (UndoType & UT_ALPHAUNDO) != 0;
if (fAlphaInit && !(Control.NoUndo || fDisableUndos) && (!fBase || Control.UndoMasks))
{
// Apply any changes that have been made if in auto apply mode
// or if in manual apply mode and changes have been undone or
// apply any changes only to the mask
// or if it is a change to both data and mask and
// both were not dirty before
// Initialize the data undo if the object is not the base and we didn't
// already do a data init
// the init flag is set only if we are doing an edit in place change
// to the alpha so we get rid of any useless undo's
if (!Control.UseApply ||
(Control.UseApply && !lpObject->AlphaUndoNotRedo) ||
(fBase && (!fDataInit || !lpObject->fBothDirty)))
ObjEditApply(lpObject, fDataInit ? NO : !fBase, YES,
(UndoType & UT_ALPHA) != 0);
// Save undo information for the specific type of operation
if (lpAlpha)
{
if (!lpObject->AlphaUndoType)
{
if (UndoType & UT_ALPHA)
{
// init the data pixmap for editing
if (!lpAlpha->Pixmap.UndoFrame)
if (!PixmapInitUndo(&lpAlpha->Pixmap))
return(FALSE);
lpAlpha->rUndoMask = lpAlpha->rMask;
}
if (UndoType & UT_NEWALPHA)
lpAlpha->rUndoMask = lpAlpha->rMask;
if (fBase && UndoType & UT_CREATEMASK)
lpObject->lpUndoAlpha = NULL;
if (fBase && UndoType & UT_DELETEMASK)
lpObject->lpUndoAlpha = lpAlpha;
if (UndoType & UT_ALPHAUNDO)
{
lpObject->AlphaUndoNotRedo = YES;
lpObject->AlphaUndoType |= (UndoType & UT_ALPHAUNDO);
}
}
}
}
return(TRUE);
}
BOOL CImage::EditInit( EDIT_TARGET Target, UNDO_TYPE UndoType,
LPOBJECT lpTargetObject)
{
LPOBJECT lpObject, lpBase;
int retc;
BOOL fDiscardUndo = NO;
BOOL fUndoFailed;
BOOL fMaskEdit;
EDIT_TARGET OldTarget;
lpBase = GetBase();
// the InitUndoType flag is kept separately from the
// DataUndoType and AlphaUndoType so that if the initialization
// of the undo fails we still know what was edited when
// EditedObject and EditedObjectFrame are called
lpObject = NULL;
while (lpObject = GetNextObject(lpObject, YES, NO))
lpObject->InitUndoType = 0;
// No mask undo's are allowed - so apply any that we have now
if (!Control.UndoMasks)
ObjEditApply(lpBase, NO, YES, NO);
// No undo's are allowed - so apply any that we have now
if (Control.NoUndo || fDisableUndos)
{
lpObject = NULL;
while (lpObject = GetNextObject(lpObject, YES, NO))
ObjEditApply(lpObject, YES, lpObject != lpBase, NO);
}
// if we have don't have multiple objects, strip off the delete objects flag
if (!Control.MultipleObjects)
UndoType &= ~UT_DELETEOBJECTS;
// find out whether we are in mask edit mode
fMaskEdit = (Target == ET_OBJECT) && (lpTargetObject == lpBase) &&
((UndoType & UT_ALPHAUNDO) != 0);
// see if any objects cannot have their undos freed without
// asking the user first, if so ask the user and get the response
// This is only a manual apply thing
if (UndoType & (UT_NEWDATA|UT_NEWALPHA) && Control.UseApply)
{
lpObject = NULL;
fDiscardUndo = YES;
while (lpObject = GetNextObject(lpObject, YES, NO))
{
// see if this is an object we are not editing
if ((Target == ET_SELOBJECTS &&
!IsSelectedObject(lpObject)) ||
(Target == ET_OBJECT && lpObject != lpTargetObject))
continue;
if (!ObjEditUndoDiscardable(lpObject, (UndoType & UT_NEWDATA) != 0,
(UndoType & UT_NEWALPHA) != 0))
{
if (lpCmdList->fPlayback)
{
fDiscardUndo = fDiscardUndo;
}
else
{
DISCARDUNDO_PARMS parms;
retc = AstralConfirm( IDS_OKTOAPPLY );
if (retc == IDCANCEL)
return(FALSE);
fDiscardUndo = retc == IDYES;
parms.fDiscardUndo = fDiscardUndo;
PostCommand(lpCmdList, IDS_CMD_DISCARDUNDO, &parms);
}
break;
}
}
}
OldTarget = EditTarget;
EditTarget = Target;
// now loop through the objects initializing their undos
lpObject = NULL;
while (lpObject = GetNextObject(lpObject, YES, NO))
{
// if our last edit involved editing all objects then
// make sure we apply for all objects
if (OldTarget == ET_ALLOBJECTS)
{
ObjEditApply(lpObject, !fMaskEdit,
(lpObject != lpBase) && !fMaskEdit, NO);
}
// see if this is an object we are not editing
if ((Target == ET_SELOBJECTS && !IsSelectedObject(lpObject)) ||
(Target == ET_OBJECT && lpObject != lpTargetObject))
{
// if no individual undo's, wack any undo buffers
// if in auto apply or in manual apply and state is redo
// Objects that are not the base need to also have
// their alphas wacked if this is not a mask edit
if (!Control.UndoObjects && (!Control.UseApply ||
( Control.UseApply && !lpObject->DataUndoNotRedo ) ) )
ObjEditApply(lpObject, !fMaskEdit,
(lpObject != lpBase) && !fMaskEdit, NO);
continue;
}
// Discard it's undo if possible
if (fDiscardUndo)
ObjEditFreeUndo(lpObject, (UndoType & UT_NEWDATA) != 0,
(UndoType & UT_NEWALPHA) != 0);
// save state of undo failed flag
fUndoFailed = lpObject->fUndoFailed;
// Initialize the undo for this object
if (!ObjEditInit(lpObject, UndoType))
{
// Undo initialization failed, so apply all objects that
// were going to be initialized
lpObject = NULL;
while (lpObject = GetNextObject(lpObject, YES, NO))
{
// see if this is an object we are not editing
if ((Target == ET_SELOBJECTS &&
!IsSelectedObject(lpObject)) ||
(Target == ET_OBJECT && lpObject != lpTargetObject))
{
continue;
}
lpObject->fUndoFailed = YES;
lpObject->InitUndoType = 0;
if (lpObject == lpBase)
ObjEditApply(lpObject,
(UndoType & UT_DATAUNDO) != 0,
(UndoType & UT_ALPHAUNDO) != 0, NO);
else
ObjEditApply(lpObject, YES, YES, NO);
}
// if we have failed before
if (fUndoFailed)
return(TRUE);
else
{
Message(IDS_NOUNDO);
return(FALSE);
}
}
lpObject->fUndoFailed = NO;
lpObject->InitUndoType = UndoType;
}
return( TRUE );
}
void CImage::EditUndo( BOOL fEditUndo, BOOL fMaskUndo,
LPUPDATE_TYPE lpUpdateType, LPRECT lpUpdateRect)
{
RECT rUndo, rUndoMask, rTemp;
LPOBJECT lpBase, lpObject, lpNext;
BOOL fNewSize, fSetupMiniViews, fRemoveMarquee, fUndoDelete, fColorMapChanged;
BOOL fUndoAlpha, fUndoData;
int nDeleted;
LPMASK lpMask;
EDIT_TARGET Target;
AstralSetRectEmpty(lpUpdateRect);
// Initialize things for updating the display
fNewSize = fSetupMiniViews = fUndoDelete = fColorMapChanged = NO;
AstralSetRectEmpty(&rUndo);
AstralSetRectEmpty(&rUndoMask);
// loop through objects doing undo
lpBase = GetBase();
lpObject = NULL;
// get the target of the last edit
Target = EditTarget;
while (lpObject = GetNextObject(lpObject, NO, NO, fEditUndo))
{
// See if this is an object we are undoing
if (fEditUndo)
{
// check for special undo processing of a deleted object
if (lpObject->fDeleted)
continue; // do no undo processing for a deleted object
// {
// if (Control.UndoObjects && !IsSelectedObject(lpBase))
// continue;
// }
else
// if target is not the entire image and we are in undo
// object mode and the object is not selected then
// skip this object
if (Target != ET_ALLOBJECTS && Control.UndoObjects && !IsSelectedObject(lpObject))
continue;
}
// Only handle mask undo for the base object
if (fMaskUndo)
{
if (lpObject != lpBase || lpObject->fBothDirty ||
!lpObject->AlphaDirty)
continue;
}
fUndoData = fUndoAlpha = NO;
// Do preprocess for doing a data undo
if (fEditUndo)
{
if (lpObject->DataDirty)
fUndoData = YES;
// See if we need to undo the alpha for this object
if ((lpObject != lpBase) && lpObject->lpAlpha && lpObject->AlphaDirty)
fUndoAlpha = YES;
if (!fUndoData && !fUndoAlpha)
continue;
// check to see and undoing/redoing deleted objects will change
// the select state, if so undraw the object marquee
if (lpObject == lpBase &&
lpObject->DataUndoType & UT_DELETEOBJECTS)
{
fUndoDelete = YES;
fRemoveMarquee = NO;
nDeleted = 0;
lpNext = lpObject;
while (lpNext = GetNextObject(lpNext, YES, NO, YES))
{
if (lpNext->fUndoDeleted)
++nDeleted;
else
if (lpNext->fDeleted && lpNext->fSelected)
{
fRemoveMarquee = YES;
break;
}
}
if (GetSelObject(NULL) == lpBase && !fRemoveMarquee)
{
if (CountObjects() - nDeleted <= 1)
fRemoveMarquee = YES;
}
if (fRemoveMarquee)
{
GetObjectMarqueeRect(this, &rTemp);
AstralUnionRect(lpUpdateRect, lpUpdateRect, &rTemp);
}
}
}
else // fMaskUndo
if (!lpObject->AlphaDirty)
continue;
else
fUndoAlpha = YES;
// do a preprocess for undoing the mask caused either by
// a mask undo or by an edit function that also edits the mask
if (((lpObject == lpBase) && fEditUndo && lpObject->fBothDirty) ||
fMaskUndo)
{
if ( lpObject->AlphaUndoType & (UT_CREATEMASK|UT_DELETEMASK) )
{
// if the undo is going to delete the mask,
// we need to undraw the mask
if (GetMask())
{
GetMaskMarqueeRect(this, &rTemp);
AstralUnionRect(lpUpdateRect, lpUpdateRect, &rTemp);
if (GetMaskUpdateRect(YES, NO, &rTemp))
AstralUnionRect(&rUndoMask, &rUndoMask, &rTemp);
}
// if the undo is going to create the mask,
// we need to undraw the object marquees if
// not in mask and object marquee mode
else
{
if (!Control.UseMaskAndObjects)
{
GetObjectMarqueeRect(this, &rTemp);
AstralUnionRect(lpUpdateRect, lpUpdateRect, &rTemp);
}
}
}
}
// Actually do the undo
ObjEditUndo(lpObject, fUndoData, fUndoAlpha);
// do a postprocess for undoing the mask
if ((lpMask = GetMask()) &&
(((lpObject == lpBase) && fEditUndo && lpObject->fBothDirty) ||
fMaskUndo))
{
// if the undo is going to add the mask, we need to redraw the mask
if (lpObject->AlphaUndoType & (UT_CREATEMASK|UT_DELETEMASK) )
{
if (GetMaskUpdateRect(YES, NO, &rTemp))
AstralUnionRect(&rUndoMask, &rUndoMask, &rTemp);
}
else
// just redraw the undo area for the mask
AstralUnionRect(&rUndoMask, &rUndoMask, &lpMask->Pixmap.UndoRect);
}
// Setup rectangle for undoing deletion of objects
// Handled specially so that moved objects will still undo
// and redo properly
if (fEditUndo)
{
if (lpObject == lpBase &&
lpObject->DataUndoType & UT_DELETEOBJECTS)
{
lpNext = lpObject;
while (lpNext = GetNextObject(lpNext, YES, NO, YES))
{
if (lpNext->fDeleted || lpNext->fUndoDeleted)
AstralUnionRect(&rUndo, &rUndo, &lpNext->rObject);
}
fSetupMiniViews = YES;
}
if (lpObject->DataUndoType & UT_COLORMAP)
fColorMapChanged = YES;
if (lpObject->Pixmap.fNewFrame)
{
/* if new frame, cause window to be redisplayed */
if (lpObject == lpBase)
fNewSize = YES;
else
{
if (!fNewSize)
{
AstralUnionRect(&rUndo, &rUndo, &lpObject->rObject);
AstralUnionRect(&rUndo, &rUndo, &lpObject->rUndoObject);
}
}
}
else
{
AstralSetRectEmpty(&rTemp);
if (fUndoData)
AstralUnionRect(&rTemp, &rTemp, &lpObject->Pixmap.UndoRect);
if (fUndoAlpha)
AstralUnionRect(&rTemp, &rTemp,
&lpObject->lpAlpha->Pixmap.UndoRect);
if (rTemp.right >= rTemp.left)
{
if (!fNewSize)
{
OffsetRect(&rTemp, lpObject->rObject.left,
lpObject->rObject.top);
AstralUnionRect(&rUndo, &rUndo, &rTemp);
}
}
if( lpObject->DataUndoType & UT_OBJECTRECT )
{
AstralUnionRect( &rUndo, &rUndo, &lpObject->rObject );
AstralUnionRect( &rUndo, &rUndo, &lpObject->rUndoObject );
}
}
}
}
// now redisplay whatever changes are necessary for the undo
if (fColorMapChanged)
{
ImgColorMapChanged(this);
*lpUpdateType |= UT_DATATYPE;
}
if (fNewSize)
{
*lpUpdateType |= UT_DATATYPE;
if (lpBase->Pixmap.UndoFrame)
{
if ((FrameXSize(lpBase->Pixmap.UndoFrame) ==
FrameXSize(lpBase->Pixmap.EditFrame)) &&
(FrameYSize(lpBase->Pixmap.UndoFrame) ==
FrameYSize(lpBase->Pixmap.EditFrame)))
fNewSize = NO;
}
if (fNewSize)
*lpUpdateType |= UT_SIZE;
else
{
int dx, dy;
GetInfo(&dx, &dy, NULL, NULL);
SetRect(lpUpdateRect, 0, 0, dx-1, dy-1);
}
}
else
{
if (!AstralIsRectEmpty(lpUpdateRect))
*lpUpdateType |= UT_ACTIVEAREA;
if (rUndoMask.right >= rUndoMask.left)
{
*lpUpdateType |= UT_ACTIVEAREA;
AstralUnionRect(lpUpdateRect, lpUpdateRect, &rUndoMask);
}
if (rUndo.right >= rUndo.left)
{
*lpUpdateType |= UT_AREA;
AstralUnionRect(lpUpdateRect, lpUpdateRect, &rUndo);
}
}
}
BOOL CImage::SelectObjects(LPOBJECT lpStartObject, LPRECT lpRect,
BOOL fSelect, BOOL fBottomUp, BOOL fExcludeBase)
{
BOOL fHaveRect, fSelected;
BOOL fLoop;
LPOBJECT lpObject, lpBase;
if (lpRect)
fHaveRect = lpRect->left < lpRect->right;
fLoop = lpStartObject != NULL;
lpObject = lpStartObject;
fSelected = FALSE;
lpBase = GetBase();
while (lpObject = GetNextObject(lpObject, fBottomUp, fLoop))
{
if (!fExcludeBase || lpObject != lpBase)
{
if (!lpRect)
{
if (fSelect != lpObject->fSelected)
{
ObjSelectObject((LPPRIMOBJECT)lpObject, fSelect);
fSelected = TRUE;
}
}
else if (fHaveRect)
{
if (lpObject->rObject.left >= lpRect->left &&
lpObject->rObject.right <= lpRect->right &&
lpObject->rObject.top >= lpRect->top &&
lpObject->rObject.bottom <= lpRect->bottom)
{
if (fSelect != lpObject->fSelected)
{
ObjSelectObject((LPPRIMOBJECT)lpObject, fSelect);
fSelected = TRUE;
}
}
}
else
{
if (AstralPtInRect(&lpObject->rObject, *((LPPOINT)lpRect)))
{
if (lpObject == lpBase || !lpObject->lpAlpha ||
IsMasked(lpObject->lpAlpha,
lpRect->left-lpObject->rObject.left,
lpRect->top-lpObject->rObject.top))
{
if (fSelect != lpObject->fSelected)
{
ObjSelectObject((LPPRIMOBJECT)lpObject, fSelect);
fSelected = TRUE;
}
break;
}
}
}
}
if (lpObject == lpStartObject)
break;
}
return(fSelected);
}
void CImage::AdjustLayerSelObj(BOOL fToTop, BOOL fOneLevel)
{
LPOBJECT lpObject, lpFirstObject, lpNext, lpBase, lpLinkObject;
lpBase = GetBase();
if (fToTop)
lpObject = GetNextObject(lpBase, YES, NO);
else
lpObject = GetNextObject(NULL, NO, NO);
if (fOneLevel)
{
while (lpObject && lpObject != lpBase)
{
// find first selected object
if (!lpObject->fSelected)
{
lpObject = GetNextObject(lpObject, fToTop, NO);
continue;
}
// got a selected object, now find next unselected object to link after
lpLinkObject = GetNextObject(lpObject, fToTop, NO);
while (lpLinkObject && lpLinkObject->fSelected)
lpLinkObject = GetNextObject(lpLinkObject, fToTop, NO);
// if no unselected objects to link before or after, nothing to do
if (!lpLinkObject)
break;
// can't move objects below base
if (lpLinkObject == lpBase && !fToTop)
break;
// now move all consecutive selected objects up/down one level
while (lpObject && lpObject->fSelected)
{
lpNext = GetNextObject(lpObject, fToTop, NO);
ObjUnlinkObject(&ObjList, (LPPRIMOBJECT)lpObject);
ObjLinkObject(&ObjList, (LPPRIMOBJECT)lpLinkObject,
(LPPRIMOBJECT)lpObject, fToTop);
lpLinkObject = lpObject;
lpObject = lpNext;
}
lpObject = GetNextObject(lpLinkObject, fToTop, NO);
}
}
else
{
// find first selected object
while (lpObject)
{
if (lpObject->fSelected)
break;
lpObject = GetNextObject(lpObject, fToTop, NO);
}
lpFirstObject = lpObject;
while (lpObject)
{
lpNext = GetNextObject(lpObject, fToTop, NO);
if (lpObject->fSelected && (lpObject != lpBase))
{
ObjUnlinkObject(&ObjList, (LPPRIMOBJECT)lpObject);
if (fToTop)
ObjLinkObject(&ObjList,
(LPPRIMOBJECT)ObjList.lpTail,
(LPPRIMOBJECT)lpObject, YES);
else
ObjLinkObject(&ObjList,
(LPPRIMOBJECT)ObjList.lpHead,
(LPPRIMOBJECT)lpObject, YES);
}
lpObject = lpNext;
if (lpObject == lpFirstObject)
break;
}
}
}
BOOL CImage::CombineObjects(BOOL fNoUndo, BOOL fCreateMask,
BOOL fForceIt, ITEMID idDirty, LPRECT lpUpdateRect)
{
LPOBJECT lpBase, lpObject;
int iWidth, iHeight, depth, y, iImageWidth, iImageHeight;
LPTR lpDataBuf, lpMaskPtr;
RECT rFloaters, rMask, rTemp;
BOOL fNewMask;
LPMASK lpMask;
UNDO_TYPE UndoType;
AstralSetRectEmpty(lpUpdateRect);
// get rectangle for all floating objects
if (!GetFloatingObjectsRect(&rFloaters))
return(FALSE);
// Get base object
lpBase = GetBase();
// get pixmap information
PixmapGetInfo(&lpBase->Pixmap, PMT_EDIT, &iImageWidth, &iImageHeight, &depth, NULL);
BoundRect(&rFloaters, 0, 0, iImageWidth-1, iImageHeight-1);
iWidth = RectWidth(&rFloaters);
iHeight = RectHeight(&rFloaters);
// allocate buffer for alpha channel combining
if (!(lpDataBuf = Alloc((long)iWidth*depth)))
{
Message(IDS_EMEMALLOC);
return(FALSE);
}
lpMask = NULL;
if (fCreateMask)
{
lpMask = GetMaskEx(OFF, Control.NoUndo, &fNewMask, &rTemp);
AstralUnionRect(lpUpdateRect, lpUpdateRect, &rTemp);
}
// do it to it
ProgressBegin(lpMask != NULL ? 2 : 1, idDirty-IDS_UNDOFIRST+IDS_PROGFIRST);
if (!fNoUndo)
{
UndoType = UT_DATA|UT_DELETEOBJECTS;
if (lpMask)
{
if (fNewMask)
UndoType |= UT_CREATEMASK;
else
UndoType |= UT_ALPHA;
}
if (!ImgEditInit(this, ET_OBJECT, UndoType, lpBase))
{
if (!fForceIt)
{
ProgressEnd();
FreeUp(lpDataBuf);
return(FALSE);
}
}
}
// do it to it
ProgressBegin(1, 0);
for (y = rFloaters.top; y <= rFloaters.bottom; ++y)
{
AstralClockCursor(y-rFloaters.top, iHeight, NO);
ImgGetLine(this, NULL, rFloaters.left, y, iWidth, lpDataBuf);
PixmapWrite(&lpBase->Pixmap, PMT_EDIT, rFloaters.left, y, iWidth,
lpDataBuf, iWidth);
}
ProgressEnd();
if (lpMask && (lpObject = GetNextObject(lpBase, YES, NO)))
{
ProgressBegin(1, 0);
for (y = rFloaters.top; y <= rFloaters.bottom; ++y)
{
AstralClockCursor(y-rFloaters.top, iHeight, NO);
lpMaskPtr = PixmapPtr(&lpMask->Pixmap, PMT_EDIT, rFloaters.left,
y, YES);
if (!lpMaskPtr)
continue;
ImgMaskLoad(this, lpObject, NULL,
rFloaters.left, y, iWidth, lpDataBuf, NO,
CR_OR, 0, 0);
CombineData(lpDataBuf, lpMaskPtr, iWidth, NO, CR_OR);
}
MaskRectUpdate(lpMask, &rMask);
ProgressEnd();
}
FreeUp(lpDataBuf);
GetObjectMarqueeRect(this, &rTemp);
AstralUnionRect(lpUpdateRect, lpUpdateRect, &rTemp);
lpObject = lpBase;
while (lpObject = GetNextObject(lpObject, YES, NO))
{
// always let undo stuff initialize this
// lpObject->fUndoDeleted = NO;
lpObject->fDeleted = YES;
}
//DeleteObjects((LPOBJECT)lpBase->lpNext, NO);
if (!fNoUndo)
ImgEditedObject(this, lpBase, idDirty, &rFloaters);
else
fChanged = YES;
//if ( Tool.hRibbon )
// SendMessage( Tool.hRibbon, WM_CONTROLENABLE, 0, 0L );
ProgressEnd();
//SetupMiniViews(NULL, NO);
return(TRUE);
}
// set external load to zero in both directions
MatPtLoadBC *MatPtLoadBC::ZeroMPLoad(void)
{
ZeroVector(mpm[ptNum-1]->GetPFext());
return (MatPtLoadBC *)GetNextObject();
}
// increment external load on a particle
// input is analysis time in seconds
// (only called when diffusion is active)
MatPtFluxBC *MatPtFluxBC::AddMPFlux(double bctime)
{
// condition value is g/(mm^2-sec), Divide by rho*csat to get potential flux in mm/sec
// find this flux and then add (times area) to get mm^3-potential/sec
MPMBase *mpmptr = mpm[ptNum-1];
MaterialBase *matptr = theMaterials[mpmptr->MatID()];
// Flux is a scalar and we need int_(face) F Ni(x) dA
// Since F is constant, only need integral which is done by CPDI methods
// which has be generalized to work for GIMP too
// We use X_DIRECTION for bcDIR for efficiency. For Silent BC, change to
// Normal direction to all caculation of n
Vector fluxMag;
ZeroVector(&fluxMag);
int bcDir=X_DIRECTION;
if(style==SILENT)
{ TransportProperties t;
matptr->GetTransportProps(mpmptr,fmobj->np,&t);
Tensor *D = &(t.diffusionTensor);
// D in mm^2/sec, Dc in 1/mm
if(fmobj->IsThreeD())
{ fluxMag.x = D->xx*mpmptr->pDiffusion[gGRADx] + D->xy*mpmptr->pDiffusion[gGRADy] + D->xz*mpmptr->pDiffusion[gGRADz];
fluxMag.y = D->xy*mpmptr->pDiffusion[gGRADx] + D->yy*mpmptr->pDiffusion[gGRADy] + D->yz*mpmptr->pDiffusion[gGRADz];
fluxMag.z = D->xz*mpmptr->pDiffusion[gGRADx] + D->yz*mpmptr->pDiffusion[gGRADy] + D->zz*mpmptr->pDiffusion[gGRADz];
}
else
{ fluxMag.x = D->xx*mpmptr->pDiffusion[gGRADx] + D->xy*mpmptr->pDiffusion[gGRADy];
fluxMag.y = D->xy*mpmptr->pDiffusion[gGRADx] + D->yy*mpmptr->pDiffusion[gGRADy];
}
bcDir = N_DIRECTION;
}
else if(direction==EXTERNAL_FLUX)
{ // csatrho = rho0 V0 csat/V (units g/mm^3)
double csatrho = mpmptr->GetRho()*mpmptr->GetConcSaturation()/mpmptr->GetRelativeVolume();
fluxMag.x = BCValue(bctime)/csatrho;
}
else
{ // coupled surface flux and ftime is bath concentration
// time variable (t) is replaced by c-cbath, where c is the particle potential and cbath is bath potential
varTime = mpmptr->pPreviousConcentration-GetBCFirstTime();
GetPosition(&varXValue,&varYValue,&varZValue,&varRotValue);
double currentValue = fabs(scale*function->Val());
if(varTime>0.) currentValue=-currentValue;
// csatrho = rho0 V0 csat/V (units g/mm^3)
double csatrho = mpmptr->GetRho()*mpmptr->GetConcSaturation()/mpmptr->GetRelativeVolume();
fluxMag.x = currentValue/csatrho;
}
// get corners and direction from material point
int cElem[4],numDnds;
Vector corners[4],tscaled;
double ratio = mpmptr->GetTractionInfo(face,bcDir,cElem,corners,&tscaled,&numDnds);
// compact CPDI nodes into list of nodes (nds) and final shape function term (fn)
// May need up to 8 (in 3D) for each of the numDnds (2 in 2D or 4 in 3D)
int nds[8*numDnds+1];
double fn[8*numDnds+1];
int numnds = CompactCornerNodes(numDnds,corners,cElem,ratio,nds,fn);
// add force to each node
int i;
for(i=1;i<=numnds;i++)
diffusion->AddFluxCondition(nd[nds[i]],DotVectors(&fluxMag,&tscaled)*fn[i],false);
return (MatPtFluxBC *)GetNextObject();
}
