Forum Message

We have moved the forum to https://forum.ngsolve.org . This is an archived version of the topics until 05/05/23. All the topics were moved to the new forum and conversations can be continued there. This forum is just kept as legacy to not invalidate old links. If you want to continue a conversation just look for the topic in the new forum.

Notice

The forum is in read only mode.

SymbolicBFI definedonelements = all elements that are needed for FreeDofs?

creativeworker
Topic Author
Offline
Senior Member

3 years 1 week ago - 3 years 1 week ago #3725 by creativeworker

SymbolicBFI definedonelements = all elements that are needed for FreeDofs? was created by creativeworker

Hello,

I have a fes for the whole system. Using the definedon='regexpr' key the system is substructured into parts and stored to different fes_parts. Using the Compress method, I can use everything nice and clean for the different substructures.
To do the AssembleLinearization only on the elements in the substructure, I have a very large code-block to find all elements that have any dof in the substructure. Then translating the element-numbers into a BitArray that is then applied to the SymbolicBFI(..., definedonelements=BitArray).
Is there any shortcut available to find all elements related to the FreeDofs of such a fes_part automatically?

Also I didn't understand the difference in the following example (dealing with exactly that):

Code:

    fes_in = object.fespace(definedon=object.nonlinear_domain)
    
    fesMini = Compress(fes_in)
    u, v = fesMini.TnT()
    
    print('---> Mini FE-Space', fesMini.ndof)
    
    el_iterator = fesMini.Elements()

    master_el_nrs = []
    for el in el_iterator:
        master_el_nrs.append(el.nr)
        el_id = ElementId(VOL, el.nr)
        
    act_el = BitArray(object.mesh.ne)
    act_el[:] = False
    
    for i in master_el_nrs:
        act_el[i] = True
    
    print('active elements...........', sum(act_el))
    
    #-------------------------------------------------------------------------   
   
    InternalMask = fes_in.FreeDofs()
    wii = np.where(InternalMask)
    ix_ii = np.ix_(wii[0],wii[0])
    
    aMini = BilinearForm(fesMini)
    aMini += SymbolicBFI(object.fcn_weak_K(object, material, u,v), definedonelements=act_el )
    aMini.Assemble()
    KiiMini = ngsolve2spmat_mat(aMini.mat)
    #Ergebnis: Immer zu klein, mit und ohne definedonelements
    
    fesfull = object.fespace()
    ufull,vfull = fesfull.TnT()
    aTest = BilinearForm(fesfull)
    aTest +=SymbolicBFI(object.fcn_weak_K(object, material, ufull,vfull), definedonelements=act_el )
    aTest.Assemble()
    ATest = ngsolve2spmat_mat(aTest.mat)
    KiiTest = ATest[ix_ii]
    #Ergebnis: mit definedonelements ist das Ergebnis zu klein, ohne passt es. 
    #Die Anzahl der dofs sind immer gleich...

Kind regards,

Last edit: 3 years 1 week ago by creativeworker. Reason: Extension of the question with code

creativeworker
Topic Author
Offline
Senior Member

2 years 11 months ago - 2 years 11 months ago #3773 by creativeworker

Replied by creativeworker on topic SymbolicBFI definedonelements = all elements that are needed for FreeDofs?

Just wanted to give an update how I solved it meanwhile for me. Certainly not the most elegant way, but functional and not too slow:

Code:

def createInnerModel(object):
    # get finite element space
    fes = object.fespace()
    fes_in = Compress(object.fespace(definedon=inner_domain))
   
    # Suche alle dofs, die mit den inneren Elementen verknüpft sind
    mastervertices = []
    el_iterator = fes_in.Elements()  
    for el in el_iterator:
        el_id = ElementId(VOL, el.nr)
        mastervertices.extend(fes.GetDofNrs(el_id))

    dofs = BitArray(fes.ndof)
    dofs[:] = False
    for i in mastervertices:
        dofs[i] = True
    
    fesMini = Compress(fes, active_dofs=dofs)
    print('---> Mini FE-Space', fesMini.ndof)
    
    # Search for all elements that are related to that dofs
    master_el_nrs = []
    for el in fes.Elements(VOL):
        is_master = False
        el_id = ElementId(VOL, el.nr)
        eldofs = fes.GetDofNrs(el_id)
        for eldof in eldofs:
            is_master |= eldof in mastervertices
        if is_master:
            master_el_nrs.append(el.nr)

    E_tilde = np.unique(master_el_nrs)

    act_el = BitArray(object.mesh.ne)
    act_el[:] = False
    
    for i in E_tilde:
        act_el[i] = True    

    print('active elements...........', sum(act_el))
    
    return fesMini, act_el

Last edit: 2 years 11 months ago by creativeworker.

Time to create page: 0.102 seconds

Login

NGSolve on Twitter