void MultiPlasticityDebugger::fddyieldFunction_dintnl(const RankTwoTensor & stress, const std::vector<Real> & intnl, std::vector<Real> & df_dintnl) { df_dintnl.resize(_num_surfaces); std::vector<bool> act; act.assign(_num_surfaces, true); std::vector<Real> origf; yieldFunction(stress, intnl, act, origf); std::vector<Real> intnlep; intnlep.resize(_num_models); for (unsigned model = 0; model < _num_models; ++model) intnlep[model] = intnl[model]; Real ep; std::vector<Real> fep; unsigned int model; for (unsigned surface = 0; surface < _num_surfaces; ++surface) { model = modelNumber(surface); ep = _fspb_debug_intnl_change[model]; intnlep[model] += ep; yieldFunction(stress, intnlep, act, fep); df_dintnl[surface] = (fep[surface] - origf[surface])/ep; intnlep[model] -= ep; } }
void MultiPlasticityDebugger::fddflowPotential_dintnl(const RankTwoTensor & stress, const std::vector<Real> & intnl, std::vector<RankTwoTensor> & dr_dintnl) { dr_dintnl.resize(_num_surfaces); std::vector<bool> act; act.assign(_num_surfaces, true); std::vector<RankTwoTensor> origr; flowPotential(stress, intnl, act, origr); std::vector<Real> intnlep; intnlep.resize(_num_models); for (unsigned model = 0; model < _num_models; ++model) intnlep[model] = intnl[model]; Real ep; std::vector<RankTwoTensor> rep; unsigned int model; for (unsigned surface = 0; surface < _num_surfaces; ++surface) { model = modelNumber(surface); ep = _fspb_debug_intnl_change[model]; intnlep[model] += ep; flowPotential(stress, intnlep, act, rep); dr_dintnl[surface] = (rep[surface] - origr[surface])/ep; intnlep[model] -= ep; } }
void MultiPlasticityLinearSystem::calculateJacobian(const RankTwoTensor & stress, const std::vector<Real> & intnl, const std::vector<Real> & pm, const RankFourTensor & E_inv, const std::vector<bool> & active, const std::vector<bool> & deactivated_due_to_ld, std::vector<std::vector<Real> > & jac) { // see comments at the start of .h file mooseAssert(intnl.size() == _num_models, "Size of intnl is " << intnl.size() << " which is incorrect in calculateJacobian"); mooseAssert(pm.size() == _num_surfaces, "Size of pm is " << pm.size() << " which is incorrect in calculateJacobian"); mooseAssert(active.size() == _num_surfaces, "Size of active is " << active.size() << " which is incorrect in calculateJacobian"); mooseAssert(deactivated_due_to_ld.size() == _num_surfaces, "Size of deactivated_due_to_ld is " << deactivated_due_to_ld.size() << " which is incorrect in calculateJacobian"); unsigned ind = 0; unsigned active_surface_ind = 0; std::vector<bool> active_surface(_num_surfaces); // active and not deactivated_due_to_ld for (unsigned surface = 0 ; surface < _num_surfaces ; ++surface) active_surface[surface] = (active[surface] && !deactivated_due_to_ld[surface]); unsigned num_active_surface = 0; for (unsigned surface = 0 ; surface < _num_surfaces ; ++surface) if (active_surface[surface]) num_active_surface++; std::vector<bool> active_model(_num_models); // whether a model has surfaces that are active and not deactivated_due_to_ld for (unsigned model = 0 ; model < _num_models ; ++model) active_model[model] = anyActiveSurfaces(model, active_surface); unsigned num_active_model = 0; for (unsigned model = 0 ; model < _num_models ; ++model) if (active_model[model]) num_active_model++; ind = 0; std::vector<unsigned int> active_model_index(_num_models); for (unsigned model = 0 ; model < _num_models ; ++model) if (active_model[model]) active_model_index[model] = ind++; else active_model_index[model] = _num_models+1; // just a dummy, that will probably cause a crash if something goes wrong std::vector<RankTwoTensor> df_dstress; dyieldFunction_dstress(stress, intnl, active_surface, df_dstress); std::vector<Real> df_dintnl; dyieldFunction_dintnl(stress, intnl, active_surface, df_dintnl); std::vector<RankTwoTensor> r; flowPotential(stress, intnl, active, r); std::vector<RankFourTensor> dr_dstress; dflowPotential_dstress(stress, intnl, active, dr_dstress); std::vector<RankTwoTensor> dr_dintnl; dflowPotential_dintnl(stress, intnl, active, dr_dintnl); std::vector<Real> h; hardPotential(stress, intnl, active, h); std::vector<RankTwoTensor> dh_dstress; dhardPotential_dstress(stress, intnl, active, dh_dstress); std::vector<Real> dh_dintnl; dhardPotential_dintnl(stress, intnl, active, dh_dintnl); // d(epp)/dstress = sum_{active alpha} pm[alpha]*dr_dstress RankFourTensor depp_dstress; ind = 0; for (unsigned surface = 0 ; surface < _num_surfaces ; ++surface) if (active[surface]) // includes deactivated_due_to_ld depp_dstress += pm[surface]*dr_dstress[ind++]; depp_dstress += E_inv; // d(epp)/dpm_{active_surface_index} = r_{active_surface_index} std::vector<RankTwoTensor> depp_dpm; depp_dpm.resize(num_active_surface); ind = 0; active_surface_ind = 0; for (unsigned surface = 0 ; surface < _num_surfaces ; ++surface) { if (active[surface]) { if (active_surface[surface]) // do not include the deactived_due_to_ld, since their pm are not dofs in the NR depp_dpm[active_surface_ind++] = r[ind]; ind++; } } // d(epp)/dintnl_{active_model_index} = sum(pm[asdf]*dr_dintnl[fdsa]) std::vector<RankTwoTensor> depp_dintnl; depp_dintnl.assign(num_active_model, RankTwoTensor()); ind = 0; for (unsigned surface = 0 ; surface < _num_surfaces ; ++surface) { if (active[surface]) { unsigned int model_num = modelNumber(surface); if (active_model[model_num]) // only include models with surfaces which are still active after deactivated_due_to_ld depp_dintnl[active_model_index[model_num]] += pm[surface]*dr_dintnl[ind]; ind++; } } // df_dstress has been calculated above // df_dpm is always zero // df_dintnl has been calculated above, but only the active_surface+active_model stuff needs to be included in Jacobian: see below std::vector<RankTwoTensor> dic_dstress; dic_dstress.assign(num_active_model, RankTwoTensor()); ind = 0; for (unsigned surface = 0 ; surface < _num_surfaces ; ++surface) { if (active[surface]) { unsigned int model_num = modelNumber(surface); if (active_model[model_num]) // only include ic for models with active_surface (ie, if model only contains deactivated_due_to_ld don't include it) dic_dstress[active_model_index[model_num]] += pm[surface]*dh_dstress[ind]; ind++; } } std::vector<std::vector<Real> > dic_dpm; dic_dpm.resize(num_active_model); ind = 0; active_surface_ind = 0; for (unsigned model = 0 ; model < num_active_model ; ++model) dic_dpm[model].assign(num_active_surface, 0); for (unsigned surface = 0 ; surface < _num_surfaces ; ++surface) { if (active[surface]) { if (active_surface[surface]) // only take derivs wrt active-but-not-deactivated_due_to_ld pm { unsigned int model_num = modelNumber(surface); // if (active_model[model_num]) // do not need this check as if the surface has active_surface, the model must be deemed active! dic_dpm[active_model_index[model_num]][active_surface_ind] = h[ind]; active_surface_ind++; } ind++; } } std::vector<std::vector<Real> > dic_dintnl; dic_dintnl.resize(num_active_model); for (unsigned model = 0 ; model < num_active_model ; ++model) { dic_dintnl[model].assign(num_active_model, 0); dic_dintnl[model][model] = 1; // deriv wrt internal parameter } ind = 0; for (unsigned surface = 0 ; surface < _num_surfaces ; ++surface) { if (active[surface]) { unsigned int model_num = modelNumber(surface); if (active_model[model_num]) // only the models that contain surfaces that are still active after deactivation_due_to_ld dic_dintnl[active_model_index[model_num]][active_model_index[model_num]] += pm[surface]*dh_dintnl[ind]; ind++; } } unsigned int dim = 3; unsigned int system_size = 6 + num_active_surface + num_active_model; // "6" comes from symmeterizing epp jac.resize(system_size); for (unsigned i = 0 ; i < system_size ; ++i) jac[i].assign(system_size, 0); unsigned int row_num = 0; unsigned int col_num = 0; for (unsigned i = 0 ; i < dim ; ++i) for (unsigned j = 0 ; j <= i ; ++j) { for (unsigned k = 0 ; k < dim ; ++k) for (unsigned l = 0 ; l <= k ; ++l) jac[col_num][row_num++] = depp_dstress(i, j, k, l) + (k != l ? depp_dstress(i, j, l, k) : 0); // extra part is needed because i assume dstress(i, j) = dstress(j, i) for (unsigned surface = 0 ; surface < num_active_surface ; ++surface) jac[col_num][row_num++] = depp_dpm[surface](i, j); for (unsigned a = 0 ; a < num_active_model ; ++a) jac[col_num][row_num++] = depp_dintnl[a](i, j); row_num = 0; col_num++; } ind = 0; for (unsigned surface = 0 ; surface < _num_surfaces ; ++surface) if (active_surface[surface]) { for (unsigned k = 0 ; k < dim ; ++k) for (unsigned l = 0 ; l <= k ; ++l) jac[col_num][row_num++] = df_dstress[ind](k, l) + (k != l ? df_dstress[ind](l, k) : 0); // extra part is needed because i assume dstress(i, j) = dstress(j, i) for (unsigned beta = 0 ; beta < num_active_surface ; ++beta) jac[col_num][row_num++] = 0; // df_dpm for (unsigned model = 0 ; model < _num_models ; ++model) if (active_model[model]) // only use df_dintnl for models in active_model { if (modelNumber(surface) == model) jac[col_num][row_num++] = df_dintnl[ind]; else jac[col_num][row_num++] = 0; } ind++; row_num = 0; col_num++; } for (unsigned a = 0 ; a < num_active_model ; ++a) { for (unsigned k = 0 ; k < dim ; ++k) for (unsigned l = 0 ; l <= k ; ++l) jac[col_num][row_num++] = dic_dstress[a](k, l) + (k != l ? dic_dstress[a](l, k) : 0); // extra part is needed because i assume dstress(i, j) = dstress(j, i) for (unsigned alpha = 0 ; alpha < num_active_surface ; ++alpha) jac[col_num][row_num++] = dic_dpm[a][alpha]; for (unsigned b = 0 ; b < num_active_model ; ++b) jac[col_num][row_num++] = dic_dintnl[a][b]; row_num = 0; col_num++; } mooseAssert(col_num == system_size, "Incorrect filling of cols in Jacobian"); }
int main(int argc, char** argv) { int x,y,z; std::string serial(""); std::string desc(""); std::string info = ""; std::string modelNumber(""); char filename[256]; const char *dir = "/tmp"; const char *extension = "tiff"; bool canSetTemp; bool hasFilters; short binX; short binY; long xsize; long ysize; long startX; long startY; int iNumFound; bool tiffoutput = false; bool fitsoutput = false; int c; while (EOF != (c = getopt(argc, argv, "tfd:"))) switch (c) { case 't': #if HAVE_TIFFIO_H tiffoutput = true; #else std::cerr << "no TIFF support" << std::endl; exit(EXIT_FAILURE); #endif break; case 'f': #if HAVE_FITSIO_H fitsoutput = true; #else std::cerr << "no FITS support" << std::endl; exit(EXIT_FAILURE); #endif break; case 'd': dir = optarg; break; } // for compatibility, of no option was present, and we have TIFF // support, then we use tiff output #if HAVE_TIFFIO_H if ((!tiffoutput) && (!fitsoutput)) { tiffoutput = true; } #endif if ((tiffoutput) && (fitsoutput)) { std::cerr << "you cannot request both TIFF and FITS." << std::endl; exit(EXIT_FAILURE); } if (fitsoutput) { extension = "fits"; } QSICamera cam; cam.put_UseStructuredExceptions(true); try { cam.get_DriverInfo(info); std::cout << "qsiapi version: " << info << "\n"; //Discover the connected cameras std::string camSerial[QSICamera::MAXCAMERAS]; std::string camDesc[QSICamera::MAXCAMERAS]; cam.get_AvailableCameras(camSerial, camDesc, iNumFound); if (iNumFound < 1) { std::cout << "No cameras found\n"; exit(1); } for (int i = 0; i < iNumFound; i++) { std::cout << camSerial[i] << ":" << camDesc[i] << "\n"; } cam.put_SelectCamera(camSerial[0]); cam.put_IsMainCamera(true); // Connect to the selected camera and retrieve camera parameters cam.put_Connected(true); std::cout << "Camera connected. \n"; // Get Model Number cam.get_ModelNumber(modelNumber); std::cout << modelNumber << "\n"; // Get Camera Description cam.get_Description(desc); std:: cout << desc << "\n"; // Enable the beeper cam.put_SoundEnabled(true); // Enable the indicator LED cam.put_LEDEnabled(true); // Set the fan mode cam.put_FanMode(QSICamera::fanQuiet); // Query the current flush mode setting cam.put_PreExposureFlush(QSICamera::FlushNormal); // Query if the camera can control the CCD temp cam.get_CanSetCCDTemperature(&canSetTemp); if (canSetTemp) { // Set the CCD temp setpoint to 10.0C cam.put_SetCCDTemperature(10.0); // Enable the cooler cam.put_CoolerOn(true); } if (modelNumber.substr(0,1) == "6") { cam.put_ReadoutSpeed(QSICamera::FastReadout); } // Does the camera have a filer wheel? cam.get_HasFilterWheel(&hasFilters); if ( hasFilters) { // Set the filter wheel to position 1 (0 based position) cam.put_Position(0); } if (modelNumber.substr(0,3) == "520" || modelNumber.substr(0,3) == "540") { cam.put_CameraGain(QSICamera::CameraGainHigh); cam.put_PreExposureFlush(QSICamera::FlushNormal); } // ////////////////////////////////////////////////////////////// // Set image size // cam.put_BinX(1); cam.put_BinY(1); // Get the dimensions of the CCD cam.get_CameraXSize(&xsize); cam.get_CameraYSize(&ysize); // Set the exposure to a full frame cam.put_StartX(0); cam.put_StartY(0); cam.put_NumX(xsize); cam.put_NumY(ysize); // take 10 test images for (int i = 0; i < 10; i++) { bool imageReady = false; // Start an exposure, 0 milliseconds long (bias frame), with shutter open cam.StartExposure(0.000, true); // Poll for image completed cam.get_ImageReady(&imageReady); while(!imageReady) { usleep(100); cam.get_ImageReady(&imageReady); } // Get the image dimensions to allocate an image array cam.get_ImageArraySize(x, y, z); unsigned short* image = new unsigned short[x * y]; // Retrieve the pending image from the camera cam.get_ImageArray(image); std::cout << "exposure #" << i; sprintf(filename, "%s/qsiimage%d.%s", dir, i, extension); if (tiffoutput) { #ifdef HAVE_TIFFIO_H WriteTIFF(image, x, y, filename); #endif } else if (fitsoutput) { #ifdef HAVE_FITSIO_H WriteFITS(image, x, y, filename); #endif } std::cout << "\n"; std::cout.flush(); delete [] image; } cam.put_Connected(false); std::cout << "Camera disconnected.\nTest complete.\n"; std::cout.flush(); return 0; } catch (std::runtime_error &err) { std::string text = err.what(); std::cout << text << "\n"; std::string last(""); cam.get_LastError(last); std::cout << last << "\n"; std::cout << "exiting with errors\n"; exit(1); } }