int main (int argc, char **argv) { GetPot cl (argc, argv); if (cl.search (2, "-h", "--help")) { std::cerr << help_text << std::endl; return 0; } const double a = cl.follow (0.0, "-a"); const double b = cl.follow (1.0, "-b"); const unsigned int nnodes = cl.follow (100, 2, "-n", "--nnodes"); const std::string diffusion = cl.follow ("1.0", 2, "-d", "--diffusion"); const std::string forcing = cl.follow ("1.0", 2, "-f", "--forcing"); std::unique_ptr<mesh<double>> m (new mesh<double> (a, b, nnodes)); fem_1d<double> problem (std::move (m)); coeff<double> a_coeff (diffusion); problem.set_diffusion_coefficient (a_coeff); coeff<double> f_coeff (forcing); problem.set_source_coefficient (f_coeff); problem.assemble (); problem.set_dirichlet (fem_1d<double>::left_boundary, 0.0); problem.set_dirichlet (fem_1d<double>::right_boundary, 0.0); problem.solve (); for (unsigned int ii = 0; ii < nnodes; ++ii) std::cout << problem.m->nodes[ii] << " " << problem.result ()(ii, 0) << std:: endl; return 0; };
int main (int argc, char *argv[]) { const unsigned int ImageDimension = 2; GetPot cl (argc, const_cast<char**>(argv)); if( cl.size() == 1 || cl.search (2,"--help","-h") ) { std::cout << "Not Enough Arguments" << std::endl; std::cout << "Generate the Gradient Table" << std::endl; std::cout << "Usage: return -1" << std::endl; } const string image_n = cl.follow("NoFile",1, "-i"); const string out_n = cl.follow("NoFile",1, "-o"); typedef itk::DiffusionTensor3D<float> DiffusionTensorType; typedef itk::Image<DiffusionTensorType, 3> ImageType; typedef itk::ImageFileReader<ImageType> ReaderType; ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(image_n); reader->Update(); ImageType::Pointer image = reader->GetOutput(); typedef itk::ImageRegionIterator<ImageType> TensorIterator; TensorIterator itImg(image, image->GetLargestPossibleRegion()); std::ofstream file; file.open(out_n); for(itImg.GoToBegin(); !itImg.IsAtEnd(); ++itImg) { file << itImg.Get() << std::endl; } file.close(); return 0; }
int main (int argc, char **argv) { GetPot cl (argc, argv); if (cl.search (2, "-h", "--help")) { std::cerr << help_text << std::endl; return 0; } const double a = cl.follow (0.0, "-a"); const double b = cl.follow (1.0, "-b"); const unsigned int nnodes = cl.follow (100, 2, "-n", "-nnodes"); mesh m (a, b, nnodes); Eigen::MatrixXd A(nnodes, nnodes); Eigen::Matrix2d mloc; mloc << 0, 0, 0, 0; for (unsigned int iel = 0; iel < m.nels; ++iel) { mloc << 0, 0, 0, 0; for (unsigned int inode = 0; inode < 2; ++inode) { double igrad = (inode == 0 ? 1.0 / m.h : -1.0 / m.h); for (unsigned int jnode = 0; jnode < 2; ++jnode) { double jgrad = (jnode == 0 ? 1.0 / m.h : -1.0 / m.h); mloc(inode,jnode) = igrad * jgrad * m.h; A(m.elements[iel][inode],m.elements[iel][jnode]) += mloc(inode,jnode); } } } Eigen::VectorXd f(nnodes); Eigen::Vector2d vloc; for (unsigned int iel = 0; iel < m.nels; ++iel) { vloc << 0, 0; for (unsigned int inode = 0; inode < 2; ++inode) { vloc(inode) = m.h / 2.0; f(m.elements[iel][inode]) += vloc(inode); } } f(0) = 0; f(nnodes - 1) = 0; A(0,0) = 1.0; A(nnodes-1,nnodes-1) = 1.0; for (unsigned int ii = 1; ii < nnodes; ++ii) { A(0, ii) = 0.0; A(nnodes-1, nnodes-1-ii) = 0.0; } Eigen::VectorXd uh = A.partialPivLu ().solve (f); for (unsigned int ii = 0; ii < nnodes; ++ii) std::cout << uh(ii, 0) << std:: endl; return 0; };
int main (int argc, char **argv) { GetPot cl (argc, argv); if (cl.search (2, "-h", "--help")) { std::cerr << help_text << std::endl; return 0; } const double a = cl.follow (0.0, "-a"); const double b = cl.follow (1.0, "-b"); const unsigned int nnodes = cl.follow (100, 2, "-n", "-nnodes"); mesh m (a, b, nnodes); matrix A(nnodes); matrix mloc(2); for (unsigned int iel = 0; iel < m.nels; ++iel) { std::fill (mloc.get_data (), mloc.get_data () + 4, 0.0); for (unsigned int inode = 0; inode < 2; ++inode) { double igrad = (inode == 0 ? 1.0 / m.h : -1.0 / m.h); for (unsigned int jnode = 0; jnode < 2; ++jnode) { double jgrad = (jnode == 0 ? 1.0 / m.h : -1.0 / m.h); mloc(inode,jnode) = igrad * jgrad * m.h; A(m.elements[iel][inode],m.elements[iel][jnode]) += mloc(inode,jnode); } } } matrix f(nnodes, 1); matrix vloc(2, 1); for (unsigned int iel = 0; iel < m.nels; ++iel) { std::fill (mloc.get_data (), mloc.get_data () + 2, 0.0); for (unsigned int inode = 0; inode < 2; ++inode) { vloc(inode, 0) = m.h / 2.0; f(m.elements[iel][inode], 0) += vloc(inode, 0); } } f(0, 0) = 0; f(nnodes - 1, 0) = 0; A(0,0) = 1.0; A(nnodes-1,nnodes-1) = 1.0; for (unsigned int ii = 1; ii < nnodes; ++ii) { A(0, ii) = 0.0; A(nnodes-1, nnodes-1-ii) = 0.0; } matrix uh(f); A.solve (uh); for (unsigned int ii = 0; ii < nnodes; ++ii) std::cout << uh(ii, 0) << std:: endl; return 0; };
int main (int argc, char** argv) { #ifdef LIFEV_HAS_HDF5 #ifdef HAVE_MPI typedef RegionMesh<LinearTetra> mesh_Type; MPI_Init (&argc, &argv); boost::shared_ptr<Epetra_Comm> comm (new Epetra_MpiComm (MPI_COMM_WORLD) ); if (comm->NumProc() != 1) { std::cout << "This test needs to be run " << "with a single process. Aborting." << std::endl; return (EXIT_FAILURE); } GetPot commandLine (argc, argv); string dataFileName = commandLine.follow ("data", 2, "-f", "--file"); GetPot dataFile (dataFileName); const UInt numElements (dataFile ("mesh/nelements", 10) ); const UInt numParts (dataFile ("test/num_parts", 4) ); const std::string partsFileName (dataFile ("test/hdf5_file_name", "cube.h5") ); const std::string ioClass (dataFile ("test/io_class", "new") ); std::cout << "Number of elements in mesh: " << numElements << std::endl; std::cout << "Number of parts: " << numParts << std::endl; std::cout << "Name of HDF5 container: " << partsFileName << std::endl; boost::shared_ptr<mesh_Type> fullMeshPtr (new mesh_Type ( comm ) ); regularMesh3D (*fullMeshPtr, 1, numElements, numElements, numElements, false, 2.0, 2.0, 2.0, -1.0, -1.0, -1.0); MeshPartitioner<mesh_Type> meshPart; meshPart.setup (numParts, comm); meshPart.attachUnpartitionedMesh (fullMeshPtr); meshPart.doPartitionGraph(); meshPart.doPartitionMesh(); // Release the original mesh from the MeshPartitioner object and // delete the RegionMesh object meshPart.releaseUnpartitionedMesh(); fullMeshPtr.reset(); // Write mesh parts to HDF5 container if (! ioClass.compare ("old") ) { ExporterHDF5Mesh3D<mesh_Type> HDF5Output (dataFile, meshPart.meshPartition(), partsFileName, comm->MyPID() ); HDF5Output.addPartitionGraph (meshPart.elementDomains(), comm); HDF5Output.addMeshPartitionAll (meshPart.meshPartitions(), comm); HDF5Output.postProcess (0); HDF5Output.closeFile(); } else { boost::shared_ptr<Epetra_MpiComm> mpiComm = boost::dynamic_pointer_cast<Epetra_MpiComm> (comm); PartitionIO<mesh_Type> partitionIO (partsFileName, mpiComm); partitionIO.write (meshPart.meshPartitions() ); } MPI_Finalize(); #else std::cout << "This test needs MPI to run. Aborting." << std::endl; return (EXIT_FAILURE); #endif /* HAVE_MPI */ #else std::cout << "This test needs HDF5 to run. Aborting." << std::endl; return (EXIT_FAILURE); #endif /* LIFEV_HAS_HDF5 */ return (EXIT_SUCCESS); }
void Server::parseConfig(GetPot &config) { // this variable is needed for setting up the partial loading part when the features // are loaded for the very first time at fire start up string partialLoadingString="empty"; if(config.search(2,"-F","--filter")) { string unparsed = config.follow("empty",2,"-F","--filter"); if (parseFilter(unparsed.c_str())) { retriever_.setFilterApply(true); DBG(10) << "Using filter " << unparsed << " for retrieval" << endl; } else { retriever_.setFilterApply(false); retriever_.clearFilter(); DBG(10) << "Error in filter String " << unparsed << endl; DBG(10) << "Aborting filtering and using normal retrieval settings" << endl; } } if(config.search(2,"-q","--queryCombiner")) { retriever_.setQueryCombiner(config.follow("adding:POS=1.0:NEG=0.833",2,"-q","--queryCombiner")); } if(config.search("--reRanker")) { retriever_.setReranking(config.follow("cluster:CONS=100:RR=20:CLUSTERS=5","--reRanker")); } if(config.search(2,"-U","--defdontload")) { partialLoadingString="default"; retriever_.setPartialLoadingApply(true); } if(config.search(2,"-u","--dontload")) { string unparsed=config.follow("empty",2,"-u","--dontload"); if(unparsed!="empty") { // the parsing is not possible here, because the amount of different features // is not known yet // but a sanity check is possible const char* str = unparsed.c_str(); bool errformat = false; // note it is not checked if there are two or more : present in a row while(*str != '\0' && !errformat) { if(!isdigit(*str) && *str!=':') { errformat=true; DBG(10) << "Error in format string " << unparsed << " following -u/--dontload option" << endl; DBG(10) << "format string must start with a digit; aborting partial feature loading" << endl; } str++; } if(!errformat && retriever_.setPartialLoadingApply(true)) { partialLoadingString=unparsed; } else { ERR << "-u/--dontload was used without -F/--filter option or there are illegal characters in the format string" << endl; ERR << "ignoring -u/--dontload option, loading all features" << endl; } } else { retriever_.setPartialLoadingApply(false); ERR << "Error after -u/--dontload option: No featureindexsequence given" << endl; //DBG(10) << "Aborting partial loading for filtered retrieval and loading all features" << endl; } } if(config.search(2,"-f","--filelist")) { string filelistname=config.follow("list.txt",2,"-f","--filelist"); string result=retriever_.filelist(filelistname,partialLoadingString); if(result=="filelist FAILURE") { ERR << "Error in filelist. Please correct it and start again." << endl; exit(1); } DBG(10) << result << endl; } if(config.search(2,"-R","--relevancefile")) { relevanceFile_=config.follow("",2,"-R","--relevancefile"); } retriever_.setScoring("linear"); log_=LogFile(config.follow("",2,"-l","--logfile")); if(config.search(2,"-D","--defaultdists")) { for(uint i=0;i<retriever_.numberOfSuffices();++i) { retriever_.dist(i,distanceMaker_.getDefaultDistance(retriever_.featureType(i))); retriever_.weight(i,1.0); DBG(10) << "default dist[" << i << "]=" << retriever_.dist(i)->name() << endl; } } config.init_multiple_occurrence(); // can have multiple distances while(config.search(2,"-d","--dist")) { uint idx=config.follow(0,2,"-d","--dist"); string distname=config.next("basedist"); // default distance measure (dummy!) retriever_.weight(idx,1.0); // set default weight for configured distances retriever_.dist(idx,distanceMaker_.makeDistance(distname)); DBG(10) << "dist[" << idx << "]=" << retriever_.dist(idx)->name() << endl; } config.init_multiple_occurrence(); // can have multiple weights while(config.search(2,"-w","--weight")) { uint idx=config.follow(0,2,"-w","--weight"); double w=config.next(1.0); retriever_.weight(idx,w); DBG(10) << "weight[" << idx << "]=" << w << endl; } retriever_.setScoring(config.follow("linear",2,"-C","--scoring")); if(config.search(2,"-I","--interactor")) { retriever_.setInteractor(config.follow("",2,"-I","--interactor")); } config.enable_loop(); // enable returning to the beginning of command line (was disabled for multiplicity before) if(config.search(2,"-S","--startAfterInit")) { startAfterInit_=config.follow("echo \"No program defined\"",2,"-S","--startAfterInit"); } if(config.search(2,"-P","--proxy")) { proxyhost_=config.follow("localhost",2,"-P","--proxy"); proxyport_=config.next(12963); DBG(10) << "Will notify proxy at " << proxyhost_ << ":"<<proxyport_ << " about my existence." << endl; } if(config.search(2,"-r","--results")) { retriever_.results(config.follow(9,2,"-r","--results")); DBG(10) << "results=" << retriever_.results() << endl; } if(config.search(2,"-l","--log")) { logfile_=config.follow("log.txt",2,"-l","--log"); DBG(10) << "logfile="<< logfile_ << endl; } if(config.search(2,"-s","--server")) { port_=config.follow(12961,2,"-s","--server"); DBG(10) << "port="<< port_ << endl; } if(config.search(2,"-B","--batch")) { batchfile_=config.follow("batch",2,"-B","--batch"); DBG(10) << "batchfile="<< batchfile_ << endl; } if(config.search("--cache")) { retriever_.setCache(config.follow("cache.sqlite3.db","--cache")); } if(config.search(2,"-e","--expansion")) { retriever_.extensions(config.follow(2,2,"-e","--expansion")); DBG(10) << "expansions=" << config.follow(2,2,"-e","--expansion") << endl; } if(config.search(2,"-p","--password")) { password_=config.follow("",2,"-p","--password"); DBG(10) << "password necessary for changing settings: " << password_ << endl; } if(config.search(2,"-t","--type2bin")) { t2bpath=config.follow("",2,"-t","--type2bin"); DBG(10) << "type2bin-file has been reset to: " << t2bpath << endl; } }
int main ( int argc, char** argv ) { #ifdef LIFEV_HAS_HDF5 #ifdef HAVE_MPI MPI_Init (&argc, &argv); boost::shared_ptr<Epetra_MpiComm> comm (new Epetra_MpiComm (MPI_COMM_WORLD) ); const bool verbose (comm->MyPID() == 0); // Read first the data needed if (verbose) { std::cout << " -- Reading the data ... " << std::flush; } // GetPot dataFile ( "data" ); if (verbose) { std::cout << " done ! " << std::endl; } GetPot cl (argc, argv); // partitionerType should be MeshPartitioner, MeshPartitionTool_ParMETIS or // MeshPartitionTool_Zoltan const std::string partitionerType = cl.follow ("MeshPartitioner", "--partitioner-type"); std::string partsFile; partsFile.reserve (50); partsFile += "cube_"; partsFile += partitionerType; partsFile += ".h5"; boost::shared_ptr<mesh_Type> mesh; { PartitionIO<RegionMesh<LinearTetra> > partitionIO (partsFile, comm); partitionIO.read (mesh); } // Build the FESpaces if (verbose) { std::cout << " -- Building FESpaces ... " << std::flush; } std::string uOrder ("P1"); std::string bOrder ("P1"); boost::shared_ptr<FESpace<mesh_Type, MapEpetra> > uFESpace (new FESpace<mesh_Type, MapEpetra> (mesh, uOrder, 1, comm) ); boost::shared_ptr<FESpace<mesh_Type, MapEpetra> > betaFESpace (new FESpace<mesh_Type, MapEpetra> (mesh, bOrder, 3, comm) ); if (verbose) { std::cout << " done ! " << std::endl; } if (verbose) std::cout << " ---> Dofs: " << uFESpace->dof().numTotalDof() << std::endl; // Build the assembler and the matrices if (verbose) { std::cout << " -- Building assembler ... " << std::flush; } ADRAssembler<mesh_Type, matrix_Type, vector_Type> adrAssembler; if (verbose) { std::cout << " done! " << std::endl; } if (verbose) { std::cout << " -- Setting up assembler ... " << std::flush; } adrAssembler.setup (uFESpace, betaFESpace); if (verbose) { std::cout << " done! " << std::endl; } if (verbose) { std::cout << " -- Defining the matrix ... " << std::flush; } boost::shared_ptr<matrix_Type> systemMatrix (new matrix_Type (uFESpace->map() ) ); *systemMatrix *= 0.0; if (verbose) { std::cout << " done! " << std::endl; } // Perform the assembly of the matrix if (verbose) { std::cout << " -- Adding the diffusion ... " << std::flush; } adrAssembler.addDiffusion (systemMatrix, 1); if (verbose) { std::cout << " done! " << std::endl; } if (verbose) std::cout << " Time needed : " << adrAssembler.diffusionAssemblyChrono().diffCumul() << std::endl; if (verbose) { std::cout << " -- Closing the matrix ... " << std::flush; } systemMatrix->globalAssemble(); if (verbose) { std::cout << " done ! " << std::endl; } Real matrixNorm (systemMatrix->normFrobenius() ); if (verbose) { std::cout << " ---> Norm 2 : " << matrixNorm << std::endl; } if (std::fabs (matrixNorm - 35.908) > 1e-3) { std::cout << " <!> Matrix has changed !!! <!> " << std::endl; return EXIT_FAILURE; } if (verbose) { std::cout << "End Result: TEST PASSED" << std::endl; } MPI_Finalize(); #else std::cout << "This test needs MPI to run. Aborting." << std::endl; return (EXIT_FAILURE); #endif /* HAVE_MPI */ #else std::cout << "This test needs HDF5 to run. Aborting." << std::endl; return (EXIT_FAILURE); #endif /* LIFEV_HAS_HDF5 */ return ( EXIT_SUCCESS ); }
int main (int argc, char *argv[]) { GetPot cl (argc, const_cast<char**>(argv)); if( cl.size() == 1 || cl.search (2,"--help","-h") ) { std::cout << "Not Enough Arguments" << std::endl; std::cout << "Scales the tensors with a scalar factor" << std::endl; std::cout << "Usage: -trueB0 <true B0> -m <MaskImage> -true <True Tensors> -f <flag for extended gradient> -t <initial tensor estimate> -g <gradient> -o <Output File> -s <Sigma> -nm <Noise Model> -Sim <intelligent COnvergence>" << std::endl; return -1; } const string image_n =cl.follow("NoFile", 1, "-i"); const string out_n = cl.follow("NoFile", 1, "-o"); const int idx = cl.follow(0, 1, "-ix"); const int idy = cl.follow(0, 1, "-iy"); const int idz = cl.follow(0, 1, "-iz"); const int sx = cl.follow(0, 1, "-sx"); const int sy = cl.follow(0, 1, "-sy"); const int sz = cl.follow(0, 1, "-sz"); typedef itk::Image< float, 3> ImageType; typedef itk::ImageFileReader<ImageType> ReaderType; ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(image_n); reader->Update(); ImageType::Pointer image = reader->GetOutput(); ImageType::SizeType size; ImageType::IndexType id; id[0] = idx; id[1] = idy; id[2] = idz; size[0] = sx; size[1] = sy; size[2] =sz; ImageType::RegionType region(id, size); typedef itk::ExtractImageFilter<ImageType, ImageType> FilterType; FilterType::Pointer filter = FilterType::New(); filter->SetExtractionRegion(region); filter->SetInput(image); filter->SetDirectionCollapseToIdentity(); filter->Update(); ImageType::Pointer exImage = filter ->GetOutput(); typedef itk::ImageFileWriter<ImageType> WriterType; WriterType::Pointer writer = WriterType::New(); writer->SetFileName(out_n); writer->SetInput(exImage); writer->Update(); return 0; }
int main(int argc, char *argv[]) { GetPot cl (argc, const_cast<char**>(argv)); if( cl.size() == 1 || cl.search (2,"--help","-h") ) { std::cout << "Not Enough Arguments" << std::endl; std::cout << "Generate the Gradient Table" << std::endl; std::cout << "Usage: return -1" << std::endl; } // One idea is to apply the rotation matrix const string Linear_trans_n = cl.follow("NoFile",1,"-t"); const string ref_Image_n = cl.follow("NoFile",1, "-r"); const string out_n = cl.follow("NoFile",1,"-o"); const string B0_n =cl.follow("NoFile",1,"-B0"); const string T1_n =cl.follow("NoFile",1,"-T1"); typedef itk::Image<float, 3> ImageType; typedef itk::ImageFileReader<ImageType> ImageReaderType; ImageReaderType::Pointer imageReaderB0 = ImageReaderType::New(); imageReaderB0->SetFileName(B0_n); imageReaderB0->Update(); std::cout << imageReaderB0->GetOutput()->GetDirection() << std::endl; ImageReaderType::Pointer imageReaderT1 = ImageReaderType::New(); imageReaderT1->SetFileName(B0_n); imageReaderT1->Update(); std::cout << imageReaderT1->GetOutput()->GetDirection() << std::endl; // typedef itk::TransformFileReader TransformFileReaderType; // typedef TransformFileReaderType::TransformListType TransformListType; // typedef itk::TransformBase TransformBaseType; // typedef itk::AffineTransform<double, 3> AffineTransformType; // // typedef itk::Image<float, 3> ImageType; // typedef itk::ImageFileReader<ImageType> ImageReaderType; // ImageReaderType::Pointer imageReader = ImageReaderType::New(); // // imageReader->SetFileName(ref_Image_n); // imageReader->Update(); // ImageType::Pointer refImage = imageReader->GetOutput(); // // // // TransformFileReaderType::Pointer readerTransform = TransformFileReaderType::New(); // readerTransform->SetFileName(Linear_trans_n); // readerTransform -> Update(); // TransformListType *list = readerTransform->GetTransformList(); // TransformBaseType * transform = list->front().GetPointer(); // TransformBaseType::ParametersType parameters = transform->GetParameters(); // AffineTransformType::Pointer transform_fwd = AffineTransformType::New(); // transform_fwd->SetParameters(parameters); // // std::cout << transform_fwd->GetParameters() << std::endl; // typedef itk::Vector< float, 3 > VectorPixelType; // typedef itk::Image< VectorPixelType, 3 > DisplacementFieldImageType; // // // typedef itk::TransformToDisplacementFieldFilter<DisplacementFieldImageType, double> DisplacementFieldGeneratorType; // DisplacementFieldGeneratorType::Pointer dispfieldGenerator = DisplacementFieldGeneratorType::New(); // // dispfieldGenerator->UseReferenceImageOn(); // dispfieldGenerator->SetReferenceImage( refImage ); // dispfieldGenerator->SetTransform( transform_fwd ); // dispfieldGenerator->Update(); // DisplacementFieldImageType::Pointer dispField = dispfieldGenerator->GetOutput(); // // typedef itk::ImageFileWriter<DisplacementFieldImageType> DispFieldWriterType; // DispFieldWriterType::Pointer writer = DispFieldWriterType::New(); // writer->SetFileName(out_n); // writer->SetInput(dispField); // writer->Update(); return 0; }
int main (int argc, char *argv[]) { GetPot cl (argc, const_cast<char**>(argv)); if( cl.size() == 1 || cl.search (2,"--help","-h") ) { std::cout << "Not Enough Arguments" << std::endl; std::cout << "Scales the tensors with a scalar factor" << std::endl; std::cout << "Usage: -trueB0 <true B0> -m <MaskImage> -true <True Tensors> -f <flag for extended gradient> -t <initial tensor estimate> -g <gradient> -o <Output File> -s <Sigma> -nm <Noise Model> -Sim <intelligent COnvergence>" << std::endl; return -1; } const string file_g_n = cl.follow("NoFile",1, "-g"); const string fileIn = cl.follow("NoFile",1,"-i"); const string fileIn_HR = cl.follow("NoFile",1,"-iHR"); const string B0_n = cl.follow("NoFile", 1, "-B0"); const string mask_LR_n = cl.follow("NoFile",1, "-mLR"); const int numOfIter = cl.follow(1,1, "-n"); const float kappa_L = cl.follow(0.05, 1, "-k"); const float lambda_L = cl.follow(0.25, 1, "-lamb_L"); const string B0Image_HR_n = cl.follow("NoFile", 1, "-B0HR"); const string dispField_n = cl.follow("NoFile",1,"-d"); const string T1Image_n = cl.follow("NoFile",1,"-T1"); const string mask_HR_n = cl.follow("NoFile", 1, "-mHR"); // Usual Typedefs typedef float RealType; const int ImageDim =3; typedef itk::Image<RealType, ImageDim> ScalarImageType; typedef itk::Vector<double, ImageDim> VectorType; typedef itk::Image<VectorType, ImageDim> DeformationFieldType; typedef itk::Image<VectorType, ImageDim> VectorImageType; typedef itk::ImageFileReader<ScalarImageType> ScalarImageReaderType; typedef itk::ImageFileWriter<ScalarImageType> ScalarImageWriterType; //Read T1 image ScalarImageReaderType::Pointer scalarReader = ScalarImageReaderType::New(); scalarReader->SetFileName(T1Image_n.c_str()); scalarReader->Update(); ScalarImageType::Pointer T1_image = scalarReader->GetOutput(); // Read LR ImageList typedef std::vector<ScalarImageType::Pointer> ImageListType; ImageListType DWIList; std::ifstream file(fileIn.c_str()); int numOfImages = 0; file >> numOfImages; for (int i=0; i < numOfImages ; i++) // change of numOfImages { char filename[256]; file >> filename; ScalarImageReaderType::Pointer myReader=ScalarImageReaderType::New(); myReader->SetFileName(filename); std::cout << "Reading.." << filename << std::endl; // add a try catch block myReader->Update(); DWIList.push_back( myReader->GetOutput() ); //using push back to create a stack of diffusion images } // Read deformation field typedef itk::ImageFileReader<DeformationFieldType> DeformationFieldReaderType; DeformationFieldReaderType::Pointer deformationFieldReader = DeformationFieldReaderType::New(); deformationFieldReader->SetFileName(dispField_n.c_str()); deformationFieldReader->Update(); DeformationFieldType::Pointer defField = deformationFieldReader->GetOutput(); // Read Mask Image Spatial typedef itk::ImageMaskSpatialObject<ImageDim> MaskSpatialObjectType; typedef MaskSpatialObjectType::ImageType MaskSpatialImageType; typedef itk::ImageFileReader<MaskSpatialImageType> MaskSpatialImageReaderType; MaskSpatialImageReaderType::Pointer spatialReader = MaskSpatialImageReaderType::New(); spatialReader->SetFileName(mask_LR_n.c_str()); spatialReader->Update(); MaskSpatialImageType::Pointer maskSpatialImage_LR = spatialReader->GetOutput(); //Read Mask Image Normal ScalarImageReaderType::Pointer maskImageReader = ScalarImageReaderType::New(); maskImageReader->SetFileName(mask_LR_n.c_str()); maskImageReader->Update(); ScalarImageType::Pointer maskImage_LR = maskImageReader->GetOutput(); // Resample diffusion Images /* typedef itk::WarpImageFilter<ScalarImageType, ScalarImageType, DeformationFieldType> WarpImageFilterType; typedef itk::ImageFileWriter<ScalarImageType> ScalarImageWriterType; for (int i =0; i < numOfImages; i++) { WarpImageFilterType::Pointer warpImageFilter = WarpImageFilterType::New(); warpImageFilter->SetOutputSpacing(T1_image->GetSpacing()); warpImageFilter->SetOutputOrigin(T1_image->GetOrigin()); warpImageFilter->SetDisplacementField(defField); warpImageFilter->SetInput(DWIList[i]); warpImageFilter->Update(); ScalarImageType::Pointer imageDWI = warpImageFilter->GetOutput(); std::ostringstream num_con; num_con << i ; std::string result = num_con.str() + ".nii.gz"; ScalarImageWriterType::Pointer writer = ScalarImageWriterType::New(); writer->SetFileName(result); writer->SetInput(imageDWI); writer->Update(); std::cout<< i << "Done" << std::endl; }*/ // Read Gradient List ScalarValues typedef itk::Vector<double, 3> VectorDoubleType; typedef std::vector<VectorDoubleType> GradientListType; GradientListType GradientList; std::ifstream fileg(file_g_n.c_str()); int numOfGrads =0; fileg >> numOfGrads; for (int i=0; i < numOfGrads ; i++) { VectorType g; fileg >> g[0]; fileg >> g[1]; fileg >> g[2]; GradientList.push_back(g); } // Transform gradients // Read the HR diffusion images, typedef std::vector<ScalarImageType::Pointer> ImageListType; ImageListType DWIList_HR; std::ifstream fileHR(fileIn_HR.c_str()); int numOfImagesHR = 0; fileHR >> numOfImagesHR; /* for (int i=0; i < numOfImagesHR ; i++) // change of numOfImages { char filename[256]; fileHR >> filename; ScalarImageReaderType::Pointer myReader=ScalarImageReaderType::New(); myReader->SetFileName(filename); myReader->Update(); std::cout << "Reading.." << filename << std::endl; // add a try catch block DWIList_HR.push_back(myReader->GetOutput()); } */ // Read HR mask image spatial MaskSpatialImageReaderType::Pointer spatialReader_HR = MaskSpatialImageReaderType::New(); spatialReader_HR->SetFileName(mask_HR_n.c_str()); spatialReader_HR->Update(); MaskSpatialImageType::Pointer maskSpatial_HR = spatialReader_HR->GetOutput(); //Read HR mask image Normal ScalarImageReaderType::Pointer maskImage_HR_reader = ScalarImageReaderType::New(); maskImage_HR_reader->SetFileName(mask_HR_n.c_str()); maskImage_HR_reader->Update(); ScalarImageType::Pointer maskImage_HR = maskImage_HR_reader->GetOutput(); // Read B0 HR image ScalarImageReaderType::Pointer B0Image_HR_reader = ScalarImageReaderType::New(); B0Image_HR_reader->SetFileName(B0Image_HR_n.c_str()); B0Image_HR_reader->Update(); ScalarImageType::Pointer B0Image_HR = B0Image_HR_reader->GetOutput(); //Read B0 LR image ScalarImageReaderType::Pointer B0_image_LR_reader = ScalarImageReaderType::New(); B0_image_LR_reader->SetFileName(B0_n.c_str()); B0_image_LR_reader->Update(); ScalarImageType::Pointer B0_image_LR = B0_image_LR_reader->GetOutput(); // ComputeGradientImages /* TransformGradients transformGradients; transformGradients.ReadMaskImage(maskImage_HR); transformGradients.ReadDeformationField(defField); transformGradients.ReadGradients(GradientList); transformGradients.ComputeGradients(); typedef std::vector<VectorImageType::Pointer> GradientImageListType; GradientImageListType GradientImageList; GradientImageList = transformGradients.GetGradientImages(); std::cout << "Transformed all Gradients... Done." << std::endl; typedef itk::ImageFileWriter<VectorImageType> GradientImageWriterType; for (int i=0; i < numOfGrads; i++) { GradientImageWriterType::Pointer gradientImageWriter = GradientImageWriterType::New(); std::ostringstream c; c << i; std::string tempName; tempName = "Gradient_" + c.str() + ".nii.gz"; gradientImageWriter->SetFileName(tempName); gradientImageWriter->SetInput(GradientImageList[i]); gradientImageWriter->Update(); } */ //Read GradientImages const string file_gradImage_n = cl.follow("NoFile", 1, "-fG"); std::ifstream fileGImg(file_gradImage_n.c_str()); int numOfGradImages = 0; fileGImg >> numOfGradImages; typedef itk::ImageFileReader<VectorImageType> GradientImageReaderType; typedef std::vector<VectorImageType::Pointer> GradientImageListType; GradientImageListType gradientImageList; /* for (int i=0; i < numOfGradImages; i++) { char filename[25]; fileGImg >> filename; VectorImageType::Pointer gradientImage = VectorImageType::New(); GradientImageReaderType::Pointer gradientImageReader = GradientImageReaderType::New(); gradientImageReader->SetFileName(filename); gradientImageReader->Update(); gradientImageList.push_back(gradientImageReader->GetOutput()) ; std::cout << "Reading...." << filename << std::endl; }*/ // Compute the matrix MapFilterLR2HRDisp filter; filter.ReadFixedImage(T1_image); // filter.ReadMovingImage(B0_image_LR); filter.ReadDeformationField(defField); filter.ReadMaskImage(maskSpatial_HR); filter.ComputeMapWithDefField(); vnl_sparse_matrix<float> MapLR2HR, MapHR2LR; MapLR2HR = filter.GetLR2HRMatrix(); MapHR2LR = filter.GetHR2LRMatrix(); std::cout << "Computing Map done " << std::endl; std::cout << B0_image_LR->GetLargestPossibleRegion().GetSize() << std::endl; // // ComposeImageFilter composeFilter; // composeFilter.GetHRImage(T1_image); // composeFilter.GetLRImage(B0_image_LR); // composeFilter.ReadMatrix(MapLR2HR); // // ScalarImageType::Pointer tempImage1 = composeFilter.ComposeIt(); // std::cout << "Composing done " << std::endl; // // typedef itk::ImageFileWriter<ScalarImageType> ScalarWriterType; // ScalarWriterType::Pointer scalarWriter = ScalarWriterType::New(); // scalarWriter->SetFileName("TempImage.nii.gz"); // scalarWriter->SetInput(tempImage1); // scalarWriter->Update(); /* UnweightedLeastSquaresTensorEstimation UnWeightedTensorEstimator; UnWeightedTensorEstimator.ReadDWIList(DWIList_HR); UnWeightedTensorEstimator.ReadMask(maskImage_HR); UnWeightedTensorEstimator.ReadBVal(1.0); UnWeightedTensorEstimator.ReadGradientList(gradientImageList); UnWeightedTensorEstimator.ReadB0Image(B0Image_HR); typedef itk::DiffusionTensor3D<RealType> DiffusionTensorType; typedef itk::Image<DiffusionTensorType, ImageDim> TensorImageType; TensorImageType::Pointer tensorImage_init = UnWeightedTensorEstimator.Compute(); typedef itk::ImageFileWriter<TensorImageType> TensorWriterType; TensorWriterType::Pointer tensorWriter = TensorWriterType::New(); tensorWriter->SetFileName("TensorImage.nii.gz"); tensorWriter->SetInput(tensorImage_init); tensorWriter->Update(); //Compute Sigma vnl_vector<RealType> Sigma; // Compute Joint Estimation // JointTensorEstimation jTestimation; // jTestimation.ReadBVal(1.0); // jTestimation.ReadDWIList(DWIList_HR); // jTestimation.ReadMaskImage(maskImage_HR); // jTestimation.ReadB0Image(B0Image_HR); // jTestimation.ReadGradientList(gradientImageList); // jTestimation.ReadInitialTensorImage(tensorImage_init); // jTestimation.ReadKappa(kappa_L); */ return 0; }
int main (int argc, char **argv) { GetPot cl (argc, argv); if (cl.search (2, "-h", "--help")) { std::cerr << help_text << std::endl; return 0; } const double a = cl.follow (0.0, "-a"); const double b = cl.follow (1.0, "-b"); const unsigned int nnodes = cl.follow (100, 2, "-n", "--nnodes"); const std::string diffusion = cl.follow ("1.0", 2, "-d", "--diffusion"); const std::string forcing = cl.follow ("1.0", 2, "-f", "--forcing"); coeff f_coeff (forcing); coeff a_coeff (diffusion); const std::string quadrature = cl.follow ("trapezoidal.so", 2, "-q", "--quadrature-rule"); std::function <void ()> r_r; void * handle = dlopen (quadrature.c_str (), RTLD_NOW); if (! handle) { std::cerr << "fem1d: cannot load dynamic object!" << std::endl; std::cerr << dlerror () << std::endl; return (-1); } void * sym = dlsym (handle, "register_rules"); if (! sym) { std::cerr << "fem1d: cannot load symbol!" << std::endl; std::cerr << dlerror () << std::endl; return (-1); } r_r = reinterpret_cast <void (*) ()> (sym); r_r (); auto & the_factory = quadrature_factory::instance (); auto integrate = the_factory.create ("trapezoidal"); if (! integrate) { std::cerr << "rule name unknown" << std::endl; return (-1); } mesh m (a, b, nnodes); Eigen::SparseMatrix<double> A(nnodes, nnodes); Eigen::Matrix2d mloc; mloc << 0, 0, 0, 0; for (unsigned int iel = 0; iel < m.nels; ++iel) { mloc << 0, 0, 0, 0; for (unsigned int inode = 0; inode < 2; ++inode) { auto igrad = [=, &m] (double x) -> double { return basisfungrad (x, m.nodes[m.elements[iel][0]], m.nodes[m.elements[iel][1]], inode == 0 ? 1.0 : 0.0, inode == 1 ? 1.0 : 0.0); }; for (unsigned int jnode = 0; jnode < 2; ++jnode) { auto jgrad = [=, &m] (double x) -> double { return basisfungrad (x, m.nodes[m.elements[iel][0]], m.nodes[m.elements[iel][1]], jnode == 0 ? 1.0 : 0.0, jnode == 1 ? 1.0 : 0.0); }; mloc(inode,jnode) += (*integrate) ([=, &m, &igrad, &jgrad, &a_coeff] (double x) -> double { return (igrad (x) * jgrad (x) * a_coeff (x)); }, m.nodes[m.elements[iel][0]], m.nodes[m.elements[iel][1]]); A.coeffRef(m.elements[iel][inode], m.elements[iel][jnode]) += mloc(inode,jnode); } } } Eigen::VectorXd f(nnodes); for (unsigned int ii = 0; ii < nnodes; ++ii) f(ii) = 0.0; Eigen::Vector2d vloc; for (unsigned int iel = 0; iel < m.nels; ++iel) { vloc << 0, 0; for (unsigned int inode = 0; inode < 2; ++inode) { auto ifun = [=, &m] (double x) -> double { return basisfun (x, m.nodes[m.elements[iel][0]], m.nodes[m.elements[iel][1]], inode == 0 ? 1.0 : 0.0, inode == 1 ? 1.0 : 0.0); }; vloc(inode) += (*integrate) ([=, &m, &ifun, &f_coeff] (double x) -> double { return (ifun (x) * f_coeff (x)); }, m.nodes[m.elements[iel][0]], m.nodes[m.elements[iel][1]]); f(m.elements[iel][inode]) += vloc(inode); } } f(0) = 0; f(nnodes - 1) = 0; A.coeffRef(0,0) = 1.0e10; A.coeffRef(nnodes-1,nnodes-1) = 1.0e10; for (unsigned int ii = 1; ii < nnodes; ++ii) { A.coeffRef(0, ii) = 0.0; A.coeffRef(nnodes-1, nnodes-1-ii) = 0.0; } Eigen::SparseLU<Eigen::SparseMatrix<double>> solver; A.makeCompressed (); solver.analyzePattern(A); solver.factorize(A); Eigen::VectorXd uh = solver.solve (f); for (unsigned int ii = 0; ii < nnodes; ++ii) std::cout << m.nodes[ii] << " " << uh(ii, 0) << std:: endl; return 0; };
int main (int argc, char *argv[]) { const unsigned int ImageDimension = 2; GetPot cl (argc, const_cast<char**>(argv)); if( cl.size() == 1 || cl.search (2,"--help","-h") ) { std::cout << "Not Enough Arguments" << std::endl; std::cout << "Generate the Gradient Table" << std::endl; std::cout << "Usage: return -1" << std::endl; } const string image_n = cl.follow("NoFile",1, "-i"); const string mask_n = cl.follow("NoFile", 1, "-m"); const string out_n = cl.follow("NoFile",1, "-o"); typedef itk::DiffusionTensor3D<float> DiffusionTensorType; typedef itk::Image<DiffusionTensorType, 3> TensorImageType; typedef itk::ImageFileReader<TensorImageType> TensorReaderType; TensorReaderType::Pointer reader = TensorReaderType::New(); reader->SetFileName(image_n.c_str()); reader->Update(); TensorImageType::Pointer image = reader->GetOutput(); typedef itk::Image<float, 3> ScalarImageType; typedef itk::ImageFileReader<ScalarImageType> ScalarReaderType; ScalarReaderType::Pointer scalarReader = ScalarReaderType::New(); scalarReader->SetFileName(mask_n.c_str()); scalarReader->Update(); ScalarImageType::Pointer maskImage = scalarReader->GetOutput(); typedef itk::ImageRegionIterator<TensorImageType> TensorIterator; typedef itk::ImageRegionIterator<ScalarImageType> ScalarIterator; ScalarIterator itMask(maskImage, maskImage->GetLargestPossibleRegion()); TensorUtilities utilsTensor; TensorImageType::Pointer logTensorImage = utilsTensor.LogTensorImageFilter(image, maskImage); typedef itk::ImageFileWriter<TensorImageType> TensorImageWriterType; TensorImageWriterType::Pointer tensorImageWriter = TensorImageWriterType::New(); tensorImageWriter->SetFileName("LogTensorImage_stupid.nii.gz"); tensorImageWriter->SetInput(logTensorImage); tensorImageWriter->Update(); std::ofstream file; file.open(out_n); ScalarImageType::Pointer TraceImage = ScalarImageType::New(); CopyImage cpImage; cpImage.CopyScalarImage(maskImage, TraceImage); ScalarIterator itTr(TraceImage, TraceImage->GetLargestPossibleRegion()); TensorIterator itImg(logTensorImage, logTensorImage->GetLargestPossibleRegion()); for(itImg.GoToBegin(), itMask.GoToBegin(), itTr.GoToBegin(); !itTr.IsAtEnd(), !itImg.IsAtEnd(), !itMask.IsAtEnd(); ++itTr, ++itImg, ++itMask) { file << itImg.Get().GetTrace() << std::endl; itTr.Set(itImg.Get().GetTrace()) ; } typedef itk::ImageFileWriter<ScalarImageType> WriterType; WriterType::Pointer writer = WriterType::New(); writer->SetFileName("LogTense_Trace.nii.gz"); writer->SetInput(TraceImage); writer->Update(); file.close(); return 0; }
int main (int argc, char **argv) { GetPot cl (argc, argv); if (cl.search (2, "-h", "--help")) { std::cerr << help_text << std::endl; return 0; } const double a = cl.follow (double (0.0), "-a"); const double b = cl.follow (double (1.0), "-b"); const unsigned int nnodes = cl.follow (100, 2, "-n", "--nnodes"); const unsigned int nel = nnodes - 1; const std::string diffusion = cl.follow ("1.0", 2, "-d", "--diffusion"); const std::string forcing = cl.follow ("1.0", 2, "-f", "--forcing"); const double tol = 1e-6; const unsigned int maxit = 43; const unsigned int overlap = 3; const double L = b - a; const int mpi_size = 3; const double L_loc = L / double (mpi_size); const double h = L_loc / ceil (double(nel) / double(mpi_size)); std::vector<double> a_loc (mpi_size); std::vector<double> b_loc (mpi_size); std::vector<unsigned int> nel_loc (mpi_size); std::vector<unsigned int> ndof_loc (mpi_size); std::vector<fem_1d<double>*> subproblems (mpi_size); coeff<double> a_coeff (diffusion); coeff<double> f_coeff (forcing); int mpi_rank; for (mpi_rank = 0; mpi_rank < mpi_size; ++mpi_rank) { a_loc[mpi_rank] = a + mpi_rank * L_loc; b_loc[mpi_rank] = a_loc[mpi_rank] + L_loc; nel_loc[mpi_rank] = ceil (double(nel) / double(mpi_size)); if (mpi_rank > 0) { a_loc[mpi_rank] -= overlap * h; nel_loc[mpi_rank] += overlap; } if (mpi_rank < mpi_size - 1) { b_loc[mpi_rank] += overlap * h; nel_loc[mpi_rank] += overlap; } ndof_loc[mpi_rank] = nel_loc[mpi_rank] + 1; fem_1d<double>* tmp = new fem_1d<double>(new mesh<double> (a_loc[mpi_rank], b_loc[mpi_rank], ndof_loc[mpi_rank])); subproblems[mpi_rank] = tmp; subproblems[mpi_rank]->set_diffusion_coefficient (a_coeff); subproblems[mpi_rank]->set_source_coefficient (f_coeff); subproblems[mpi_rank]->assemble (); subproblems[mpi_rank]->set_dirichlet (fem_1d<double>::left_boundary, 0.0); subproblems[mpi_rank]->set_dirichlet (fem_1d<double>::right_boundary, 0.0); subproblems[mpi_rank]->solve (); }; for (unsigned int it = 0; it < maxit; ++it) for (mpi_rank = 0; mpi_rank < mpi_size; ++mpi_rank) { if (mpi_rank > 0) subproblems[mpi_rank]->set_dirichlet (fem_1d<double>::left_boundary, subproblems[mpi_rank-1]->result () [ndof_loc[mpi_rank-1]-1-2*overlap]); else subproblems[mpi_rank]->set_dirichlet (fem_1d<double>::left_boundary, 0.0); if (mpi_rank < mpi_size - 1) subproblems[mpi_rank]->set_dirichlet (fem_1d<double>::right_boundary, subproblems[mpi_rank+1]->result () [2*overlap]); else subproblems[mpi_rank]->set_dirichlet (fem_1d<double>::right_boundary, 0.0); subproblems[mpi_rank]->solve (); } for (mpi_rank = 0; mpi_rank < mpi_size; ++mpi_rank) for (unsigned int ii = 0; ii < ndof_loc[mpi_rank]; ++ii) std::cout << subproblems[mpi_rank]->m->nodes[ii] << " " << subproblems[mpi_rank]->result ()(ii, 0) << std::endl; return 0; };
int main (int argc, char **argv) { MPI_Init (&argc, &argv); GetPot cl (argc, argv); if (cl.search (2, "-h", "--help")) { std::cerr << help_text << std::endl; return 0; } const double a = cl.follow (double (0.0), "-a"); const double b = cl.follow (double (1.0), "-b"); const unsigned int nnodes = cl.follow (100, 2, "-n", "--nnodes"); const unsigned int nel = nnodes - 1; const std::string diffusion = cl.follow ("1.0", 2, "-d", "--diffusion"); const std::string forcing = cl.follow ("1.0", 2, "-f", "--forcing"); const double L = b - a; constexpr double tol = 1e-6; constexpr unsigned int maxit = 100; constexpr unsigned int overlap = 100; MPI_Status status; int mpi_size, mpi_rank, tag; MPI_Comm_size (MPI_COMM_WORLD, &mpi_size); MPI_Comm_rank (MPI_COMM_WORLD, &mpi_rank); const double L_loc = L / double(mpi_size); const double h = L_loc / ceil (double(nel) / double(mpi_size)); double a_loc = .0; double lval = .0; double b_loc = .0; double rval = .0; double buffer = .0; unsigned int nel_loc = 0; unsigned int ndof_loc = 1; fem_1d<double> *subproblems; coeff<double> a_coeff (diffusion); coeff<double> f_coeff (forcing); a_loc = a + mpi_rank * L_loc; b_loc = a_loc + L_loc; nel_loc = ceil (double(nel) / double(mpi_size)); if (mpi_rank > 0) { a_loc -= overlap * h; nel_loc += overlap; } if (mpi_rank < mpi_size - 1) { b_loc += overlap * h; nel_loc += overlap; } ndof_loc = nel_loc + 1; subproblems = new fem_1d<double> (new mesh<double> (a_loc, b_loc, ndof_loc)); subproblems->set_diffusion_coefficient (a_coeff); subproblems->set_source_coefficient (f_coeff); subproblems->assemble (); subproblems->set_dirichlet (fem_1d<double>::left_boundary, 0.0); subproblems->set_dirichlet (fem_1d<double>::right_boundary, 0.0); subproblems->solve (); for (unsigned int it = 0; it < maxit; ++it) { // With the following implementation // communication will occur sequentailly // left to right first then right to left // Receive from left neighbour if (mpi_rank > 0) { std::cerr << "rank " << mpi_rank << " receiving lval from rank " << mpi_rank - 1 << std::endl; MPI_Recv (&buffer, 1, MPI_DOUBLE, mpi_rank - 1, MPI_ANY_TAG, MPI_COMM_WORLD, &status); std::cerr << "rank " << mpi_rank << " received lval from rank " << mpi_rank - 1 << std::endl; lval = buffer; } tag = 10*mpi_rank; // Send to right neighbour if (mpi_rank < mpi_size - 1) { buffer = subproblems->result () [ndof_loc - 1 - 2*overlap]; std::cerr << "rank " << mpi_rank << " sending lval to rank " << mpi_rank + 1 << std::endl; MPI_Send (&buffer, 1, MPI_DOUBLE, mpi_rank + 1, tag, MPI_COMM_WORLD); std::cerr << "rank " << mpi_rank << " sent lval to rank " << mpi_rank + 1 << std::endl; } // Receive from right neighbour if (mpi_rank < mpi_size - 1) { std::cerr << "rank " << mpi_rank << " receiving rval from rank " << mpi_rank + 1 << std::endl; MPI_Recv (&buffer, 1, MPI_DOUBLE, mpi_rank + 1, MPI_ANY_TAG, MPI_COMM_WORLD, &status); std::cerr << "rank " << mpi_rank << " received rval from rank " << mpi_rank + 1 << std::endl; rval = buffer; } tag = 10*mpi_rank + 1; // Send to right neighbour if (mpi_rank > 0) { buffer = subproblems->result () [2*overlap]; std::cerr << "rank " << mpi_rank << " sending rval to rank " << mpi_rank - 1 << std::endl; MPI_Send (&buffer, 1, MPI_DOUBLE, mpi_rank - 1, tag, MPI_COMM_WORLD); std::cerr << "rank " << mpi_rank << " sent rval to rank " << mpi_rank - 1 << std::endl; } subproblems->set_dirichlet (fem_1d<double>::left_boundary, lval); subproblems->set_dirichlet (fem_1d<double>::right_boundary, rval); subproblems->solve (); } for (int rank = 0; rank < mpi_size; ++rank) { if (rank == mpi_rank) for (unsigned int ii = 0; ii < ndof_loc; ++ii) std::cout << subproblems->m->nodes[ii] << " " << subproblems->result ()(ii, 0) << std::endl; MPI_Barrier (MPI_COMM_WORLD); } MPI_Finalize (); return 0; };
Int main ( Int argc, char** argv ) { //Setup main communicator boost::shared_ptr< Epetra_Comm > comm; //Setup MPI variables Int numberOfProcesses (1); Int rank (0); #ifdef HAVE_MPI MPI_Init ( &argc, &argv ); MPI_Comm_size ( MPI_COMM_WORLD, &numberOfProcesses ); MPI_Comm_rank ( MPI_COMM_WORLD, &rank ); #endif if ( rank == 0 ) { std::cout << std::endl; std::cout << "$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$" << std::endl; std::cout << " THE ZERO DIMENSIONAL SOLVER IS AN ALPHA VERSION UNDER STRONG DEVELOPMENT" << std::endl; std::cout << "$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$" << std::endl << std::endl; std::cout << "MPI Processes: " << numberOfProcesses << std::endl; } #ifdef HAVE_MPI if ( numberOfProcesses > 1 ) { if ( rank == 0 ) { std::cout << "test_ZeroDimensional not enabled in parallel, failing gracefully." << std::endl; std::cout << "MPI Finalization" << std::endl; } MPI_Finalize(); return EXIT_FAILURE; } #endif #ifdef EPETRA_MPI if ( rank == 0 ) { std::cout << "MPI Epetra Initialization ... " << std::endl; } comm.reset ( new Epetra_MpiComm ( MPI_COMM_WORLD ) ); #else std::cout << "SERIAL Epetra Initialization ... " << std::endl; comm.reset ( new Epetra_SerialComm() ); #endif bool exitFlag = EXIT_SUCCESS; #if ( defined(HAVE_NOX_THYRA) && defined(HAVE_TRILINOS_RYTHMOS) ) // Command line parameters GetPot commandLine ( argc, argv ); const bool check = commandLine.search ( 2, "-c", "--check" ); string fileName = commandLine.follow ( "data", 2, "-f", "--file" ); // SetupData GetPot dataFile ( fileName + ".dat" ); std::string circuitDataFile = dataFile ( "0D_Model/CircuitDataFile", "./inputFile.dat" ); BCInterface0D< ZeroDimensionalBCHandler, ZeroDimensionalData > zeroDimensionalBC; zeroDimensionalBC.createHandler(); zeroDimensionalBC.fillHandler ( circuitDataFile, "Files" ); boost::shared_ptr< ZeroDimensionalData > zeroDimensionalData ( new ZeroDimensionalData ); zeroDimensionalData->setup ( dataFile, zeroDimensionalBC.handler() ); boost::shared_ptr< ZeroDimensionalSolver > zeroDimensionalSolver ( new ZeroDimensionalSolver ( zeroDimensionalData->unknownCounter(), comm, zeroDimensionalData->circuitData() ) ); zeroDimensionalSolver->setup ( zeroDimensionalData->solverData() ); zeroDimensionalData->showMe(); // SetupModel zeroDimensionalData->dataTime()->setInitialTime (0); zeroDimensionalData->initializeSolution(); // Create output folder if ( comm->MyPID() == 0 ) { mkdir ( "output", 0777 ); } // Save initial solution zeroDimensionalData->saveSolution(); zeroDimensionalData->dataTime()->updateTime(); zeroDimensionalData->dataTime()->setInitialTime (zeroDimensionalData->dataTime()->time() ); // Definitions for the time loop LifeChrono chronoTotal; LifeChrono chronoSystem; LifeChrono chronoIteration; Int count = 0; chronoTotal.start(); for ( ; zeroDimensionalData->dataTime()->canAdvance() ; zeroDimensionalData->dataTime()->updateTime(), ++count ) { std::cout << std::endl << "--------- Iteration " << count << " time = " << zeroDimensionalData->dataTime()->time() << std::endl; chronoIteration.start(); chronoSystem.start(); zeroDimensionalSolver->takeStep ( zeroDimensionalData->dataTime()->previousTime(), zeroDimensionalData->dataTime()->time() ); chronoSystem.stop(); //Save solution zeroDimensionalData->saveSolution(); chronoIteration.stop(); std::cout << " System solved in " << chronoSystem.diff() << " s, (total time " << chronoIteration.diff() << " s)." << std::endl; } chronoTotal.stop(); std::cout << std::endl << " Simulation ended successfully in " << chronoTotal.diff() << " s" << std::endl; // Final check if ( check ) { bool ok = true; ok = ok && checkValue ( 0.001329039627, zeroDimensionalData->circuitData()->Nodes()->nodeListAt (1)->voltage() ); ok = ok && checkValue ( 0.000787475119, zeroDimensionalData->circuitData()->Elements()->elementListAt (1)->current() ); if (ok) { std::cout << " Test succesful" << std::endl; exitFlag = EXIT_SUCCESS; } else { std::cout << " Test unsuccesful" << std::endl; exitFlag = EXIT_FAILURE; } } #else std::cout << "ZeroDimensional requires configuring Trilinos with Rythmos/NOX/Thyra. Skipping test." << std::endl; exitFlag = EXIT_SUCCESS; #endif /* HAVE_NOX_THYRA && HAVE_TRILINOS_RYTHMOS */ if (rank == 0) { std::cout << "End Result: TEST PASSED" << std::endl; } #ifdef HAVE_MPI if ( rank == 0 ) { std::cout << "MPI Finalization" << std::endl; } MPI_Finalize(); #endif return exitFlag; }