Visualizao da estrutura cristalina e magntica utilizando o

Visualização da estrutura cristalina e magnética utilizando o VTK

Objectivos do trabalho Representar graficamente a célula unitária a 3 D; n Representar graficamente a estrutura magnética do composto; n Simular a transição magneto-estrutural do composto; n Simular a reorientação de spin do composto. n

Menu printf("nnnnnnnnnnnnnnnnn"); printf("nn ////////////////////////////////////////nn"); printf(" ------------------ MENU-----------------nn "); printf("t ATENCAO: Este programa diferencia maisculas de minusculas nnn"); printf ("t t C-Visualizacao da Estrutura Cristalografica nnn"); printf (" t t M-Visualizacao da Estrutura Magnetica nnn"); printf ("t t S-Simulacao da transicao estrutural nnn"); printf ("t t H-Simulacao da reorientacao de spin nnn"); printf("////////////////////////////////////////nn"); printf("nn"); util = getchar(); //Condição da escolha da letra C programa para visualizar a Estrutura Cristalografica if ( util == 'C') { Erro !!! if ( util != 'H' && util != 'S' && util != 'M' && util != 'C') { printf ("nn Voce nao escolheu nenhuma das opcoes dadasn"); printf ("nn O programa desliga-se automaticamente volte a tentar por favorn"); printf ("nn para isso carregue em qualquer tecla n"); }

Classes do VTK utilizadas mais importantes n vtk. Sphere. Source. h n vtk. Arrow. Source. h n vtk. Axes. h n vtk. Actor 2 D. h n vtk. Cell. Array. h Texto

Opção “C”-Estrutura cristalina // Criação de uma esfera por uma classe pré definida ( Source) vtk. Sphere. Source *sphere = vtk. Sphere. Source: : New(); sphere->Set. Theta. Resolution(100); sphere->Set. Phi. Resolution(50); Source da Esfera // Mapeamento de uma esfera que depois irá ser utilizada em vários actores vtk. Poly. Data. Mapper *sphere. Mapper = vtk. Poly. Data. Mapper: : New(); sphere. Mapper->Set. Input(sphere->Get. Output()); Mapeamento da Esfera // Criação dos actores Neste caso temos 36 atomos: vtk. Actor *sphere 1 = vtk. Actor: : New(); sphere 1 ->Set. Mapper(sphere. Mapper); sphere 1 ->Get. Property()->Set. Color(0, 0, 1); sphere 1 ->Get. Property()->Set. Ambient(0. 3); sphere 1 ->Get. Property()->Set. Diffuse(0. 5); sphere 1 ->Get. Property()->Set. Specular(1. 0); sphere 1 ->Get. Property()->Set. Specular. Power(20. 0); sphere 1 ->Add. Position(x[1], y[1], z[1]); Actor da Esfera ……. vtk. Renderer *ren 1 = vtk. Renderer: : New(); vtk. Render. Window *ren. Win = vtk. Render. Window: : New(); ren. Win->Add. Renderer(ren 1); vtk. Render. Window. Interactor *iren = vtk. Render. Window. Interactor: : New(); iren->Set. Render. Window(ren. Win); Render Janela

Opção “C”-Estrutura cristalina char *text = "Estrutura Cristalografica"; vtk. Text. Mapper *p. Text = vtk. Text. Mapper: : New(); p. Text->Set. Input(text); vtk. Text. Property *prop. Text = p. Text->Get. Text. Property(); prop. Text->Set. Font. Size(18); prop. Text->Set. Font. Family. To. Arial(); prop. Text->Set. Color(0, 0, 1); prop. Text->Bold. On(); prop. Text->Italic. Off(); prop. Text->Shadow. Off(); prop. Text->Set. Justification. To. Left(); prop. Text->Set. Vertical. Justification. To. Bottom(); vtk. Actor 2 D *p. Actor = vtk. Actor 2 D: : New(); p. Actor->Set. Mapper(p. Text); p. Actor->Set. Position(425, 650); Título ren 1 ->Add. Actor 2 D(p. Actor); ren 1 ->Add. Actor(sphere 1); ren 1 ->Set. Background(1, 1, 0. 7); ren. Win->Set. Size(400, 200); // Tamanho dos parâmetros da rede a=7. 4313; b=14. 6278; c=7. 7151; static float q[8][3]={{0, 0, 0}, {a, b, 0}, {0, 0, c}, {a, b, c}, {0, b, c}}; static vtk. Id. Type pts[6][4]={{0, 1, 2, 3}, {4, 5, 6, 7}, {0, 1, 5, 4}, {1, 2, 6, 5}, {2, 3, 7, 6}, {3, 0, 4, 7}}; vtk. Poly. Data *celula = vtk. Poly. Data: : New(); vtk. Points *points = vtk. Points: : New(); vtk. Cell. Array *polys=vtk. Cell. Array: : New(); Célula

Opção “C”-Estrutura cristalina int j; for (j=0; j<8; j++) points->Insert. Point(j, q[j]); for (j=0; j<6; j++) polys->Insert. Next. Cell(4, pts[j]); celula->Set. Points(points); points->Delete(); celula->Set. Polys(polys); polys->Delete(); // Mapeador da celula vtk. Poly. Data. Mapper *celula. Mapper = vtk. Poly. Data. Mapper: : New(); celula. Mapper->Set. Input(celula); Célula // Criação do actor da celula vtk. Actor *celula. Actor = vtk. Actor: : New(); celula. Actor->Set. Mapper(celula. Mapper); celula. Actor->Get. Property()->Set. Representation. To. Wireframe(); ren 1 ->Add. Actor(celula. Actor); celula. Mapper->Delete(); // Criação do texto com as direcções segundo xx neste caso é segundo // a direcção do parametro a da celula, b corresponde aos yy e finalmente c aos zz. vtk. Vector. Text *texta=vtk. Vector. Text: : New(); texta->Set. Text("a"); vtk. Poly. Data. Mapper *texta. Mapper=vtk. Poly. Data. Mapper: : New(); texta. Mapper->Set. Input(texta->Get. Output()); vtk. Actor *texta. Actor=vtk. Actor: : New(); texta. Actor->Set. Mapper(texta. Mapper); texta. Actor->Set. Position(1, 0, -0. 5); texta. Actor->Set. Scale(0. 5); ren 1 ->Add. Actor(texta. Actor); vtk. Vector. Text *textb=vtk. Vector. Text: : New(); vtk. Vector. Text *textc=vtk. Vector. Text: : New(); Etiquetagem eixos

Opção “C”-Estrutura cristalina // Criação dos eixos vtk. Axes *axes=vtk. Axes: : New(); axes->Set. Origin(0, 0, 0); axes->Set. Scale. Factor(1); axes->Symmetric. On(); vtk. Poly. Data. Mapper *axes. Mapper=vtk. Poly. Data. Mapper: : New(); axes. Mapper->Set. Input(axes->Get. Output()); Eixos vtk. Actor *axes. Actor=vtk. Actor: : New(); axes. Actor->Set. Mapper(axes. Mapper); ren 1 ->Add. Actor(axes. Actor); axes. Mapper->Delete(); // Criação da luz no render vtk. Light *light = vtk. Light: : New(); light->Set. Focal. Point(1. 875, 0. 6125, 0); light->Set. Position(0. 875, 1. 6125, 1); ren 1 ->Add. Light(light); Luz // Inicializar as interacções iren->Initialize(); iren->Start(); Iniciar Interacção // Apapgar todos os pointers (actores, render, mapeadores, sources, renderwindows, lights, etc. ) p. Text->Delete(); Delete

Opção “M”-Estrutura Magnética // Criação da fonte da secta (source) que é a junção de um // cone numa extremidade de um cilindro vtk. Arrow. Source *arrow = vtk. Arrow. Source: : New(); // Mappeador da secta vtk. Poly. Data. Mapper *arrow. Mapper = vtk. Poly. Data. Mapper: : New(); arrow. Mapper->Set. Input(arrow->Get. Output()); Source Seta Mappeamento Seta // Criação dos actores sectas (correspondem aos spins): vtk. Actor *arrowactor 1 = vtk. Actor: : New(); arrowactor 1 ->Set. Mapper(arrow. Mapper); arrowactor 1 ->Set. Position(x[1]-0. 5, y[1], z[1]); arrowactor 1 ->Set. Scale(2); (arrowactor 1 ->Get. Property())->Set. Color(0. 5, 0. 5); arrowactor 1 ->Rotate. Z(phi[1]); arrowactor 1 ->Rotate. X(theta[1]); Actor Seta

Opção “S”-Simulação da transição Estrutural // apontadores declarados globais por serem usados no callback vtk. Renderer *ren 1; long time. Last. Call=0; vtk. Actor *sphere 1; …. . bool toogle=0; // Class Callback para ser utilizado coma interacção class vtk. My. Callback : public vtk. Command { public: static vtk. My. Callback *New() { return new vtk. My. Callback; } void Print. Self(ostream& os, vtk. Indent indent) {} void Print. Trailer(ostream& os, vtk. Indent indent) {} void Print. Header(ostream& os, vtk. Indent indent) {} void Collect. Revisions(ostream& os) {} virtual void Execute(vtk. Object *caller, unsigned long, void*) { vtk. Render. Window. Interactor *ri = reinterpret_cast<vtk. Render. Window. Interactor*>(caller); if ((time. Get. Time() - time. Last. Call) > 1000) { cout << "1 segundo" << endl; time. Last. Call = time. Get. Time(); sphere 1 ->Add. Position(0. 1, 0, 0); ……. } ri->Get. Render. Window()->Render(); Abort. Flag. On(); vtk. Render. Window. Interactor } }; Mycallback

Opção “S”-Simulação da transição Estrutural vtk. My. Callback *mo 1 = vtk. My. Callback: : New(); iren->Create. Timer(VTKI_TIMER_FIRST); iren->Add. Observer(vtk. Command: : Timer. Event, mo 1, 2. 0); time. Last. Call = time. Get. Time(); Chamada vtk. Callback

Opção “H”-Simulação da transição Reorientação spin vtk. Renderer *ren 1 = vtk. Renderer: : New(); ren 1 ->Add. Actor(p. Actor); …. ren 1 ->Get. Active. Camera()->Set. Focal. Point(0, 0, 0); ren 1 ->Get. Active. Camera()->Set. Position(0, 10, 0); ren 1 ->Reset. Camera(); ren 1 ->Get. Active. Camera()->Set. Parallel. Scale(5); …. tk. Renderer *ren 2 = vtk. Renderer: : New(); ren 2 ->Add. Actor(p. Actor 2); Renderer 1 … ren 2 ->Get. Active. Camera()->Set. Focal. Point(0, 0, 0); ren 2 ->Get. Active. Camera()->Set. Position(0, 10, 0); ren 2 ->Reset. Camera(); ren 2 ->Get. Active. Camera()->Set. Parallel. Scale(5); vtk. Render. Window *ren. Win 1 = vtk. Render. Window: : New(); ren. Win 1 ->Add. Renderer(ren 1); vtk. Render. Window *ren. Win 2 = vtk. Render. Window: : New(); ren. Win 2 ->Add. Renderer(ren 2); Renderer 2 Janela 1 Janela 2 vtk. Render. Window. Interactor *iren 1 = vtk. Render. Window. Interactor: : New(); iren 1 ->Set. Render. Window(ren. Win 1); vtk. Render. Window. Interactor *iren 2 = vtk. Render. Window. Interactor: : New(); iren 2 ->Set. Render. Window(ren. Win 2); ren. Win 1 ->Render(); ren. Win 2 ->Render(); iren 1 ->Start(); Interacção

Melhoramentos Futuros n n n Determinação das distâncias/posições dos átomos; Poder seleccionar os planos atómicos; Etiquetar os atómos; Mais dificil!!!!! Utilização de Teoria de Grupos

Trabalho da disciplina de Visualização Científica Realizado por: Agradecimentos Dr(s): André Pereira J. Tavares & J. Barbosa