การคำนวณโครงสร้าง sparsity สำหรับเมทริกซ์องค์ประกอบ จำกัด

คำถาม: มีวิธีการใดในการคำนวณโครงสร้าง sparsity ของเมทริกซ์ไฟท์องค์ประกอบที่แม่นยำและมีประสิทธิภาพ

ข้อมูล: ฉันกำลังทำงานกับตัวแก้สมการความดัน Poisson โดยใช้วิธีของ Galerkin ที่มีพื้นฐานกำลังสองของลากรองจ์เขียนใน C และใช้ PETSc สำหรับการจัดเก็บเมทริกซ์แบบกระจัดกระจายและกิจวัตร KSP ในการใช้ PETSc อย่างมีประสิทธิภาพฉันจำเป็นต้องจัดสรรหน่วยความจำล่วงหน้าสำหรับเมทริกซ์ความแข็งระดับโลก

ขณะนี้ฉันกำลังประกอบ mock เพื่อประเมินจำนวนที่ไม่ใช่ศูนย์ต่อแถวดังต่อไปนี้ (pseudocode)

int nnz[global_dim]
for E=1 to NUM_ELTS
  for i=1 to 6
    gi = global index of i 
    if node gi is free
      for j=1 to 6
        gj = global index of j
        if node gj is free 
          nnz[i]++

อย่างไรก็ตามสิ่งนี้จะประเมินค่า nnz มากเกินไปเนื่องจากการโต้ตอบของโหนด - โหนดบางอย่างสามารถเกิดขึ้นได้ในหลายองค์ประกอบ

ฉันได้พิจารณาแล้วว่าพยายามติดตามว่าฉันพบการโต้ตอบใดบ้าง แต่ฉันไม่แน่ใจว่าจะทำอย่างไรโดยไม่ต้องใช้หน่วยความจำมาก ฉันยังสามารถวนซ้ำโหนดและค้นหาการสนับสนุนของฟังก์ชันพื้นฐานที่อยู่ตรงกลางโหนดนั้น แต่จากนั้นฉันต้องค้นหาองค์ประกอบทั้งหมดสำหรับแต่ละโหนดซึ่งดูเหมือนไม่มีประสิทธิภาพ

ฉันพบคำถามล่าสุดนี้ซึ่งมีข้อมูลที่เป็นประโยชน์โดยเฉพาะจาก Stefano M ผู้เขียน

คำแนะนำของฉันคือการนำไปใช้ใน python หรือ C โดยใช้แนวคิดเชิงทฤษฎีของกราฟบางอย่างเช่นพิจารณาองค์ประกอบในเมทริกซ์เป็นขอบในกราฟและคำนวณโครงสร้างการกระจายของเมทริกซ์ adjacency รายการของรายการหรือพจนานุกรมของคีย์เป็นตัวเลือกทั่วไป

ฉันกำลังมองหารายละเอียดเพิ่มเติมและแหล่งข้อมูลเกี่ยวกับเรื่องนี้ ฉันยอมรับว่าไม่รู้ทฤษฎีกราฟมากและฉันไม่คุ้นเคยกับเทคนิค CS ทั้งหมดที่อาจมีประโยชน์ (ฉันกำลังเข้าใกล้สิ่งนี้จากด้านคณิตศาสตร์)

ขอบคุณ!

ความคิดของคุณในการติดตามว่า i, j การโต้ตอบที่คุณพบสามารถทำงานได้ฉันคิดว่านั่นเป็น "เคล็ดลับ CS" ที่คุณและสเตฟาโนเอ็มอ้างถึง จำนวนนี้สร้างเมทริกซ์เบาบางในรายชื่อของรูปแบบรายการ

ไม่แน่ใจว่าคุณมี CS มากเพียงใดฉันจึงต้องขออภัยถ้าสิ่งนี้เป็นที่รู้จักของคุณอยู่แล้ว: ในโครงสร้างข้อมูลรายการที่เชื่อมโยงทุกรายการจะเก็บตัวชี้ไปยังรายการหลังจากนั้นและรายการก่อนหน้า มีราคาถูกที่จะเพิ่มและลบรายการจาก แต่ไม่ใช่เรื่องง่ายที่จะหารายการในนั้น - คุณอาจต้องดูทั้งหมด

ดังนั้นสำหรับแต่ละโหนด i คุณเก็บรายการเชื่อมโยง จากนั้นคุณวนซ้ำองค์ประกอบทั้งหมด; หากคุณพบว่าทั้งสองโหนดเชื่อมต่อกันฉันและเจคุณไปดูในรายการเชื่อมโยงของฉัน หาก j ยังไม่มีอยู่ให้คุณเพิ่มลงในรายการและเพิ่มเช่นกันในรายการของ j เป็นวิธีที่ง่ายที่สุดถ้าคุณเพิ่มลงไปตามลำดับ

เมื่อคุณเติมรายการของรายการตอนนี้คุณจะรู้จำนวนรายการที่ไม่เป็นศูนย์ในแต่ละแถวของเมทริกซ์นั่นคือความยาวของรายการโหนดนั้น ข้อมูลนี้เป็นสิ่งที่คุณต้องการจัดสรรเมทริกซ์กระจัดกระจายในโครงสร้างข้อมูลเมทริกซ์ของ PETSc จากนั้นคุณสามารถเพิ่มรายการของคุณให้เป็นอิสระเพราะคุณไม่ต้องการมันอีกต่อไป

อย่างไรก็ตามวิธีการนี้จะถือว่าคุณมีรายการโหนดที่แต่ละองค์ประกอบมี

แพคเกจการสร้างตาข่ายบางตัว - ตัวอย่างเช่นสามเหลี่ยม - สามารถส่งออกไม่เพียง แต่รายการองค์ประกอบและโหนดใดที่มีอยู่ แต่ยังแสดงรายการของทุก ๆ ขอบในการคำนวณของคุณ ในกรณีดังกล่าวคุณจะไม่มีความเสี่ยงในการประเมินจำนวนรายการที่ไม่เป็นศูนย์มากเกินไป: สำหรับองค์ประกอบเชิงเส้นทีละชิ้นแต่ละขอบจะให้รายการเมทริกซ์ความแข็ง 2 รายการ คุณกำลังใช้กำลังสองทีละชิ้นดังนั้นแต่ละรอบจะนับเป็น 4 รายการ แต่คุณได้รับแนวคิด ในกรณีดังกล่าวคุณสามารถค้นหาจำนวนรายการที่ไม่เป็นศูนย์ต่อแถวโดยผ่านหนึ่งรายการผ่านรายการขอบโดยใช้อาร์เรย์สามัญ

ด้วยวิธีการนี้คุณต้องอ่านไฟล์ขนาดใหญ่พิเศษจากฮาร์ดดิสก์ซึ่งอาจช้ากว่าการใช้รายการองค์ประกอบหากการคำนวณจริงของคุณไม่ใหญ่ อย่างไรก็ตามฉันคิดว่ามันง่ายกว่า

หากคุณระบุ mesh ของคุณเป็น DMPlex และเค้าโครงข้อมูลของคุณเป็น PetscSection แล้ว DMCreateMatrix () จะให้เมทริกซ์ที่จัดสรรล่วงหน้าอย่างถูกต้องโดยอัตโนมัติ นี่คือตัวอย่าง PETSc สำหรับเป็นPoisson ปัญหาและStokes ปัญหา

upvoted

ฉันเองไม่รู้วิธีการทำเช่นนี้ราคาถูกดังนั้นฉันก็ประเมินค่าสูงกว่าจำนวนเช่นใช้ค่าที่มีขนาดใหญ่พอสมควรสำหรับทุกแถว

ตัวอย่างเช่นสำหรับตาข่ายที่มีโครงสร้างที่สมบูรณ์แบบที่ทำจากองค์ประกอบ hex แบบเส้นตรง 8 จุด nnzs ต่อแถวในบล็อกเส้นทแยงมุมและบล็อกแนวทแยงทั้งสองมีค่า dof * 27 สำหรับเลขฐานสิบหกที่สร้างขึ้นโดยอัตโนมัติที่ไม่มีโครงสร้างมากที่สุดจำนวนที่น้อยกว่า dof * 54 สำหรับ tets เชิงเส้นฉันไม่จำเป็นต้องไปไกลเกินกว่า dof * 30 สำหรับตาข่ายที่มีองค์ประกอบอัตราส่วนรูปร่าง / ต่ำมากคุณอาจต้องใช้ค่าที่ใหญ่กว่าเล็กน้อย

โทษคือการใช้หน่วยความจำภายใน (อยู่ในอันดับ) อยู่ระหว่าง 2x-5x ดังนั้นคุณอาจต้องใช้โหนดการคำนวณเพิ่มเติมในคลัสเตอร์ของคุณมากกว่าปกติ

Btw ฉันลองใช้รายการที่ค้นหาได้ แต่เวลาที่ใช้ในการพิจารณาโครงสร้างความกระจัดกระจายเป็นมากกว่าการประกอบ / การแก้ปัญหา แต่การนำไปใช้ของฉันนั้นง่ายมากและไม่ได้ใช้ข้อมูลเกี่ยวกับขอบ

ตัวเลือกอื่น ๆ คือการใช้การปฏิบัติเช่น DMMeshCreateExodus ดังแสดงในนี้ตัวอย่างเช่น

คุณกำลังมองหาการเชื่อมต่อที่ไม่ซ้ำกันทั้งหมด (gi, gj) ซึ่งแนะนำให้พวกเขาทั้งหมดลงในภาชนะที่เชื่อมโยง (ไม่ทำซ้ำ) แล้วนับความสำคัญของมัน - ใน C ++ นี่จะเป็น std :: set <std :: pair <int, int>> ใน pseudocode ของคุณคุณต้องแทนที่ "nnz [i] ++" ด้วย "s.insert [pair (gi, gj)]" "จากนั้นจำนวนสุดท้ายของไม่ใช่ศูนย์คือ s.size () มันควรทำงานในเวลา O (n-log-n) โดยที่ n คือจำนวนที่ไม่ใช่ศูนย์

เนื่องจากคุณอาจทราบช่วงของ gi ที่เป็นไปได้คุณสามารถ "splay" ตารางโดยดัชนี gi เพื่อปรับปรุงประสิทธิภาพ สิ่งนี้จะแทนที่ชุดของคุณด้วย std :: vector <std :: set <int>> คุณเติมด้วย "v [gi] .insert (gj)" ดังนั้นจำนวนทั้งหมดของศูนย์จะมาจากการรวม v [gi] .size () สำหรับ gi ทั้งหมด สิ่งนี้ควรทำงานในเวลา O (n-log-k) โดยที่ k คือจำนวน unknowns ต่อองค์ประกอบ (หกสำหรับคุณ - เป็นค่าคงที่สำหรับรหัส pde ส่วนใหญ่เว้นแต่ว่าคุณกำลังพูดถึงวิธีการของ hp)

(หมายเหตุ - ต้องการให้นี่เป็นความคิดเห็นในคำตอบที่เลือก แต่ยาวเกินไป - ขออภัย!)

$E^T$$\times$