Mechanics of Defect Evolution Library
Loading...
Searching...
No Matches
GrainBoundaryTransmission.h
Go to the documentation of this file.
1/* This file is part of MoDELib, the Mechanics Of Defects Evolution Library.
2 *
3 *
4 * MoDELib is distributed without any warranty under the
5 * GNU General Public License (GPL) v2 <http://www.gnu.org/licenses/>.
6 */
7
8#ifndef model_GrainBoundaryTransmission_H_
9#define model_GrainBoundaryTransmission_H_
10
11#include <deque>
12#include <utility>
13#include <math.h>
14#include <TerminalColors.h>
15//#include <TransmitSegment.h>
16 // defines mode::cout
17
18
19namespace model
20{
21
22
23
24 template <int modelID>
29
30 template <>
31 struct GrainBoundaryTransmissionEnergyModel<1>
32 {
33
34 static constexpr double alpha=1.0;
35 static constexpr double lambda=5.0;
36
37 template<typename SegmentType>
38 static double dGdirect(const SegmentType& seg,
39 const Eigen::Matrix<double,SegmentType::dim,1>& grain2OutNormal,
40 const Eigen::Matrix<double,SegmentType::dim,1>& b2,
41 const Eigen::Matrix<double,SegmentType::dim,1>& n2)
42 {
43
44 double temp=0.0;
45
46 const size_t q=seg.quadraturePoints().size()/2;
47 if(seg.quadraturePoints().size()>q)
48 {
49 const Eigen::Matrix<double,SegmentType::dim,1> pk((seg.quadraturePoint(q).stress*b2).cross(seg.chord().normalized()));
50
51 // std::cout<<"here 1"<<std::endl;
52
53 const Eigen::Matrix<double,SegmentType::dim,1> pkg(pk-pk.dot(n2)*n2);
54
55 if( pkg.dot(grain2OutNormal)<0.0
56 )
57 {// pk force on segment must be pushing into new grain
58 const Eigen::Matrix<double,SegmentType::dim,1>& b1(seg.burgers());
59 const double tau=fabs((seg.quadraturePoint(q).stress*b2.normalized()).dot(n2));
60
61 temp=0.5*alpha*((b1-b2).squaredNorm()+b2.squaredNorm()-b1.squaredNorm())-tau*b2.norm()*lambda;
62 }
63 }
64
65 // std::cout<<"here 0"<<std::endl;
66 // std::cout<<"seg.quadratureParticleContainer.size()="<<seg.quadratureParticleContainer.size()<<std::endl;
67 // if((seg.stressAtQuadrature(q)*seg.burgers()).cross(seg.chord().normalized()).dot(grain2OutNormal)<0.0)
68
69 return temp;
70 }
71
72
73 template<typename SegmentType>
74 static double dGindirect(const SegmentType& seg,
75 const Eigen::Matrix<double,SegmentType::dim,1>& grain2OutNormal,
76 const Eigen::Matrix<double,SegmentType::dim,1>& b2,
77 const Eigen::Matrix<double,SegmentType::dim,1>& n2)
78 {
79
80 return dGdirect(seg,grain2OutNormal,b2,n2);
81 }
82
83 };
84
85 template <typename DislocationNetworkType>
86 class GrainBoundaryTransmission
87 {
88 static constexpr int dim=DislocationNetworkType::dim;
89 typedef typename DislocationNetworkType::LinkType LinkType;
90 typedef Grain<dim> GrainType;
91 typedef GrainBoundary<dim> GrainBoundaryType;
92 typedef Eigen::Matrix<double,dim,1> VectorDim;
93
94 DislocationNetworkType& DN;
95
96 static constexpr double chordTol=1.0;
97
98 typedef std::tuple<size_t, // sourceID
99 /* */ size_t, // sinkID
100 /* */ size_t, // grainID
101 /* */ size_t, // slipSystemID
102 /* */ std::pair<int,int>, // grainBoundaryID
103 /* */ int // transmission type
104 /* */ > TransmissionDataType;
105
106 typedef std::map<double,TransmissionDataType> LinkTransmissionDataContainerType;
107 typedef std::deque<TransmissionDataType> TransmissionDataContainerType;
108
109
110 /**********************************************************************/
111 void emplaceData(const LinkType& seg,
112 const GrainBoundaryType& grainBoundary,
113 const GrainType& grain,
114 const std::shared_ptr<SlipSystem>& slipSystem,
115 const size_t& ssID,
116 const int& transmissionType,
117 LinkTransmissionDataContainerType& transmissionMap) const
118 {
119
120 std::cout<<"GBsegment "<<seg.source->sID<<"->"<<seg.sink->sID<<" "<<grain.grainID<<" "<<ssID<<std::flush;
121
122
123 double dG=0.0;
124 switch (grainBoundaryTransmissionModel)
125 {
126 case 1:
127 {
128 switch (transmissionType)
129 {
130 case 0: // direct transmit
131 {
132 std::cout<<" directTransmit "<<std::flush;
133 dG=GrainBoundaryTransmissionEnergyModel<1>::dGdirect(seg,
134 grainBoundary.outNormal(grain.grainID),
135 slipSystem->s.cartesian(),
136 slipSystem->n.cartesian().normalized()
137 );
138 break;
139 }
140
141 case 1: // offset transmit
142 {
143 std::cout<<" offsetTransmit "<<std::flush;
144 // dG=GrainBoundaryTransmissionEnergyModel<1>::dGdirect(*link.second,
145 // grainBoundary->glidePlane(grain.second->grainID).unitNormal,
146 // slipSystem->s.cartesian(),
147 // slipSystem->n.cartesian().normalized()
148 // );
149 break;
150 }
151
152 default:
153 {
154 std::cout<<" indirectTransmit "<<std::flush;
155 dG=GrainBoundaryTransmissionEnergyModel<1>::dGindirect(seg,
156 grainBoundary.outNormal(grain.grainID),
157 slipSystem->s.cartesian(),
158 slipSystem->n.cartesian().normalized()
159 );
160 break;
161 }
162 }
163 break;
164 }
165
166 default:
167 std::cout<<" Transmission Model not implemented. "<<std::flush;
168
169 break;
170 }
171
172 std::cout<<"dG= "<<dG<<std::endl;
173
174
175 if(dG<0.0)
176 {
177 const TransmissionDataType data(seg.source->sID,
178 seg.sink->sID,
179 grain.grainID,
180 ssID,
181 grainBoundary.grainBndID,
182 transmissionType);
183
184 transmissionMap.emplace(dG,data);
185
186 }
187
188 }
189
190 public:
191
192 const size_t grainBoundaryTransmissionModel;
193
194 /**********************************************************************/
195 GrainBoundaryTransmission(DislocationNetworkType& DN_in) :
196 /* init */ DN(DN_in)
197 /* init */,grainBoundaryTransmissionModel(TextFileParser("inputFiles/DD.txt").readScalar<int>("grainBoundaryTransmissionModel",true))
198 {
199
200 }
201
202
203
204 /**********************************************************************/
205 size_t directTransmit()
206 {
207 assert(false && "REWORK THIS");
208 return 0;
209 }
210// {
211// size_t nTransmitted=0;
212// if(grainBoundaryTransmissionModel)
213// {
214// std::cout<<" GrainBounTransmission... "<<std::flush;
215// const auto t0=std::chrono::system_clock::now();
216//
217//
218// TransmissionDataContainerType transmissionDeq;
219//
220// for (const auto& link : DN.links() )
221// {
222// LinkTransmissionDataContainerType transmissionMap;
223//
224//
225// const VectorDim chord(link.second->chord());
226// const VectorDim glidePlaneNormal(link.second->glidePlaneNormal());
227//
228// if( link.second->isGrainBoundarySegment()
229// && chord.norm()>chordTol*DislocationNetworkRemesh<dim>::Lmin
230// )
231// {
232// const VectorDim unitChord(chord.normalized());
233//
234// for(const auto& grainBoundary : link.second->grainBoundaries())
235// {
236// for(const auto& grain : grainBoundary->grains())
237// {
238// for(size_t ssID=0;ssID<grain.second->slipSystems().size();++ssID)
239// {
240// const auto& slipSystem(grain.second->slipSystems()[ssID]);
242// if(grainBoundary->outNormal(grain.second->grainID).cross(slipSystem->n.cartesian().normalized()).norm()>FLT_EPSILON // slip plane is not GB plane
243// //&& slipSystem->n.cartesian().normalized().cross(glidePlaneNormal).norm()>FLT_EPSILON
244// ) // NOT SAME PLANE, REMOVE THIS
245//
246// {
247// if(fabs(slipSystem->n.cartesian().normalized().dot(unitChord))<FLT_EPSILON )
248// {// slip plane cointains chord -> direct or indirect (offset) transmit
249// const std::pair<bool,long int> temp=LatticePlane::computeHeight(slipSystem->n,0.5*(link.second->source->get_P()+link.second->sink->get_P()));
250// if(temp.first)
251// {// direct transmit possible
252// emplaceData(*link.second,*grainBoundary,*grain.second,slipSystem,ssID,0,transmissionMap);
253// }
254// else
255// {// direct transmit not possible, use offset transmit
256// emplaceData(*link.second,*grainBoundary,*grain.second,slipSystem,ssID,1,transmissionMap);
257// }
258// }
259// else
260// {// slip plane doesn't cointains chord -> indirect (incident) transmit
261// emplaceData(*link.second,*grainBoundary,*grain.second,slipSystem,ssID,2,transmissionMap);
262// }
263// }
264// }
265// }
266// }
267//
268// }
269//
270// if(transmissionMap.size())
271// {
272// transmissionDeq.push_back(transmissionMap.begin()->second); // best transmission choice for the segment
273// }
274//
275// }
276//
277//
278//
279// // Insert new loops
280// for(const auto& tup : transmissionDeq)
281// {
282// const size_t& sourceID(std::get<0>(tup));
283// const size_t& sinkID(std::get<1>(tup));
284// const size_t& grainID(std::get<2>(tup));
285// const size_t& slipID(std::get<3>(tup));
286// const std::pair<int,int>& gbID(std::get<4>(tup));
287// const int& transmissionType(std::get<5>(tup));
288//
289// const auto isLink(DN.link(sourceID,sinkID));
290// if(isLink.first)
291// {
292// switch(transmissionType)
293// {
294// case 0:
295// {
296// std::cout<<"direct transmission"<<std::endl;
297//
298//
299// const VectorDim gbInNormal(-DN.poly.grainBoundary(gbID.first,gbID.second).outNormal(grainID));
300// const VectorDim dir=(gbInNormal-gbInNormal.dot(DN.poly.grain(grainID).slipSystems()[slipID]->n.cartesian().normalized())*DN.poly.grain(grainID).slipSystems()[slipID]->n.cartesian().normalized()).normalized();
301//
302// const VectorDim newNodeP(0.5*(isLink.second->source->get_P()+isLink.second->sink->get_P())+dir*10.0);
303// const size_t newNodeID=DN.insertDanglingNode(newNodeP,VectorDim::Zero(),1.0).first->first;
304//
305// std::vector<size_t> nodeIDs;
306//
307// nodeIDs.push_back(sinkID); // insert in reverse order, sink first, source second
308// nodeIDs.push_back(sourceID); // insert in reverse order, sink first, source second
309// nodeIDs.push_back(newNodeID);
310//
311// DN.insertLoop(nodeIDs,
312// DN.poly.grain(grainID).slipSystems()[slipID]->s.cartesian(),
313// DN.poly.grain(grainID).slipSystems()[slipID]->n.cartesian(),
314// 0.5*(isLink.second->source->get_P()+isLink.second->sink->get_P()),
315// grainID);
316//
317// nTransmitted++;
318// break;
319// }
320// case 1: // offset transmit
321// {
322// std::cout<<"indirect transmission"<<std::endl;
323//
324//
325// const std::pair<bool,long int> heightPair=LatticePlane::computeHeight(DN.poly.grain(grainID).slipSystems()[slipID]->n,
326// 0.5*(isLink.second->source->get_P()+isLink.second->sink->get_P()));
327//
328// // const double planeSpacing=1.0/DN.poly.grain(grainID).slipSystems()[slipID]->n.cartesian().norm();
329//
330//
331// PlanePlaneIntersection<dim> ppi(0.5*(isLink.second->source->get_P()+isLink.second->sink->get_P()),
332// DN.poly.grainBoundary(gbID.first,gbID.second).outNormal(grainID),
333// heightPair.second*DN.poly.grain(grainID).slipSystems()[slipID]->n.cartesian()/DN.poly.grain(grainID).slipSystems()[slipID]->n.cartesian().squaredNorm(),
334// DN.poly.grain(grainID).slipSystems()[slipID]->n.cartesian());
335//
336// assert(0 && "FINISH HERE");
337//
338//
339//
340//
341// break;
342// }
343// default: // indirect (incident) transmit
344// {
391//
392//
393//
394// break;
395// }
396// }
397//
398//
399// }
400// }
401//
402// DN.clearDanglingNodes();
403//
404// std::cout<<magentaColor<<" ["<<(std::chrono::duration<double>(std::chrono::system_clock::now()-t0)).count()<<" sec]"<<defaultColor<<std::endl;
405// }
406// return nTransmitted;
407// }
408
409
410 };
411
412// template <typename DislocationNetworkType>
413// size_t GrainBoundaryTransmission<DislocationNetworkType>::grainBoundaryTransmissionModel=0;
414
415
416} // end namespace
417#endif
418
419
420
421// /**********************************************************************/
422// void transmit()
423// {
424// if(grainBoundaryTransmission)
425// {
426// std::cout<<" grain-boundary transmission..."<<std::flush;
427//
428// const auto t0= std::chrono::system_clock::now();
429// size_t nTransmitted=0;
430// for(const auto& gbSegment : *this)
431// {
432// if(DN.link(gbSegment.sourceID,gbSegment.sinkID).first)
433// {
434// if(gbSegment.isValidTransmission)
435// {
436// const int originalGrainID=DN.link(gbSegment.sourceID,gbSegment.sinkID).second->grain.grainID;
437// const int newGrainID=gbSegment.transmitGrain->grainID;
438//
439// std::cout<<"segment GB ID="<<DN.link(gbSegment.sourceID,gbSegment.sinkID).second->grain.grainID<<std::endl;
440// std::cout<<"transmit GB ID="<<gbSegment.transmitGrain->grainID<<std::endl;
441//
442// size_t newSourceID=gbSegment.sourceID;
443// size_t newSinkID=gbSegment.sinkID;
444//
445// if(originalGrainID==newGrainID)
446// {
447// DN.template disconnect<false>(newSourceID,newSinkID);
448// DN.connect(newSourceID,newSinkID,gbSegment.originalBurgers+*gbSegment.transmitBurgers);
449// }
450// else
451// {
452// newSourceID=DN.insertVertex(gbSegment.transmitSourceP,gbSegment.transmitGrain->grainID).first->first;
453// newSinkID=DN.insertVertex(gbSegment.transmitSinkP,gbSegment.transmitGrain->grainID).first->first;
454// DN.connect(newSourceID,newSinkID,*gbSegment.transmitBurgers);
455// }
456//
457// const size_t newMidpointID(DN.insertVertex(gbSegment.transmitMidpoint->cartesian(),gbSegment.transmitGrain->grainID).first->first);
458// DN.connect(newSinkID,newMidpointID,*gbSegment.transmitBurgers);
459// DN.connect(newMidpointID,newSourceID,*gbSegment.transmitBurgers);
460//
461// nTransmitted++;
462// }
463// }
464// }
465//
466//
467//
468// std::cout<<"("<<nTransmitted<<" transmissions)"<<magentaColor<<" ["<<(std::chrono::duration<double>(std::chrono::system_clock::now()-t0)).count()<<" sec]"<<defaultColor<<std::endl;
469//
470// }
471// }
472
model::GrainBoundary::outNormal
const VectorDimD & outNormal(const size_t &k) const
Definition GrainBoundary.cpp:135
model::GrainBoundary::grainBndID
const std::pair< int, int > & grainBndID
Definition GrainBoundary.h:61
model::GrainBoundaryTransmission::GrainBoundaryTransmission
GrainBoundaryTransmission(DislocationNetworkType &DN_in)
Definition GrainBoundaryTransmission.h:195
model::Grain::grainID
const size_t & grainID
Definition Grain.h:49
model::TextFileParser
Definition TextFileParser.h:123
q
the magnitude of the R vector q
Definition infiniteDisplacement.m:11
DislocationNetworkType
DislocationNetwork< 3 > DislocationNetworkType
Definition pyMoDELib.cxx:69
model::GrainBoundaryTransmissionEnergyModel< 1 >::dGdirect
static double dGdirect(const SegmentType &seg, const Eigen::Matrix< double, SegmentType::dim, 1 > &grain2OutNormal, const Eigen::Matrix< double, SegmentType::dim, 1 > &b2, const Eigen::Matrix< double, SegmentType::dim, 1 > &n2)
Definition GrainBoundaryTransmission.h:38
model::GrainBoundaryTransmissionEnergyModel< 1 >::dGindirect
static double dGindirect(const SegmentType &seg, const Eigen::Matrix< double, SegmentType::dim, 1 > &grain2OutNormal, const Eigen::Matrix< double, SegmentType::dim, 1 > &b2, const Eigen::Matrix< double, SegmentType::dim, 1 > &n2)
Definition GrainBoundaryTransmission.h:74
temp
vertex temp
Definition triangle.cpp:9214
Generated by doxygen 1.15.0